Rebindable syntax creates bogus warning

{-# LANGUAGE RebindableSyntax #-}


import Data.Void
import Prelude ((.), ($), Int, id, Num(..))


(>>) :: (b -> c) -> (a -> b) -> (a -> c)
(>>) = (.)


return :: Void -> Void
return = absurd


run :: a -> (a -> b) -> b
run x f = f x


result :: Int
result = run 8 $ do
    \n -> n * n
    id
    (+ 7)
    (* 2)

Compile with -Wall issues incorrect warnings. In fact the suggested fixes cause compile errors if implemented.

Test.hs:22:5: Warning:
    A do-notation statement discarded a result of type Int.
    Suppress this warning by saying "_ <- \ n -> (*) n n",
    or by using the flag -fno-warn-unused-do-bind

Test.hs:23:5: Warning:
    A do-notation statement discarded a result of type Int.
    Suppress this warning by saying "_ <- id",
    or by using the flag -fno-warn-unused-do-bind

Test.hs:24:5: Warning:
    A do-notation statement discarded a result of type Int.
    Suppress this warning by saying "_ <- (( \ x_ -> (+) x_ 7))",
    or by using the flag -fno-warn-unused-do-bind

Trac metadata

Trac field	Value
Version	7.6.3
Type	Bug
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system	Windows
Architecture

changed weight to 5

added Tbug Trac import labels

Interesting. I suppose your implicit proposal is that we should suppress the do-notation-related warnings if -XRebindableSyntax is in force?

I'd be ok with that, and it'd be easy to do. Other opinions?

Simon

I'd be fine with simply having the warning suppressed in that case.

Though I could see the warning be useful for rebound do-notation where it makes sense (e.g. monads that have restrictions on their kinds http://blog.omega-prime.co.uk/?p=127).

Just some initial thoughts that may or may not be useful -- concerning conditionally suppressing the warning based on what the syntax is rebound to.

---

Suppose you have the following code, where the code compiles, but line (*) issues the warning

blah = do
    x -- (*)
    y

This desugars to the following that compiles

blah = x >> y

One could, before issuing the warning, internally (and additionally) faux desugar the code to

x >>= (\_ -> y) -- do { x ; y }

This fake translation could be type checked. If the check fails for whatever reason ((>>=) is out of scope, illegally typed expression, whatever), suppress the warning. Otherwise issue it.

This doesn't look Windows-specific.

Trac metadata

Trac field	Value
Operating system	Windows → Unknown/Multiple

Trac metadata

Trac field	Value
Component	Compiler → Compiler (Type checker)

added error messages label

added Pnormal label

Similar story for QualifiedDo. It's possible to come up with a useful thing that has only (>>), so that the warning will instruct the programmer to use a non-existent function (>>=).

{-# LANGUAGE DataKinds #-}

module QualifiedDo where

import GHC.TypeLits

-- Not actually a useful thing, but illustrates the point
data NotMonad (t :: Nat)

incr :: NotMonad 1
incr = undefined

(>>) :: NotMonad s -> NotMonad t -> NotMonad (s + t)
(>>) = undefined

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE QualifiedDo #-}
{-# OPTIONS_GHC "-fwarn-unused-do-bind" #-}

module Example where

import QualifiedDo qualified as Q

example :: Q.NotMonad 2
example = Q.do
  Q.incr
  Q.incr

There will be a warning that

   A do-notation statement discarded a result of type ‘1’
    Suggested fix: Suppress this warning by saying ‘_ <- Q.incr’

but really, there was no result of type 1, and nothing was discarded.

@ani may have opinions here. He is working in this area (e.g. #24406), albeit temporarily in abeyance meeting other deadlines.

I think the fix might be fairly straightforward. Currently we generate warnings based on this oracle: warnUnusedBindValue. It suppresses the warning only for unit types. We should probably suppress the warnings for all those types which have 0 data constructors?

Would it be feasible to check if there's an (>>=) available for the do block in question, and disable the warning if not?

Ah if i understand correctly, the real issue for you is the text message in the warning: Suggested fix: Suppress this warning by saying ‘_ <- Q.incr’. The suggested fix by the compiler is not really the correct fix in your case?

Yes that's part of it, the suggestion is misleading. But more importantly, I don't think there's any suggestion that wouldn't be misleading, because there's really nothing to warn about (because no (>>=) exists).

Here's a somewhat more concrete example:

module QualifiedDo where

data NotMonad t = NotMonad
  {unNotMonad :: t -> Int}

run :: t -> NotMonad t -> Int
run t (NotMonad f) = f t

(>>) :: NotMonad t -> NotMonad t -> NotMonad t
NotMonad l >> NotMonad r = NotMonad $ \t -> l t + r t

bool :: Int -> Int -> NotMonad Bool
bool t f = NotMonad (\b -> if b then t else f)

{-# LANGUAGE QualifiedDo #-}
{-# OPTIONS_GHC "-fwarn-unused-do-bind" #-}

module Example where

import QualifiedDo qualified as Q

example :: Q.NotMonad Bool
example = Q.do
  Q.bool 1 2
  Q.bool 3 4

This is a case where the type (Bool) has more than 1 constructor, but giving a warning about discarding it wouldn't be appropriate because no Bool was actually discarded.

However there is in some sense an Int that's discarded, since every NotMonad sort of "contains" an Int:

(>>=) :: NotMonad t -> (Int -> NotMonad t) -> NotMonad t
NotMonad l >>= k = NotMonad $ \t -> unNotMonad (k (l t)) t

If this function were defined and exported by Q, then the warning could be appropriate/useful, so long as it says Int rather than Bool, since in this expression n :: Int:

example :: Q.NotMonad Bool
example = Q.do
  n <- Q.bool 1 2
  Q.bool n n

So the warning message would have to depend upon the type of the (>>=). If there's no (>>=) and therefore no type, then the warning can't exist.

mentioned in commit 39794569

mentioned in merge request !12465

mentioned in commit 2ef26d79

mentioned in commit 831effee

mentioned in commit cfbc0920