"Welcome to the Machine": State monads in Clojure

http://brehaut.net/blog/2010/welcome_to_the_machine

by stevenashley • 16 years ago

27 17 16 years ago

jrockway5• 16 years ago

I don't think monads really work in dynamically typed languages, because there is no way for the bind combinator to ensure that both operands return the same type. Consider:

    f :: Int -> Either String Int
    f 0 = Left "Zero is not allowed!"
    f x = x + 42

    g :: Int -> [Int]
    g x | x > 1 = [1..x]

(These are functions of one argument that return an Int in a monad; Either and [] are the monads. The Error monad will bind the "Right" answer to the next function, or just return the Left answer as soon as it is produced. The List monad will bind every input list element to the function, and concatenate the resulting lists.)

Then, in a dynamically typed language, nothing stops you from writing something like:

    f =<< g 42

even though the expression does not make any sense. Since you don't know the type of f before you bind the output of g to it, you can't ensure that you are still in the [] monad. So while it's possible to bind [1..42] (the output of g) to f, it's not possible to make sense of the result (which would be something like Right 43 ++ Right 44 ++, except there is no ++ on Either).

Anyway, this means you don't have a monad -- you just have a function that calls other functions. It's a fine way to reuse code, but it's not a monad.

mbrubeck3• 16 years ago

That's like saying arithmetic doesn't work in dynamic languages because nothing stops you from writing (+ 42 "foo"). Sure, you won't get a compiler error - that's why it's a dynamic language! - but you will get an error at runtime. What "stops" you from writing broken code are automated tests, lint checkers, discipline, and common sense.

I say this as someone who has implemented monadic code in both JavaScript and Haskell, including a small homegrown parser combinator module: http://limpet.net/mbrubeck/2009/10/30/compleat.html

eru5• 16 years ago

So as a summary: In dynamic languages the compiler does not enforce the monad laws.

I add: They aren't enforced completely in Haskell, either.

(And you can't even express every monad in Haskell. E.g. you can't even make Set a functor in Haskell.)

jrockway5• 16 years ago

But that's not what monads are, what you have without a type system is just "calling a function with the result of another function". You could use the function composition operator to the same effect.

Having also implemented a monad library in a dynamically-typed language, I am well aware of what happens when one operand of bind returns the wrong type. The rest of the computation silently proceeds with that type, until it happens to change again. This results in a subtle loss of information, rather than outright failure.

Like I said, programming with combinators is a great way to reuse code -- but not all combinators that are of type "f a -> (a -> g b) -> g b" are monadic. It's only a monad when f = g.

harshavr• 16 years ago

If I remember correctly, there was a more tricky problem in implementing monads without the type system - sometimes which monad is chosen for an expression, depends not just on the arguments, but the expected type of the result. Ex : "return 3" might be [3] or an IO action with result 3. The compiler decides this based on the surrounding context. In dynamical languages one would have to manually specify which kind of 'return' you mean.

This surrounding context inference feature, which is useful for type classes other than monads, has the unusual consequence that you need to specify more typeinfo in a dynamic language.

brehaut2• 16 years ago

Clojure (being a lisp) uses macros and some dynamic variables to manage this sort of polymorphism. The clojure library provides a defmonad macro to let you define the functions required (m-bind and m-result are a must, and m-plus and m-zero are optional).

Unlike haskell which can choose an implementation based on the return type of return and bind, you do have to spell it out. The macro with-monad will wrap a set of expressions up in the correct monad, and the domonad monad comprehension form is also able to accept an optional monad name (useful if you aren't inside a with-monad form, or if you need a different monad)

"Welcome to the Machine": State monads in Clojure

Related Stories