It is true that working with temperatures can be complex, especially if you allow the use of non-0 based scales like Celsius and Fahrenheit. However, if you stick to Kelvin (and/or Rankin), there is little complexity. More to the point, there are plenty of problems that require combining temperatures with other units, especially in chemical engineering and physics problems dealing with heat transport.

I would really appreciate you reconsidering the above, at least adding support for Kelvin (and/or Rankin)! If I get a chance, and if my Clojure expertise is up to it, I may have a go myself, but I assume it should be trivial for you to do.

Thanks, in any case, for what looks like a great addition to the Clojure-verse!

I had a (doseq .. ) that I wanted to execute in parallel. It was trivial to rewrite it as (dorun (map ….. )) and then simply use pmap instead!

F# uses sequence monads to construct IEnumerable. As you pointed out there is some compiler magic that rearranges the statements into monadic expressions (http://blogs.msdn.com/b/dsyme/archive/2007/09/22/some-details-on-f-computation-expressions-aka-monadic-or-workflow-syntax.aspx). In clojure I would assume one could do this same transformation with a macro.

So back to the question of why? Although this seems unnecessary in a clojure where lazy sequences accomplish the same thing. I’m still wondering if lazy-seq may be the bridge between, rather than a replacement for, the monadic representation.

Here is a web application where the author used fill-queue to convert the web server into a sequence generator rather than a event dispatcher. http://infolace.blogspot.com/2009/08/simple-webhooks-with-clojure-and-ring.html.

Using the same technique I could write fib in an imperative style.
(def fib (fill-queue (fn loop [fill] [a 0 b 1] (fill a) (recur b (+ a b)))))

However the above uses another thread which blocks when the queue is full, in some cases this concurrent computation may be desirable, but it probably isn’t desirable to dedicate a thread to each computation.

In F# events can be composed, filtered and mapped just as a sequence of events rather than traditional event handlers (http://codebetter.com/matthewpodwysocki/2009/08/11/first-class-composable-events-in-f/) which makes the code very expressive.

Here is a clojure web framework that uses a continuation monad to preserve the state of a web application http://intensivesystems.net/tutorials/cont_m_web.html. In this case continuations rather than separate threads are used to maintain state. Could this be implemented as a lazy sequence instead? In F# asynchronous workflows are also implemented via monads. Some C# developers are using IEnumerable and linq to develop async workflows (http://tomasp.net/blog/csharp-async.aspx). So I think the answer is yes, but the real question I think is would using a lazy sequence make the code easier or more difficult to understand, write and maintain?

I think applications might be written as async workflows, and instead of using event handlers they pull a sequence of events and maintain state between events in local variables (sate monad). This would have the feel of stdin/stdout in unix, but rather than the workflow blocking on output and requiring a dedicated thread a continuation could be used to externalize the choice of threading model.

I really liked this and the other blog entries about monads to let me understand the concept w/ Clojure. Thanks.

To run the sample, I had to exclude write of clojure.contrib.monadic-io-streams. It’s w/ Clojure 1.2 and 1.3.0-alpha2.

(:use [clojure.contrib.monadic-io-streams :exclude (write)])

Jacek

rest of to the domonad form should become rest of the domonad form (‘to’ removed)

used that is has itself should become used that has itself (‘is’ removed)

Thanks for the article and the others! They’re very mind-blowing and simply awesome. I wish you’d share when/how you used the library so I’d follow along and understand monads better.

(domonad sequence
[a (range 5)
:when (odd? a)]
(* 2 a))

use sequence-m?