First off, keep in mind that the State st a type is a function type (st -> (st, a)) and that returnState a wraps a into a function that returns a state-value,value pair when it’s applied to a state-value.

bindState is a bit complicated to think about. It takes two arguments, both functions. The first (m) is of type st -> (st, a) (i.e. State st a). The second (k) is of type a -> (st -> (st, b)) (i.e. a-> (State st b)). In other words, this second argument is a function that takes a value and returns a function that we can apply to a state, the return function has “wrapped up” in it the end result of the computation. Looking more into the implementation of bindState we see that it returns a function taking one argument (st) where m is used to calculate a new state-value,value (st' and a) pair based on st. Next k is used to “wrap” a into a function (m') that we can apply a state_value to. The last step is to apply the new state (st') to the function wrapping the new value (m').

Looking at mapTreeStateM on (Leaf a) we see that f a is m in bindState. \b -> returnState (Leaf b), from our look at bindState we can see that b here will be our newly calculated value (i.e. the new value coming out of f a will be wrapped into a leaf again).

I found it easier to understand when I applied an “identity function” to a tree:

doNothing :: Integer -> State Integer Integer
doNothing a = returnState a

Working through, on paper, what goes on when applying doNothing, a tree of one leaf, and an initial state of 0 made it quite clear what is happening.

Analysing the recursive step after this is fairly straight forward. Adding parentheses makes it a bit easier to read and I found it helpful to rewrite it to only consider the left branches:

mapTreeStateMLO :: (a -> State st Integer) -> Tree a -> State st (Tree Integer)
mapTreeStateMLO f (Leaf a) =
    (f a) `bindState` (\b -> returnState (Leaf b))
mapTreeStateMLO f (Branch lhs rhs) =
    (mapTreeStateMLO f lhs) `bindState` (\lhs' ->
    returnState (Branch lhs' (Leaf (-1))))

The extension to right branches comes fairly naturally after that.

I wrote a few functions to play with mapTreeStateM. All of them use a single integer to represent its state.

State is the number of leaves in the tree:

countLeaf :: Integer -> State Integer Integer
countLeaf a = \st -> (st + 1, a)

State is the maximum value of a leaf

maxLeaf :: Integer -> State Integer Integer
maxLeaf a = \st -> (max st a, a)

This function that numbers each leaf in the tree.

numberLeaf :: Integer -> State Integer (Integer, Integer)
numberLeaf a = \st -> (st + 1, (st, a))