Anton van Straaten anton at appsolutions.com
Wed Apr 29 12:33:56 EDT 2009

```michael rice wrote:
> Since I'm trying to learn Monads, let's look at this as a teaching
> moment. The example code (see below), which I pulled off YAMT (Yet
> Another Monad Tutorial ;-)), is the source of my 'comb' function.
>
> I understand the code as it now stands, and I understand that the
> Prelude (>>=) would replace the 'comb'. Adding whatever statements are
> needed, how would you "specialize" the (>>=) to Maybe and solve this
> particular problem.

Saying that "comb is just (>>=) specialized to Maybe" just means that
you can define comb like this:

comb :: Maybe a -> (a -> Maybe b) -> Maybe b
comb = (>>=)

Which also of course means that you can typically use (>>=) instead of
comb.  Although in some cases, being more specific about the type can be
useful.

You can do this sort of specialization for any polymorphic function, e.g.:

-- id is predefined in Haskell, definition given as example
id :: a -> a
id x = x

intID :: Int -> Int
intId = id

In that case, the compiler basically specializes the function for you,
providing a version of it that's specific to Ints.

However, (>>=) is defined by the Monad type class, and as it happens
there's also already a definition for it that's specific to the Maybe
type.  You can see GHC's source for it here:

Not surprisingly, that definition is essentially identical to the
definition of comb:

(Just x) >>= k      = k x
Nothing  >>= _      = Nothing

So defining "comb = (>>=)" just uses that definition.

Anton

```