On Thu, 2009-02-12 at 23:36 +0000, Edsko de Vries wrote: > Hi, > > I can desugar > > do x' <- x > f x' > > as > > x >>= \x -> f x' > > which is clearly the same as > > x >>= f > > However, now consider > > do x' <- x > y' <- y > f x' y' > > desugared, this is > > x >>= \x -> y >>= \y' -> f x' y' > > I can simplify the second half to > > x >>= \x -> y >>= f x' > > but now we are stuck. I feel it should be possible to write something like > > x ... y ... f > > or perhaps > > f ... x ... y > > the best I could come up with was > > join $ return f `ap` x `ap` y > > which is not terrible but quite as easy as I feel this should be. Any hints?
Copying a bit of Applicative style, you could say join $ f `liftM` x `ap` y I've thought it would be nice to have something like app :: Monad m => m (a -> m b) -> m a -> m b app af ax = join $ af `ap` ax in the standard library. Then you could simplify to f `liftM` x `app` y I think that's as simple as you're going to get. For more arguments, say f `liftM` x `ap` y `app` z The rule is: first application operator is `liftM` (or <$> --- I always define Applicative instances for my monads); last application operator is `app`; the operators in-between are all `ap`. I think that's a pretty straight-forward rule to follow. jcc _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe