haskell - Monads - ramp up with Monad

Fist we shall answer the question of what is Monad, monad are just beefed up applicative functors, much like applicative functors are only beefed up functors.

 

so, let's recall monad, and its predecessor, the fmap is like this:  

 

 

fmap :: (Functor f) => (a -> b) -> f a -> f b  

 and then we introduced the applica

oi tive , which is a special form of Functor, that takes binary operator and with additional helper function to help chain and organize the function composition. here is the code. 

 

(<*>) :: (Applicative f) => f (a -> b) -> f a -> f b  

 

we will ignore the code which does the funcion chaining and others, Monad is a Monads are a natural extension of applicative functors and with them we're concerned with this:

 

 

(>>=) :: (Monad m) => m a -> (a -> m b) -> m b  

 which means, with a value in a context, ma, and a function which takes a value and return a context with another type b , it gives you back a value of b in the context. 

 

so , in another word, If we have a fancy value and a function that takes a normal value but returns a fancy value, how do we feed that fancy value into the function?   

 

To best illustrate what we can do with the monad, here we will use the Maybe type .

 

ghci> (\x -> Just (x+1)) 1  
Just 2  
ghci> (\x -> Just (x+1)) 100  
Just 101  

 

so we will make a function out of it. 

 

 

applyMaybe :: Maybe a -> (a -> Maybe b) -> Maybe b  
applyMaybe Nothing f  = Nothing  
applyMaybe (Just x) f = f x  

 

we can do more test. 

ghci> Just 3 `applyMaybe` \x -> Just (x+1)  
Just 4  
ghci> Just "smile" `applyMaybe` \x -> Just (x ++ " :)")  
Just "smile :)"  

 

learnyouahaskell 写道

It looks like that for Maybe, we've figured out how to take a fancy value and feed it to a function that takes a normal value and returns a fancy one. We did this by keeping in mind that a Maybe value represents a computation that might have failed.

 

The formal introduction to the Monads.

 

the formal definition of the Monad is like this:  

 

 

class Monad m where  
    return :: a -> m a  
    (>>=) :: m a -> (a -> m b) -> m b  
    (>>) :: m a -> m b -> m b  
    x >> y = x >>= \_ -> y  
    fail :: String -> m a  
    fail msg = error msg  

 

though we said that Monad is a special beefed up Applicative, why we don't say that in the header, such like this?

class (Applicative m) = > Monad m where 

 

there is some historical reason here, but it won't affect the fact. 

 

Return function is just the same as the pure function in the applicative functors. what is special is the fail method, and it uses the error function, which basically will trigger an Error exception.  it's used by Haskell to enable failure in a special syntactic construct for monads that we'll meet later.

>>= as we saw before, like a function application, it takes a monadic value (instead of a normal valud) and feed it with a function which take a normal value but return a monadic value. 

>> is a built-in impl using >>=, it will ignore the first parameter and kept the second one? we will come back to it later. 

 

so as always, let see how the May fit into the Monad. 

 

 

instance Monad Maybe where  
    return x = Just x  
    Nothing >>= f = Nothing  
    Just x >>= f  = f x  
    fail _ = Nothing  

 

so , with this, what we can do with the Maybe using the Monad operator is like this:  

 

 

ghci> return "WHAT" :: Maybe String  
Just "WHAT"  
ghci> Just 9 >>= \x -> return (x*10)  
Just 90  
ghci> Nothing >>= \x -> return (x*10)  
Nothing 

 

Let's see a real case use scenario with Monad.. 

see if pierre walking the line with a pole and birds landing on two sides, if the number of birds are less or equal than 2, then pierre is able to master his balance, otherwise, he risks falling off. 

here is the type definition that we have. 

 

 

type Birds = Int  
type Pole = (Birds,Birds)  

 

we will wrote two functions to simulating the landing operation. 

 

 

landLeft :: Birds -> Pole -> Pole  
landLeft n (left,right) = (left + n,right)  
  
landRight :: Birds -> Pole -> Pole  
landRight n (left,right) = (left,right + n)  

 

we can chain the landLeft and landRight operation, just as below. 

 

 

ghci> landLeft 2 (landRight 1 (landLeft 1 (0,0)))  
(3,1)  

 to make it easy to write, we will define an infix operator, just as below... 

 

x -: f = f x  

 

now, we can write as this:  

 

ghci> (0,0) -: landLeft 1 -: landRight 1 -: landLeft 2  
(3,1)  

 however, this does not reflect our code, because it does not meet the requirement if the pole is unbalanced, then poor pierre might fall...  like this 

 

ghci> (0,0) -: landLeft 1 -: landRight 4 -: landLeft (-1) -: landRight (-2)  
(0,2)  

 

or this 

 

ghci> landLeft 10 (0,3)  
(10,3)  

 

so if we write as landLeft or landRight as 

 

landLeft :: Birds -> Pole -> Maybe Pole  
landLeft n (left,right)  
    | abs ((left + n) - right) < 4 = Just (left + n, right)  
    | otherwise                    = Nothing  
  
landRight :: Birds -> Pole -> Maybe Pole  
landRight n (left,right)  
    | abs (left - (right + n)) < 4 = Just (left, right + n)  
    | otherwise                    = Nothing  

 but we might not be able to chain the operatoins, because now we might get a Maybe pole and that we stop be able to apply function in the composition fashion. 

 

so you cannot just do 

 

 

ghci> landLeft 2 (0,0)  
Just (2,0)  
ghci> landLeft 10 (0,3)  
Nothing    

 

 

 and then you cannnot just chain the calles like

 (0,0) -: landLeft 1 -: landRight 4 -: landLeft (-1) -: landRight (-2)  

 

 because that the return type is Maybe Pole instead of just Pole.. 

 

but here the monad come sto rescue, as it take a facny value and a fancy value that a function which takes a normal value and return a fancy value and return a nother fancy value (could be a different type in the box). 

 

so you can chain the call like this ,(because how the monad is used,  the landLeft is put in the middle for the chainning) .

 

ghci> return (0,0) >>= landRight 2 >>= landLeft 2 >>= landRight 2  
Just (2,4)  

 Compare to what it is like this:

ghci> (0,0) -: landLeft 1 -: landRight 4 -: landLeft (-1) -: landRight (-2)  
(0,2)  

 but witht he new monaid, we can the real situation covered. 

ghci> return (0,0) >>= landLeft 1 >>= landRight 4 >>= landLeft (-1) >>= landRight (-2)  
Nothing  

 

supose now there is a new method called banana which cause the poor pierre to fall immediately, so here is how it will be implemented just as how.. 

 

banana :: Pole -> Maybe Pole  
banana _ = Nothing  

 now,you can chain as follow. 

ghci> return (0,0) >>= landLeft 1 >>= banana >>= landRight 1  
Nothing  

 

and then you can use (>>) which will ignore the input and just return a predetermined value, (this is the meaning of >> means)

 

(>>) :: (Monad m) => m a -> m b -> m b  
m >> n = m >>= \_ -> n  

 

now, you do this:: 

ghci> return (0,0) >>= landLeft 1 >> Nothing >>= landRight 1  
Nothing  

 

 so you can see Nothing will cause the whole expression to return just nothing. 

 

suppose there is a routine that simulate the landing of birds, 

routine :: Maybe Pole  
routine = case landLeft 1 (0,0) of  
    Nothing -> Nothing  
    Just pole1 -> case landRight 4 pole1 of   
        Nothing -> Nothing  
        Just pole2 -> case landLeft 2 pole2 of  
            Nothing -> Nothing  
            Just pole3 -> landLeft 1 pole3  

 

and this is a verbose version of what we have achived with the >>= and the>> mehtod, the >>= gives us a way to deal with the error condition (failure condition)..