[Haskell-cafe] Stacking monads

[Andrew Coppin]

Andrew Coppin wrote:
> Consider the following beautiful code:
>
>  run :: State -> Foo -> ResultSet State
>
>  run_and :: State -> Foo -> Foo -> ResultSet State
>  run_and s0 x y = do
>    s1 <- run s0 x
>    s2 <- run s1 y
>    return s2
>
>  run_or :: State -> Foo -> Foo -> ResultSet State
>  run_or s0 x y = merge (run s0 x) (run s0 y)

Right, well, it turns out that if I replace every ResultSet State with 
ErrorT ErrorType ResultSet State then the run_and function still 
typechecks! (I have no idea whether it still produces the correct 
result, but it typechecks.)

The run_or function now becomes highly problematic. The function 
runErrorT essentially ends up being

  runErrorT :: ErrorT ErrorType ResultSet State -> Either ErrorType 
(ResultSet State)

which looks promising. But that means I end up with

  runErrorT (run s0 x) :: ResultSet (Either ErrorType State)

which isn't what I want at all. What *I* want is something more like 
Either ErrorType (ResultSet State). After much searching (Hoogle rather 
failed me here), I discover that if ResultSet happened to be in 
Traversable then I'd have a function called "sequence" which performs 
the exact type transformation I want. Then,  utilising the fact that 
Either is itself a kind of error monad, I can do

  run_or s0 x y =
    let
      either_rset1 = sequence $ run s0 x
      either_rset2 = sequence $ run s0 y
      either_rset3 = do rset1 <- either_rset1; rset2 <- either_rset2; 
return (merge rset1 rset2)

However, now I have a problem. I have either_rset3 :: Either ErrorType 
(ResultSet State), and I need to somehow get back to ErrorT ErrorType 
ResultSet State. Well, the first part is easy:

  case either_rset3 of
    Left  e    -> throwError e
    Right rset -> uh...

Now I need some function from ResultSet State to ErrorT ErrorType 
ResultSet State. It looks like such a function ought to exist, but... 
uh... well I had to use Hoogle to find it. After some poking, it found a 
function called "lift" from a module I didn't even know about called 
Control.Monad.Trans. This has the exact signature I want, so we have

  run_or s0 x y =
    let
      either_rset1 = sequence $ run s0 x
      either_rset2 = sequence $ run s0 y
      either_rset3 = do rset1 <- either_rset1; rset2 <- either_rset2; 
return (merge rset1 rset2)
  in case either_rset3 of
    Left  e    -> throwError e
    Right rset -> lift rset

Again, this now typechecks. I have *no clue* if it behaves correctly. 
(Most specifically, I've only tried using it with dummy types to see if 
the type checker will swallow it, so I haven't attempted writing an 
instance for Traversable yet. Maybe I'll go look at the list definition 
for this to see how it works...)

So, assuming all this stuff does what I *think* it does, it looks like 
I've got this working. But _damn_, couldn't they have written down 
instructions somewhere? This has taken me all day...! o_O