ApplicativeDo not working with sequencing


I have this type, basically a Kleisli arrow:

{-# language DeriveFunctor #-}

data Plan m i o = Plan  (i -> m o) deriving Functor

instance (Monad m) => Applicative (Plan m i) where
    pure x = Plan (\_ -> pure x)
    Plan f <*> Plan x = Plan (\i -> f i <*> x i)

Since it has an Applicative instance, I turn on ApplicativeDo and try to build a value using do-notation:

{-# language ApplicativeDo #-}

myplan :: Plan IO () ()
myplan = do
    pure ()
    pure ()

It doesn't work:

No instance for (Monad (Plan IO ())) arising from a do statement

Is there a way to make it work? I'm using GHC 8.0.1.

Show source
| haskell   | monads   | applicative   | do-notation   2016-12-18 17:12 2 Answers

Answers ( 2 )

  1. 2016-12-18 18:12

    ApplicativeDo does not mean that do expressions will always be desugared in terms of an applicative functor, but only if it makes sense to do so. Here, it does not. If you have a do expression like

      x <- someAction
      y <- someAction
      return (x + y)

    note that the order doesn't really matter, so you could desugar this to

    pure (+) <*> someAction <*> someAction

    instead of

    someAction >>= (\x -> someAction >>= (\y -> return (x + y))

    However, the expression

      pure ()
      pure ()

    doesn't have any way of being expressed using pure and <*> alone. It is not equivalent to pure () <*> pure (), because the first value wraps (), not a function. Since there is no valid way to desugar this using only an Applicative instance, the compiler looks for, and fails to find, a Monad instance to allow pure () >> pure ().

  2. 2016-12-18 23:12

    After searching for ApplicativeDo-related tickets in the GHC Trac, it appears that is is a known problem:

    Explicitly discarding the result is a workaround:

      _ <- pure ()
      pure ()
◀ Go back