home1 home2  Bib  Algorithms  Bioinfo  FP  Logic  MML  Prog.Lang and the  Book

FP
Type Classes
Functor
Kernels
?Function?
?Pair?
IO
```class Monad m where
(>>=)  :: m a -> (a -> m b) -> m b
(>>)   :: m a -> m b -> m b
return :: a -> m a
fail   :: String -> m a

m >> k  =  m >>= \ _ -> k
fail s  =  error s
```

Think of m a as being the (type of) a "step" in a sequence of operations, and of >> as being an operator, like `;' in an imperative language, which connects a sequence of steps together. >>= is like >> except that the former's right operand takes a parameter of type a.

Note that >> is defined in terms of >>= for brevity and consistency; they behave in essentially the same way. Below we see that >>= must be (essentially) associative and that therefore >> must be associative, i.e. p>>(q>>r) = (p>>q)>>r.

". . . Instance of Monad should [obey]":
```return a >>= k          = k a
m >>= return            = m
m >>= (\x -> k x >>= h) = (m >>= k)>>= h  --~associative±
fmap f xs               = xs >>= return . f
```

"... lists, Maybe and IO are all instances of Monad. .... for IO, the fail method invokes error."
>>= >> return fail
defn
(>>=) :: m a -> (a->m b) -> mb (>>) :: m a -> m b -> m b return :: a -> m a fail :: String -> m a
m >> k = m >>= \_ -> k --default   fail s = error s --default
instances...
IO (>>=) =... --~magic --"-- return =... --~magic fail s = error s
[]
list
m >>= k = concat(map k m) --"-- return x = [x] fail s = []
Maybe (Just x) >>= k = k x
Nothing >>= k = Nothing
--"-- return = Just --~success fail s = Nothing

Example: [m.hs]
```module Main where
main =
putStrLn "-- Monad experiments, 11/2005 --"

-- example 1.1                                          m = list
>> (putStrLn.show)                               -- equiv to...
( ["anna", "carol"] >>= \x ->        -- do x <- [..., ...]
["bill", "dave" ] >>= \y ->        --    y <- [..., ...]
return (x,y)                       --    return (x,y)
)                           --[(a,b), (a,d), (c,b), (c,d)]

-- example 1.2                                          m = list
>> (putStrLn.show)
( ["anna", "carol"] >>= \x ->
concat [ return [x],                  -- blob with TV
["bill", "dave" ] >>= \y ->  -- a date?
if x > y then fail "bad vibe" else return [x,y]
]
)                            --[[a],[a,b],[a,d],[c],[c,d]]

-- example 2                                           m = Maybe
>> let sqrt x = if x >= 0 then Just(x**0.5) else Nothing
in (putStrLn.show)
( sqrt 4 >>= \x ->
sqrt 9 >>= \y ->
return (x+y) )                            -- Just 5.0

-- example 3                                              m = IO
>> return "print-me" >>= putStrLn
>> fail "-- stopping by invoking IO's fail --"
-- ------------------------------------------------LA--11/2005--

```

RR = revised report, CUP, 2003.

7/2002, 11/2005
 Coding Ockham's Razor, L. Allison, Springer A Practical Introduction to Denotational Semantics, L. Allison, CUP

 Linux  Ubuntu free op. sys. OpenOffice free office suite The GIMP ~ free photoshop Firefox web browser