How does the bind operator for Eval in Control.Parallel.Strategies evaluate its argument strictly?

Question

The source code for Control.Parallel.Strategies ( http://hackage.haskell.org/packages/archive/parallel/3.1.0.1/doc/html/src/Control-Parallel-Strategies.html#Eval ) contains a type Eval defined as:

data Eval a = Done a

which has the following Monad instance:

instance Monad Eval where
  return x = Done x
  Done x >>= k = k x   -- Note: pattern 'Done x' makes '>>=' strict

Note the comment in the definition of bind. Why is this comment true? My understanding of strictness is that a function is only strict if it must "know something" about its argument. Here, bind just applies k to x, thus it doesn't appear (to me) to need to know anything about x. Further, the comment suggests that strictness is "induced" in the pattern match, before the function is even defined. Can someone help me understand why bind is strict?

Also, it looks like Eval is just the identity Monad and that, given the comment in the definition of bind, bind would be strict for almost any Monad. Is this the case?

Answer 1

It is strict in that m >> n evaluates m, unlike the Identity Monad:

Prelude Control.Parallel.Strategies Control.Monad.Identity> runIdentity (undefined >> return "end") 
"end"
Prelude Control.Parallel.Strategies Control.Monad.Identity> runEval (undefined >> return "end") 
"*** Exception: Prelude.undefined

It is not strict in the value that m produces,w which is what you are pointing out:

Prelude Control.Parallel.Strategies Control.Monad.Identity> runEval (return undefined >> return "end") 
"end"