monads

I'm digging deeper into Yesod's monads, and have encountered MonadBaseControl . I took a look at the hackage doc, and got lost. Could someone tell me the problem it is trying to solve? It comes from the package monad-control , and is one of a pair of type classes (the other one being MonadTransControl ) that enhance MonadBase (resp. MonadTrans ) by supporting an alternative liftBase (resp. lift ) operation for monads that implement it. This enhanced version no longer takes a simple action in the absolute base monad (resp. immediate base monad), but instead takes a function that gets the base

In Haskell Wiki's Recursion in a monad there is an example that is claimed to be tail-recursive : f 0 acc = return (reverse acc) f n acc = do v <- getLine f (n-1) (v : acc) While the imperative notation leads us to believe that it is tail-recursive, it's not so obvious at all (at least to me). If we de-sugar do we get f 0 acc = return (reverse acc) f n acc = getLine >>= \v -> f (n-1) (v : acc) and rewriting the second line leads to f n acc = (>>=) getLine (\v -> f (n-1) (v : acc)) So we see that f occurs inside the second argument of >>= , not in a tail-recursive position. We'd need to examine

In one discussion I heard that Applicative interface of some parsers is implemented differently, more efficiently than their Monad interface. The reason is that with Applicative we know all "effects" in advance, before the whole effectful computation is run. With monads, effects can depend on values during the computation so this optimization is not possible. I'd like to see some good examples of this. It can be some very simple parser or some different monad, that's not important. The important thing is that the Applicative interface of such a monad complies with its return and ap , but using

Can someone show a simple example where state monad can be better than passing state directly? bar1 (Foo x) = Foo (x + 1) vs bar2 :: State Foo Foo bar2 = do modify (\(Foo x) -> Foo (x + 1)) get State passing is often tedious, error-prone, and hinders refactoring. For example, try labeling a binary tree or rose tree in postorder: data RoseTree a = Node a [RoseTree a] deriving (Show) postLabel :: RoseTree a -> RoseTree Int postLabel = fst . go 0 where go i (Node _ ts) = (Node i' ts', i' + 1) where (ts', i') = gots i ts gots i [] = ([], i) gots i (t:ts) = (t':ts', i'') where (t', i') = go i t (ts

I wrote small program in haskell to count all ocurences of Int values in Tree using State Monad with Vector: import Data.Vector import Control.Monad.State import Control.Monad.Identity data Tree a = Null | Node (Tree a) a (Tree a) deriving Show main :: IO () main = do print $ runTraverse (Node Null 5 Null) type MyMon a = StateT (Vector Int) Identity a runTraverse :: Tree Int -> ((),Vector Int) runTraverse t = runIdentity (runStateT (traverse t) (Data.Vector.replicate 7 0)) traverse :: Tree Int -> MyMon () traverse Null = return () traverse (Node l v r) = do s <- get put (s // [(v, (s ! v) + 1)

I've had a look at the algo.monads and fluokitten documentation. I've also read through monad blog entries by Jim Duey , Konrad Hinsen and Leonardo Borges . The closest I can find is Konrad Hinsen's library Monadic IO streams - but this doesn't appear to 'implement the monad interface' (for want of a better phrasing) This is example using ST in Haskell oneST :: ST s Int -- note that this works correctly for any s oneST = do var <- newSTRef 0 modifySTRef var (+1) readSTRef var one :: Int one = runST oneST My question is: Is it possible to do the IO Monad from Haskell in Clojure? Could you