monads

As in my previous question , I'm trying to wrap the Data.Binary.Put monad into another monad so that later I can ask it questions like "how many bytes it's going to write" or "what is the current position in file". Before, I thought that understanding why it leaks memory while using a trivial (IdentityT?) wrapper would lead me to solving my problem. But even though you guys have helped me resolve the problem with the trivial wrapper, wrapping it with something usefull like StateT or WriterT still consumes too much memory (and usually crashes). For example, this is one way I'm trying to wrap it

I just got my copy of Expert F# 2.0 and came across this statement, which somewhat surprised me: For example, when necessary, you can use side effects on private data structures allocated at the start of an algorithm and then discard these data structures before returning a result; the overall result is then effectively a side-effect-free function. One example of separation from the F# library is the library's implementation of List.map, which uses mutation internally; the writes occur on an internal, separated data structure that no other code can access. Now, obviously the advantage to this

The free MonadPlus defined as data Free f a = Pure a | Free (f (Free f a)) | Plus [Free f a] was removed in free 4.6 with the following remark ( changelog ): Removed Control.MonadPlus.Free . Use FreeT f [] instead and the result will be law-abiding. What was the problem, in particular, what laws didn't hold? dfeuer According to this issue in the bug tracker the old definition does not obey the associative law. Although I know little about such things, I suspect an other problem is redundancy: Pure a Plus [Pure a] Plus [Plus [Pure a]] ... all seem to represent the same thing. Free structures

This code is from this article I've been able to follow it until this part. module Test where type State = Int data ST a = S (State -> (a, State)) apply :: ST a -> State -> (a,State) apply (S f) x = f x fresh = S (\n -> (n, n+1)) instance Monad ST where -- return :: a -> ST a return x = S (\s -> (x,s)) -- (>>=) :: ST a -> (a -> ST b) -> ST b st >>= f = S (\s -> let (x,s') = apply st s in apply (f x) s') data Tree a = Leaf a | Node (Tree a) (Tree a) deriving (Show) mlabel :: Tree a -> ST (Tree (a,Int)) -- THIS IS THE PART I DON'T UNDERSTAND: mlabel (Leaf x) = do n <- fresh return (Leaf (x,n))

I am trying to write the validate function below so that the validation stops after the first error encountered. The return type of three is different to the other functions. Which monad transformer do I use in order to make this code compile? import scalaz._ import Scalaz._ import scala.concurrent.Future import scala.concurrent.ExecutionContext.Implicits.global def one(a : String): Disjunction[Int, String] = a == "one" match { case true => \/-("one") case false => -\/(2) } def two(a : String): Disjunction[Int, String] = a == "two" match { case true => \/-("two") case false => -\/(3) } def