monads

I'm working on using Futures for the first time in Scala and am working through an example of using the flatMap combinator; I've been following this discussion: http://docs.scala-lang.org/overviews/core/futures.html Specifically, this example: val usdQuote = future { connection.getCurrentValue(USD) } val chfQuote = future { connection.getCurrentValue(CHF) } val purchase = for { usd <- usdQuote chf <- chfQuote if isProfitable(usd, chf) } yield connection.buy(amount, chf) purchase onSuccess { case _ => println("Purchased " + amount + " CHF") } is translated to this: val purchase = usdQuote

i am kinda confused reading the definition between the two. Can they actually intersect in terms of definition? or am i completely lost? Thanks. Closures, as the word tends to be used, are just functions (or blocks of code, if you like) that you can treat like a piece of data and pass to other functions, etc. (the "closed" bit is that wherever you eventually call it, it behaves just as it would if you called it where it was originally defined). A monad is (roughly) more like a context in which functions can be chained together sequentially, and controls how data is passed from one function to

I have this monad called Desync - [<AutoOpen>] module DesyncModule = /// The Desync monad. Allows the user to define in a sequential style an operation that spans /// across a bounded number of events. Span is bounded because I've yet to figure out how to /// make Desync implementation tail-recursive (see note about unbounded recursion in bind). And /// frankly, I'm not sure if there is a tail-recursive implementation of it... type [<NoComparison; NoEquality>] Desync<'e, 's, 'a> = Desync of ('s -> 's * Either<'e -> Desync<'e, 's, 'a>, 'a>) /// Monadic return for the Desync monad. let internal

Scala has the trait Iterable[A] that defines def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Iterable[B] That certainly looks like the bind function on a monad, and the documentation hints that it is a monad, but there are two objections, one minor and one major: the minor one: the return-type of the function passed in is this GenTraversableOnce . I think this is just a convenience that can be overlooked when judging monad-ness. the major one: the "value" of the monad is the list of all the values it contains, but the function is given the values one at a time. Do these problems break the