[Haskell-beginners] State Monad stack example

[Benjamin Edwards]

I gave an expansion of the state monad for a different computation on
Reddit some time ago. Perhaps it will be useful to you:

http://www.reddit.com/r/haskell/comments/25fnrj/nicta_course_help_with_state_exercise/

Best,
Ben

On Sat, 7 Mar 2015 5:09 am Sumit Sahrawat, Maths & Computing, IIT (BHU) <
sumit.sahrawat.apm13 at iitbhu.ac.in> wrote:

> 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
>  _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20150307/db5198a9/attachment-0001.html>