Sorry for third post but I wonder why the many instances are restricted by Monad.
Both Functor and Applicative can by constructed without Monad: > instance (Functor m) => Functor (CtlArg t m) where > fmap f (CtlArg arg g c) = CtlArg arg (fmap f . g) c > > instance (Functor m) => Functor (Iter t m) where > {-# INLINE fmap #-} > fmap f (Iter g) = Iter (fmap f . g > > instance (Functor m) => Functor (IterR t m) where > fmap f (IterF i) = IterF (fmap f i) > fmap f (IterM i) = IterM (fmap (fmap f) i) > fmap f (IterC c) = IterC (fmap f c) > fmap f (Done a c) = Done (f a) c > fmap f (Fail i m mc) = Fail i (fmap f m) mc > > instance (Functor m) => Applicative (Iter t m) where > {-# INLINE pure #-} > pure x = Iter $ Done x > {-# INLINE (<*>) #-} > Iter a <*> bi@(Iter b) = Iter $ \c -> fix (\f ir -> case ir of > IterF cont -> cont <*> bi > IterM m -> IterM $ fmap f m > IterC (CtlArg a cn ch) -> > IterC (CtlArg a (\r -> cn r <*> bi) ch) > Done v ch -> fmap v (b ch) > Fail f _ ch -> Fail f Nothing ch) a c Since every monad is applicative (or rather should be) it doesn't loose generality. Join is also defined by using only functor: > joinI :: (Functor m) => Iter t m (Iter t m a) -> Iter t m a > joinI (Iter i) = Iter $ \c -> fix (\f x -> case x of > IterF cont -> IterF (joinI cont) > IterM m -> IterM $ fmap f m > IterC (CtlArg a cn ch) -> > IterC (CtlArg a (\r -> joinI (cn r)) ch) > Done v ch -> runIter v ch > Fail f _ ch -> Fail f Nothing ch) (i c) Regards PS. I haven't tested the code or benchmarked it - but it seems it is possible.
signature.asc
Description: This is a digitally signed message part
_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe