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.

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?

The only monad I can see as of some relevance to your example is the continuation monad. You could write all your computations in continuation-passing style and use the continuation monad to combine them. You could then implement generator-like constructs through continuations. However, this looks way too complicated to be of any practical interest.