[evanrmurphy]

Hmm! That's funny, I thought I was "getting" monads better after reading this article (as someone who doesn't already have a firm grasp of monads, of course).

You see, I already sensed that monads:

- were a way that you could sort of simulate side effects using pure functions

- had to do with the type signatures of functions

What I gleaned from the article is that monads:

- have to do with making functions composable

- work by way of the abstractions bind and unit in order to make type signatures match

Did the article harm my (lack of) understanding of monads?

[amalcon]

Monads basically let you add an extra calculation to your functions. Why would you want to do that? Mainly so that you don't have to do it manually. Think of it as tacking an extra calculation onto the side of each function that operates in the monad.

For a "state" monad, that calculation is maintaining/passing the state. For a "logging" monad, that calculation is maintaining the log. For an "error handling monad", that calculation is checking for and propagating errors.

[evanrmurphy]

I know lisp better than Haskell, and so I'm more familiar with macros than with monads. From what you describe, it seems to me that the use cases for monads and macros have some overlap.

Take the OP's example for the Writer monad, in which several functions needed to return a debug string "<function name> was called" in addition to their main return value. If I had these two functions+:

  (def sine (x)
    [(Math.sin x) "sine was called"])

  (def cube (x)
    [(* x x x) "cube was called"])

I might write a macro like the following (rather than a monad) to abstract away their common pattern:

  (mac defWriter (name parms body...)
    `(def ,name ,parms
       [,@body (+ ,name " was called.")]))

And then each function's definition could be written more concisely:

  (defWriter sine (x)
    (Math.sin x))

  (defWriter cube (x)
    (* x x x))

---

+ Forgive me for indulging in the syntactic sugar from my own lisp->javascript project in these examples, but since we're dealing in JavaScript I couldn't resist. https://github.com/evanrmurphy/lava-script

[tumult]

posting from phone

monads are not for simulating side effects. they can model many things.

functions are already composable with the dot (.). if you want to compose arbitrary structures, use Control.Category.

unit does not have anything in particular to do with monads.

'bind' is specific to each monad and defines its behavior. there is no abstract or generic bind.

the article didn't teach you anything.

ask #Haskell on freenode if you have questions.

[stianan]

Actually, bind and unit seem to fit very well with this interesting article, which explains the mathematics behind monads (in fact it uses unit, which you say has nothing to do with monads): http://bartoszmilewski.wordpress.com/2011/01/09/monads-for-t...