Just like everybody else who starts to look at monads, I found it was like coming to the face of a sheer cliff. \u00a0Let me qualify that: just like every other programmer who is not a mathematician (and that’s most of us). \u00a0I am looking at monads in the context of clojure, so code snippets will generally be written in clojure-like syntax.<\/p>\n
I have found these resources the most helpful:<\/p>\n
Adam’s talk eschews category theory, and mathematics in general, concentrating on how to define and use monads in code. \u00a0This is an essential approach for the rest of us<\/i>. Unfortunately, all of the terms used in discussing monads hark back to the mathematics, and that, I believe, makes the practical use of monads more confusing than it need be. \u00a0This point was brought home to me strongly when, after observing what some of the others were saying, I watched the first part of a lecture by this extraordinary woman<\/a>.<\/p>\n Warning<\/span><\/b>:<\/span> take everything I say with a large grain of salt. \u00a0I am writing this to help me to sort it out in my own mind, and there are no guarantees that any of it is correct.<\/p>\n In all of the discussions I have seen, it is stressed that monads are defined in terms of the behaviour of two functions.<\/p>\n Although it is not usually mentioned first, I will start with the function that I will call wrap<\/span><\/b>. \u00a0Nobody else calls it that, but that’s what it does. It goes by a number of aliases:<\/p>\n f: T -> [T]<\/span><\/p><\/blockquote>\n That is, for the Array Monad, wrap<\/span> takes a value of some type T<\/span>, and wraps<\/i> it in an array. \u00a0Both the type of value and the mode of wrapping are specific to each defined monad, but once defined, they are fixed for that monad.<\/p>\n The resulting, wrapped, value returned from wrap<\/span> is known as a monadic value<\/b><\/i>, and is often represented in code as mv<\/b><\/span>. \u00a0In this discussion, I’ll call it wrapt<\/b><\/span>, for obvious reasons. I’ll call the argument to wrap<\/span> the basic value<\/i><\/span>, or bv<\/b><\/span>.<\/p>\n You can see why monadic values<\/i> are frequently called containers<\/b><\/i>.<\/p>\n unwrap<\/span> is under wraps, so to speak, because it is not part of the public face of monads. It is NOT<\/b> one of the two functions which define the behaviour of a monad<\/i>. \u00a0It is, however, essential to the functioning of monads, and some kind of unwrap<\/span> functionality must be available to the other function in the definition of monad:\u00a0rewrap<\/span>.<\/p>\n unwrap<\/span> is the inverse of wrap<\/span>, not surprisingly. \u00a0In terms of Santosh’s Array monad, it’s signature might look like this.<\/p>\n f: T <- [T]<\/span><\/p><\/blockquote>\n That is, unwrap takes a wrapt<\/span> (monadic value)<\/i>, which is a wrapped basic value<\/i> and returns the basic value<\/i>.<\/p>\n This the function that is generally called bind<\/span>, m_bind<\/span>, etc., although in Santosh’s examples, this function takes the name of the monad; for example, arrayMonad<\/span>. \u00a0The signature that Santosh gives for this function in the Array Monad is<\/p>\n M: [T] -> [T]<\/span><\/p><\/blockquote>\n That is, it transforms a wrapt<\/span>\u00a0value<\/i> to another\u00a0wrapt<\/span>\u00a0value<\/i>. In the case of the Array monad, the basic value is wrapped in an array.<\/p>\n rewrap<\/span> looks like this.<\/p>\n So, what rewrap<\/span> does is<\/p>\n The monadic function<\/i> argument, mf<\/span>, deserves a closer look. \u00a0mf<\/span> operates on a basic value<\/i> to produce a new wrapt<\/span> value. \u00a0It is, in fact, a composition of functions. \u00a0It composes wrap<\/span>\u00a0and some operation that modifies the basic value<\/i>. \u00a0So,<\/span><\/p>\n mf \u21d2 (<\/span>f\u2032\u00a0<\/span>\u22c5 wrap<\/span>)<\/span><\/p><\/blockquote>\n where\u00a0f\u2032<\/span>\u00a0is a function that modifies the basic value<\/i>. In that scheme, wrap itself can be described as<\/p>\n wrap\u2032 \u21d2 (identity\u00a0<\/span>\u22c5 wrap<\/span>)<\/span><\/p><\/blockquote>\n That given, we can now describe rewrap<\/span> as<\/p>\n or, equivalently,<\/p>\nwrap<\/span><\/b><\/h3>\n
\n
\n
;; Takes a basic value; returns a wrapt value\n<\/span>(defn mymonad-wrap [bv]<\/span>\n (let [wrapt (<\/span>do-the-wrapping-of<\/i><\/span> bv)]\n wrapt))<\/span><\/pre>\n<\/blockquote>\n(unwrap)<\/b><\/span><\/h3>\n
rewrap<\/b><\/span><\/h3>\n
\n
(defn mymonad-rewrap [wrapt, mf]\n ;; call monadic function given as 2nd arg, on the\n ;; basic value extracted from the wrapt value given\n ;; in the 1st argument. Return the new wrapt value.\n (let [bv (<\/span>do-unwrap-fn-on<\/span> wrapt)\n new-wrapt (mf bv)]\n new-wrapt))<\/span><\/pre>\n<\/blockquote>\n\n
\n
\n
(defn rewrap [wrapt, (f\u2032\u00a0<\/span>\u22c5 wrap)]<\/pre>\n (let [bv (unwrap wrapt)\n new-wrapt (wrap (f\u2032 bv))]\n new-wrapt))<\/pre>\n<\/blockquote>\n
\n
(defn rewrap [wrapt, (f\u2032\u00a0<\/span>\u22c5 wrap)]<\/pre>\n (wrap (f\u2032<\/span> (unwrap wrapt))))<\/pre>\n<\/blockquote>\nThe 3 R’s<\/h3>\n