[Haskell-cafe] Re: Can we come out of a monad?
Anton van Straaten
anton at appsolutions.com
Fri Jul 30 07:49:32 EDT 2010
Kevin Jardine wrote:
> As a Haskell newbie, the first thing I learned about monads is that
> they have a type signature that creates a kind of mud you can't wash
> off.
There are places where you can't wash it off, and places where you can.
> eg.
>
> f :: String -> MyMonad String
>
> By mentioning the monad, you get to use its special functions but as a
> hard price, you must return a value with a type signature that locks
> it within the monad
That's perfectly correct: "you must return a value with a type signature
that locks it within the monad." That's because you're referring here
to returning a value from a monadic function with a return type of
MyMonad String. But that's just one part of the picture.
Consider a caller of that function: after applying f to some string, it
ends up with a value of type MyMonad String. One of the things you can
typically do with such values is "wash off the mud" using a runner
function, specific to the monad.
They're called runners (informally) because what they do is run the
delayed computation represented by the monad. In the case of the State
monad, the runner takes an initial state and supplies it to the monad in
order to start the computation. If these runners didn't exist, the
monad would be rather useless, because it would never actually execute.
The result of running that computation typically eliminates the monad
type - the mud is washed off.
You can even do this inside a monadic function, e.g.:
g m = do s <- get
let x = evalState m s -- wash the mud off m !
...
But the value of x above will be locked inside the function - you can't
return such values to the caller without using e.g. "return x", to
return a monadic value.
So you may be able to wash the mud off a monadic value, but if you want
to pass that value outside a monadic function you have to put the mud
back on first.
However, if you have a monadic value *outside* a monadic function, no
such rule applies.
> The more I learn about monads, however, the less I understand them.
> I've seen plenty of comments suggesting that monads are easy to
> understand, but for me they are not.
Monads are very general, which means they're not easily learned by the
common style of extrapolating from examples. They're easy to understand
in hindsight though! :-}
Anton
More information about the Haskell-Cafe
mailing list