Use two monads without a transformer

Question

In order to understand how to use monad transformers, I wrote the following code without one. It reads standard input line by line and displays each line reversed until an empty line is encountered. It also counts the lines using State and in the end displays the total number.

import Control.Monad.State

main = print =<< fmap (`evalState` 0) go where
    go :: IO (State Int Int)
    go = do
        l <- getLine
        if null l
        then return get
        else do
            putStrLn (reverse l)
            -- another possibility: fmap (modify (+1) >>) go
            rest <- go
            return $ do
                modify (+1)
                rest

I wanted to add the current line number before each line. I was able to do it with StateT:

import Control.Monad.State

main = print =<< evalStateT go 0 where
    go :: StateT Int IO Int
    go = do
        l <- lift getLine
        if null l
        then get
        else do
            n <- get
            lift (putStrLn (show n ++ ' ' : reverse l))
            modify (+1)
            go

My question is: how to do the same in the version without monad transformers?

score 10 · Answer 1 · answered Jul 26 '15 at 00:43

The problem you're having is that the hand-unrolling of StateT s IO a is s -> IO (s, a), not IO (s -> (s, a))! Once you have this insight, it's pretty easy to see how to do it:

go :: Int -> IO (Int, Int)
go s = do
    l <- getLine
    if null l
    then return (s, s)
    else do
        putStrLn (show s ++ ' ' : reverse l)
        go (s+1)

score 2 · Answer 2 · answered Jul 25 '15 at 17:25

2

You'd just need to run the accumulated state computation on every line. This is O(n²) time, but since your first program is already using O(n) space, that's not too terrible. Of course, the StateT approach is superior in pretty much every way! If you really want to do it "by hand" and not pay an efficiency price, just manage the state by hand instead of building a state transformer at all. You're really not getting any benefit by using State instead of Int in the first program.

answered Jul 25 '15 at 17:25

dfeuer

48,079
5
63
167

2

I realize that. I'm not looking for a version without a monad transformer for efficiency's sake, I just want to see what it would look like and learn something by comparing the two, hopefully attaining better appreciation of the need for monad transformers. – ByteEater Jul 25 '15 at 17:42
Also, running the accumulated state computation on every line is something I considered and rejected for exactly this reason: it doesn't seem the right way to use monads, a simple `Int` would be a better choice. Moreover, with incrementation it doesn't make a difference, but it would be wrong conceptually, since the `State` computation is built by prepending `modify (+1)` actions, so if I had e.g. `modify (+ length l)`, that wouldn't work as it should. – ByteEater Jul 25 '15 at 17:48
@ByteEater, the way to do it without a monad transformer is to just pass the `Int` around by hand (annoying) or use an `IORef` (limited to `IO`-like things and potentially inefficient, but okay if the box is unavoidable or updates are rare). I don't know what else you're looking for. – dfeuer Jul 25 '15 at 20:31

Matt · Answer 3 · 2015-07-25T18:44:38.270

1

Maybe this is what you are looking for?

main = print =<< fmap (`evalState` 0) (go get) where
  go :: State Int Int -> IO (State Int Int)
  go st = do
     l <- getLine 
     if null l
     then return (st >>= \_ -> get)
     else do
          let ln = evalState st 0
          putStrLn(show ln ++ ' ' : reverse l)
          go (st >>= \_ -> modify (+1) >>= \_ ->  get)

The idea here is to make go tail recursive, building up your state computation, which you can then evaluate at each step.

EDIT

This version will bound the size of the state computation to a constant size, although under lazy evaluation, when the previous state computation is forced, we should be able to reuse it without re-evaluating it, so I'm guessing that these are essentially the same...

main = print =<< fmap (`evalState` 0) (go get) where
  go :: State Int Int -> IO (State Int Int)
  go st = do
     l <- getLine 
     if null l
     then return st
     else do
          let ln = evalState st 0
          putStrLn(show ln ++ ' ' : reverse l)
          go (modify (\s -> s+ln+1) >>= \_ ->  get)

edited Jul 25 '15 at 18:44

answered Jul 25 '15 at 17:51

Matt

4,029
3
20
37

Indeed, this allows the current value computed in `State Int` to be used, at the cost of recomputing it a linear number of times (though with a referentially transparent language and a smart compiler this cost might be avoided). I had considered it but remained unconvinced that this is the canonical equivalent with `State` and `IO` monads of my second programme which uses a transformer. – ByteEater Jul 25 '15 at 18:19
I doubt that this is any more "canonical" than my first attempt, but my second edit can bound the state computation to a constant size, by throwing away the previous state computation, and immediately setting the current state to the last one's result plus 1. Any better? – Matt Jul 25 '15 at 18:34
Better, in the way you described. But it still doesn't compare easily with the version using StateT in order to clearly see what improvement in code (refactoring to a superior form) can actually be achieved with a monad transformer. – ByteEater Jul 25 '15 at 23:51

Use two monads without a transformer

3 Answers3