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
_______________________________________________
Haskell-Cafe mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/haskell-cafe
