Boost logo

Boost :

From: Brian McNamara (lorgon_at_[hidden])
Date: 2003-10-20 10:40:41

On Mon, Oct 20, 2003 at 10:25:53AM -0400, David Abrahams wrote:
> > [ x+y | x <- [1,2,3], y <- [0,10] ] -- yields [1,11,2,12,3,13]
> >
> > is just syntactic sugar for
> >
> > [1,2,3] `bind` \x ->
> > [0,10] `bind` \y ->
> > unit (x+y)
> I see that happening, and it makes sense... but it's not at all clear
> to me that the Haskell designers have ahold of something fundamental
> and important in that bind signature. It seems somewhat arbitrary.
> > In my experience, you have to do a few passes on monads before it
> > becomes clear how the basic monad stuff is motivated by the final
> > results of using monads.
> I guess I'm wondering how much of the basic monad stuff is motivated
> by the final results in the specific case of the list monad. The
> signature of the "k" function (a -> m b) seems particularly
> suspicious to me.

Let me see if I can allay any suspicions that monad signatures are in
any way list-specific...

In general, given a monad "m", the type "m a" represents a "computation
which will yield a value of type a". (The word "computation" is not
the most intuitive word, but I don't know that there is a better word
which captures the notion of what monads abstract on, and "computation"
seems to be the de facto standard that's used in the papers I've seen
which try to explain monads.)

bind() gives us a way to sequence monad computations. If we have
   comp1 :: m a
   comp2 :: m b
   comp3 :: m c
   f :: a -> b -> c -> r
then we may want to run these computations in sequence and operate on
the results. This is why bind() has the signature it does. A typical
string of operations in a monad looks like this:
   comp1 `bind` \a -> -- run comp1, store result in 'a'
   comp2 `bind` \b -> -- run comp2, store result in 'b'
   comp3 `bind` \c -> -- run comp3, store result in 'c'
   unit (f a b c) -- compute some function of a, b, and c
That whole expression has type "m r".

What bind() buys us (compared to just using functions and lets, like
   let a = c1
       b = c2
       c = c3
   in f a b c
) is that it automatically "plumbs through" the essence of the monad.

It might be helpful to check out
and look at {Identity,Maybe,List,State} in Part II. The state monad, in
particular, is one of the best motivating examples for monads, since
it's so familiar.

-Brian McNamara (lorgon_at_[hidden])

Boost list run by bdawes at, gregod at, cpdaniel at, john at