That's pretty much the point. I'll detail the first example (the Maybe monad). The idea is that you have a maybe object that is either an just an object (denot

That's pretty much the point. I'll detail the first example (the Maybe monad). The idea is that you have a maybe object that is either an just an object (denoted Just(a)) or nothing at all (denoted Nothing). If you want to manually apply a function f on object m, the code would look like this if(m is Just(a)){ f(a) } else{ // there is nothing to do } You can take f as a parameter to create a generic function apply. You want to your new function to be total (to return a value in all cases). Since you may (or may not) have a value within the maybe monad, the return type is also a Maybe value. If there was no value, then return Nothing, else apply `f` on `a` and wrap it back within the JUst part of the monad. The code looks like this. apply(m,f){ if(m is Just(a)){ return Just(f(a)) } else{ return Nothing. } } From an initial maybe value m, you can chain calls: apply(apply(apply(m,f),g),h) With a bit of syntactic sugar, the code looks like this. do m <- getData b <- f a c <- g b d <- h c print d And the code is similar for the others cases. In all solutions, <- denotes an apply function on some monad. There is a function for each type of monad and it is responsible for doing all repetitive plumbing according to the given type of the monad. I hope it helps =)