mapM/concatMapMy

[John Hughes]

	Sengan Baring-Gould writes:

	>Is >>= not lazy?

	since no experts have answered yet, this newbie will answer.
	I think it's strict.

Well, it depends. (>>=) is an overloaded operator, with a different
implementation for every monad -- when you define a monad, you give the
implementation of (>>=). If your implementation is strict (presumably in the
first operand), then (>>=) is strict *at that type*. If your implementation is
lazy, then it isn't. The same goes for (+): at most types (+) is strict, but
if you define your own kind of number with a lazy addition, then on that type
(+) will be lazy.

For many monads, (>>=) *is* strict, which fits with the intuition that it is a
`sequencing' operator. But by no means for all. The simplest counter-example
is the identity monad:

	newtype Id a = Id a

	instance Monad Id where
	  return = Id
	  Id x >>= f = f x

where m>>=f is strict in m only if f is a strict function. A more interesting
example is the state transformer monad:

	newtype ST s a = ST (s -> (a,s))

	instance Monad (ST s) where
	  return x = ST (\s -> (x,s))
	  ST h >>= f = ST (\s -> let (a,s') = h s
				     ST h' = f a
				 in h' s')

where once again, the implementation of (>>=) is strict only if f is a 
strict function. Hence `lazy state' makes sense!

John Hughes