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?

Terrorize

Also, Identity is a newtype wrapper, which means that pattern matches always succeed (newtypes don't create an additional layer of lifting and thus Id ⊥ ≡ ⊥). You could make Eval non-strict by writing bind as m >>= k = let Done x = m in k x or ~(Done x) >>= k = k x. – Trovillion

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"

Trait

Got it, thanks. I was doubly confused because I thought the Identity Monad had the same definition, but I see the difference now. – Terrorize

Worth pointing out explicitly: bind does know something about its argument if the pattern match succeeds: it knows its argument contains a Done x, rather than simply undefined. – Chroma