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@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@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners

--

Regards

Sumit Sahrawat

_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners