[Haskell-beginners] State Monad stack example

[Sumit Sahrawat, Maths & Computing, IIT (BHU)]

I won't comment on what state exactly is, but you can read up on that and
gain some intuition here:
https://en.wikibooks.org/wiki/Haskell/Understanding_monads/State
It's helpful to implement it using a pen and paper, and consider how the
state flows and gets transformed.

According to the below example,

  stackManip stack =
    let ((), newStack1) = push 3 stack
        (a, newStack2)  = pop newStack1
    in pop newStack2

We get,

  push :: a -> Stack a -> ((), Stack a)    -- Assuming 'Stack a' is a
defined datatype
  pop  :: Stack a -> (a, Stack a)          -- Representing a stack with
elements of type 'a'

Thus,

    push 3 >>= pop
~~  (Stack a -> ((), Stack a)) >>= (Stack a -> (a, Stack a))
{ Replacing by types }

Bind (>>=) has the type, (for "State s")

  (>>=) :: State s a -> (a -> State s b) -> State s b

This is a type mismatch. The conversion to do syntax is at fault here.
First, you must write the computation using bind (>>=), and then convert to
do-notation.

On 7 March 2015 at 10:12, Animesh Saxena <animeshsaxena at icloud.com> wrote:

> I am trying to relate the state monad to a stack example and somehow found
> it easy to get recursively confused!
>
> instance Monad (State s) where
>     return x = State $ \s -> (x,s)
>     (State h) >>= f = State $ \s -> let (a, newState) = h s
>                                                     (State g) = f a
>                                                      in g newState
>
> Considering the stack computation
>
> stackManip stack = let
>               ((), newStack1) = push 3 stack
>               (a, newStack2) = pop newStack1
>                in pop newStack2
>
> in do notation this would become
> do
>    push 3
>    a <- pop
>    pop
>
> If I consider the first computation push 3 >>= pop and try to translate it
> to the definition there are problems....
> Copy paste again, I have
>     (State h) >>= f = State $ \s -> let (a, newState) = h s
>                                                     (State g) = f a
>                                                      in g newState
>
> f is the push function to which we are shoving the old state. I can't
> exactly get around to what exactly is the state computation h? Ok assuming
> it's something which gives me a new state, but then thats push which is
> function f.
> Then push is applied to a which is assuming 3 in this case. This gives me
> a new state, which I would say newStack1 from the stockManip above.
>
> Then somehow I apply g to newState?? All the more confusion. Back to the
> question what exactly is state computation and how is it different from f?
> It seems to be the same function?
>
>
> -Animesh
>
>
>
>
>
>
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
>


-- 
Regards

Sumit Sahrawat
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20150307/3eaff99d/attachment.html>