Comments on: Fun with the Lazy State Monad

By: lpsmith

lpsmith — Wed, 03 Aug 2011 18:35:40 +0000

In a conversation with Edward Kmett, he suggested that the Lazy State Monad is, arguably, not a monad in the categorical sense, because fmap id ≠ id. In particular, fmap id ⊥ = λ _ → (⊥,⊥).

By: Fun with the Lazy State Monad, Part 2 « Melding Monads

Fun with the Lazy State Monad, Part 2 « Melding Monads — Wed, 25 Aug 2010 10:52:16 +0000

If you like this post, you might also be interested in Fun with the Lazy State Monad, Part 2, where I combine the Fresh monad with the continuation transformer.

By: lpsmith

lpsmith — Sat, 20 Feb 2010 04:12:25 +0000

The problem is that once you apply a continuation transformer to the monad stack itself, you make the lazy state monad a strict state monad, and this algorithm will get stuck in an infinite non-productive loop. It does not matter if it's a codensity transformer, or a regular continuation transformer. The higher-ranked types do not change the termination properties of the program. One can verify my claim above by installing Edward Kmett's category-extras package, and applying his Codensity transformer to the original code. Also, I think I see what you tried to do with freshCod, however, your code produces a depth-first renumbering, not breadth-first as is desired. It's an interesting idea though; is it possible to somehow "layer" the monads on each other without resorting to transformers? Basically, instead of combining the effects of two monads, can you use one monad to structure the computation inside another monadic language while keeping them more-or-less separate?

By: zygoloid

zygoloid — Sat, 20 Feb 2010 00:46:21 +0000

Looks like you're secretly working in the Codensity Fresh monad (which is almost the same as ContT Fresh):

type FreshCod n = Codensity (Fresh n)

runFreshCod :: Num n => FreshCod n a -> a
runFreshCod m = runFresh (runCodensity m return)

freshCod :: Num n => FreshCod n n
freshCod = Codensity fresh

lazyRenum :: Num n => Tree a b -> Tree n n
lazyRenum = runFreshCod . renumber
   where
     renumber (Leaf    _    )
        = do n <- freshCod
             return (Leaf n)
     renumber (Branch  _ l r)
        = do n <- freshCod
             l' <- renumber l
             r' <- renumber r
             return (Branch n l' r')

By: lpsmith

lpsmith — Thu, 31 Dec 2009 06:22:56 +0000

That is very elegant, my appreciation of applicative functors could be better. :-) I would contrast this with C++ and Scheme in that their order of evaluation of arguments is not specified. I wrote a parser in C++ years ago basically using an applicative functor kind of idiom, only to have to rewrite it in something closer to the monadic style because of this fact. At first I found this rather frustrating, although I grew to see it as kind of a good thing, as you must make dependencies on order explicit, and it allows the compiler to optimize more aggressively. On the other hand, the (big) downside is that code happens to work on one compiler can break on another. Of course, these specific issues don't apply to Haskell because effects are tightly controlled, but it does inform my stylistic tastes. With the monadic style it's easy to specify a right-to-left renumbering, all you have to do is swap the order of two lines. However, I'm not sure the elegance of the applicative style holds up quite as nicely in the face of this change. But of course, monadic versus applicative styles is not an all-or-nothing proposition, and I do think that your decomposition of fresh into fresh and down is probably a good move.

By: Twan van Laarhoven

Twan van Laarhoven — Thu, 31 Dec 2009 03:55:17 +0000

I would have split the fresh function into

    fresh :: Num n => Fresh n n
    down :: Fresh n a -> Fresh n a

    fresh = do
       (n:ns) <- get
       put (n+1 : ns)
       return n
    down f = do
       (n:ns) <- get
       put ns
       x <- f
       ns' <- get
       put (n:ns')
       return x

This is more like a regular fresh name supply, and allows renumber to be written in an applicative style, like so:

    renumber (Leaf    _    ) = Leaf <$> fresh
    renumber (Branch  _ l r) = Branch <$> fresh <*> (down $ renumber l) <*> (down $ renumber r)