# Clojure's Thread for Monads

## gga

## #2013-12-05

Over the last few months, I’ve really been enjoying writing Clojure. In an effort to learn the language better, I’ve kept leaning on my code to make it clearer and more concise. Eventually, pulling in `algo.monads`

to model my error handling as a monad.

I was surprised to discover that there is no `->`

macro in the monad library. So here’s an implementation:

```
(defn- bind-monadic-expr-into-form [insert form]
(list 'm-bind insert (if (seq? form)
`(fn [bound#] (~(first form) bound# ~@(rest form)))
`(fn [bound#] (~form bound#)))))
(defmacro m->
([m x]
`(monad/with-monad ~m ~x))
([m x form]
`(monad/with-monad ~m
~(bind-monadic-expr-into-form x form)))
([m x form & more]
`(m-> ~m (m-> ~m ~x ~form) ~@more)))
```

You can use the `m->`

macro to create thread macros around your own monads. I use one around the `failure-m`

monad from Andrew Brehaut. This is sort of like a `Maybe`

monad, with some more information.

```
(defprotocol Failed
(has-failed? [failure]))
(extend-protocol Failed
Object
(has-failed? [failure] false)
Failure
(has-failed? [failure] true)
Exception
(has-failed? [failure] true))
(monad/defmonad failure-m
[m-result identity
m-bind (fn [m f]
(if (has-failed? m)
m
(f m)))])
(defmacro fail->
([x] `(m-> ~failure-m ~x))
([x form] `(m-> failure-m ~x ~form))
([x form & more] `(fail-> (fail-> ~x ~form) ~@more)))
(defmacro dofailure [bindings expr]
`(monad/domonad failure-m ~bindings ~expr))
```

You can use this the `fail->`

macro just like the `->`

macro. I use it to handle HTTP routes. Honestly, I’m not ecstatic about `fail->`

as a name.

```
(fail-> (get-person person-id)
resource)
```

Where `get-person`

would return a `not-found`

failure for a bad `person-id`

, and `resource`

uses a protocol to construct something that Compojure can render as a response.

I really should offer `m->`

to `algo.monads`

.