The state here is a list of Int's.  We call that a Stack and implement the two functions on Stacks: push and pop.  Push takes another Int and puts it in the Stack as the new top element.  The function that does that (the lambda expression in the definition of push) still needs to return a pair of type (a,s).  Because there is no sensible thing to return here we just return () (unit) and the second part is the new stack.  The whole thing is then wrapped into the State constructor. 

The definition of pop follows the same concept.  The function takes the stack, returns the top element as the result and the stack without the top element as the new stack.  Again the function needs to be wrapped in the State Monad. 

To see how the combination of those functions work we have to untangle the implementation of (>>=).  The m on the left side of (>>=) has type (m a).  So in the State Monad it holds a function that takes the current State and returns a pair of type (a,s).  So the sensible thing to do would be to extract that function and apply it to the current state.  That is what happens in the let expression.  We get a pair (a,s').  The right side of the (>>=) is a function of type (a -> m b).  We just got a value of type a so we apply the function k to a to get out (m b), which is something with a function of type s -> (b,s) inside.  This function is again extracted and applied to the new state s'.  All of this has to be another function in the State Monad, so it is wrapped in the State constructor. 

Now what can we do with this?  For example we can remove the second element from the stack like so: