On Thu, 27 Nov 2003 14:56:03 +0000 Graham Klyne <[EMAIL PROTECTED]> wrote:
(perhaps a more serious and to the point reply later)
> But not all cases I encounter involve lists or monads. A different > case might look like this:
Are you sure this doesn't involve monads?
No, I'm not, and yours is very much the kind of response I was hoping to elicit... but I think I may need a little more help to properly "get it".
I'm looking at: [1] http://www.haskell.org/hawiki/MonadReader [2] http://www.haskell.org/ghc/docs/latest/html/base/Control.Monad.Reader.html [3] http://www.nomaware.com/monads/html/readermonad.html
You say of my examples "(these work fine with a Monad instance ((->) r) which is a Reader monad)". If I get this correctly, (->) used here is a type constructor for a function type [ah yes... p42 of the Haskell report, but not in the index].
In [2] I see ((->) r) as an instance of MonadReader r, which you also say. I think this means that a function from r to something is an instance MonadReader r. So in my definition of eval:
eval f g1 g2 a = f (g1 a) (g2 a)
g1 and g2 are instances of MonadReader a. Which I can see means that eval is liftM2 as you say: it takes a 2-argument function f and 'lifts' it to operate on the monads g1 and g2.
So far, so good, but what are the implications of g1 and g2 being monads? From [2], we have: class (Monad m) => MonadReader r m | m -> r where MonadReader r ((->) r) So ((->) r) must be a Monad. How are the standard monad operators implemented for ((->) r)? Maybe:
instance Monad ((->) r) where
return a = const a -- is this right? As I understand,
-- return binds some value into a monad.
-- (>>=) :: m a -> (a -> m b) -> m b
g1 >>= f = \e -> f (g1 e) e<aside>
so, if f is \a -> g2, we get:
g1 >>= f = \e -> (\a -> g2) (g1 e) e
= \e -> g2 e
= g2
</aside>Hmmm... this seems plausible, but I'm not clear-sighted enough to see if I have the ((->) r) monad right. [Later: though it seems to work as intended.]
Looking at [3], I get a little more insight. It seems that ((->) r) is a function with a type of "Computations which read values from a shared environment", where r is the type of the shared environment. Monadic sequencing (>>=) passes the result from one monad/function to the next. The monad is used by applying it to an instance of the shared environment.
So, returning to my example, it would appear that the idiom I seek is:
liftM2 f g1 g2
or:
liftM3 f g1 g2 g3
etc.Provided that ((->) r) is appropriately declared as an instance of Monad. Does this work with the above declaration?
liftM2 f g1 g2
= do { g1' <- g1 ; g2' <- g2 ; return (f g1' g2') } [from Monad]
= g1 >>= \g1' -> g2 >>= \g2' -> return (f g1' g2') [do-notation]
= \e1 -> (\g1' -> g2 >>= \g2' -> return (f g1' g2')) (g1 e1) e1
[above: g1 >>= f = (\e -> f (g1 e) e)]
= \e1 -> (\g1' -> \e2 -> (\g2' -> return (f g1' g2')) (g2 e2) e2) (g1 e1) e1
[again]
= \e1 -> (\e2 -> (return (f (g1 e1) (g2 e2))) e2) e1
[apply fns: g1' = g1 e1,g2' = g2 e2]
= \e1 -> (return (f (g1 e1) (g2 e1))) e1
[apply fn: e2 = e1]
= \e1 -> (return (f (g1 e1) (g2 e1))) e1
[apply fn: e2 = e1]
= \e1 -> (const (f (g1 e1) (g2 e1))) e1
[above: return = const]
= \e1 -> (f (g1 e1) (g2 e1)))
[apply const]
Which is the desired result (!)
(these work fine with a Monad instance ((->) r) which is a Reader monad)
Hmmm... is it true that ((->) r) *is* a reader monad? It seems to me that it is a Monad which can be used to build a reader monad.
...
The more I do with Haskell the more impressed I am by the folks who figured out this Monad wizardry.
A question I find myself asking at the end: why isn't ((->) r) declared as a Monad instance in the standard prelude? If I'm following all this correctly, it seems like a natural to include there.
Thanks for pointing me in this direction. I hope my ramblings are on-track, and not too tedious to wade through.
#g --
> > eval :: (b->c->d) -> (a->b) -> (a->c) -> (a->d) > > eval f g1 g2 a = f (g1 a) (g2 a)
eval :: Monad m => (b -> c -> d) -> m b -> m c -> m d eval = liftM2
> So, for example, a function to test of the two elements of a pair are > the same might be: > > > pairSame = eval (==) fst snd > > giving: > > > pairSame (1,2) -- false > > pairSame (3,3) -- true > > > Or a function to subtract the second and subsequent elements of a list > from the first: > > > firstDiffRest = eval (-) head (sum . tail) > > > firstDiffRest [10,4,3,2,1] -- 0
------------ Graham Klyne For email: http://www.ninebynine.org/#Contact
_______________________________________________ Haskell-Cafe mailing list [EMAIL PROTECTED] http://www.haskell.org/mailman/listinfo/haskell-cafe
