Reid Barton wrote:
I'll assume for simplicity and concreteness that ResultSet = [].
It more or less is. (But with a more complex internal structure, and
correspondingly more complex (>>=) implementation.)
That's right. The type mismatches are telling you that there's a
situation you haven't thought about, or at least, haven't told us how
you want to handle. Suppose run s0 x = Right [s1a, s1b, s1c] and
run s1a y = Left err, run s1b = Right [s2], run s1c = Left err'. What
should the overall result of run_and s0 x y be? Somehow you have to
choose whether it's a Left or a Right, and which error to report in
the former case.
For the [] monad, there is a natural way to make this choice: it's
encoded in the function sequence :: Monad m => [m a] -> m [a], where
in this setting m = Either ErrorType.
Yeah, while testing I accidentally got a definition that typechecks only
because I was using [] as a dummy standin for ResultSet. (Rather than
the real implementation.) The sequence function appears to define the
basic functionallity I'm after.
For your problem, it would
probably be a good start to write an instance of Traversable for the
ResultSet monad.
Wuh? What's Traversable?
In general, one way to make the composition of two
monads m and n into a monad is to write a function n (m a) -> m (n a);
this is the sequence method of a Traversable instance for n.
Oh, *that's* Traversable?
Mind you, looking at Data.Traversable, it demands instances for
something called "Foldable" first (plus Functor, which I already happen
to have).
(Looking up Foldable immediately meantions something called "Monoid"...
I'm rapidly getting lost here.)
Then you
can write join :: m (n (m (n a))) -> m (n a) as
m (n (m (n a))) --- fmap sequence ---> m (m (n (n a)))
------ join ---------> m (n (n a))
------ join ---------> m (n a).
Um... OK. Ouch. :-S
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
