diff --git a/Control/Continue.hs b/Control/Continue.hs deleted file mode 100644 --- a/Control/Continue.hs +++ /dev/null @@ -1,24 +0,0 @@ --- | --- Module: Control.Continue --- Copyright: (c) 2012 Ertugrul Soeylemez --- License: BSD3 --- Maintainer: Ertugrul Soeylemez --- --- Proxy to the various modules of the continue package. - -module Control.Continue - ( -- * Continue modules - module Control.Continue.Class, - module Control.Continue.Types, - module Control.Continue.Utils, - - -- * Convenience reexports - Alt(..), - Plus(..) - ) - where - -import Control.Continue.Class -import Control.Continue.Types -import Control.Continue.Utils -import Data.Functor.Plus diff --git a/Control/Continue/Class.hs b/Control/Continue/Class.hs deleted file mode 100644 --- a/Control/Continue/Class.hs +++ /dev/null @@ -1,77 +0,0 @@ --- | --- Module: Control.Continue.Class --- Copyright: (c) 2013 Ertugrul Soeylemez --- License: BSD3 --- Maintainer: Ertugrul Soeylemez - -{-# LANGUAGE UndecidableInstances #-} - -module Control.Continue.Class - ( -- * Suspension - MonadContinue(..) - ) - where - -import qualified Control.Monad.Trans.State.Strict as Ss -import qualified Control.Monad.Trans.Writer.Strict as Ws -import Control.Monad.Trans.Identity -import Control.Monad.Trans.Maybe -import Control.Monad.Trans.Reader -import Control.Monad.Trans.State.Lazy -import Control.Monad.Trans.Writer.Lazy -import Data.Monoid -import Data.Functor.Plus - - --- | Type class for monads that support suspension and continuation --- spots. - -class (Plus f, Monad m, Monoid e) => MonadContinue e f m | m -> e, m -> f where - -- | Add the given set of continuations and possibly suspend. - addCont :: - Either e a -- ^ What to return now (left suspends). - -> f (m a) -- ^ What to run and return when reentering. - -> m a - -instance (MonadContinue e f m) => MonadContinue e f (IdentityT m) where - addCont mx c = IdentityT $ addCont mx (fmap runIdentityT c) - -instance (MonadContinue e f m) => MonadContinue e f (MaybeT m) where - addCont mx c = - MaybeT $ - addCont (fmap Just mx) (fmap runMaybeT c) - -instance (MonadContinue e f m) => MonadContinue e f (ReaderT r m) where - addCont mx c = - ReaderT $ \env -> - addCont mx (fmap (flip runReaderT env) c) - --- | Time travel warning: Captures the current state, not the state at --- reentry! - -instance (MonadContinue e f m) => MonadContinue e f (StateT s m) where - addCont mx c = - StateT $ \s -> - addCont (fmap (flip (,) s) mx) - (fmap (flip runStateT s) c) - --- | Time travel warning: Captures the current state, not the state at --- reentry! - -instance (MonadContinue e f m) => MonadContinue e f (Ss.StateT s m) where - addCont mx c = - Ss.StateT $ \s -> - addCont (fmap (flip (,) s) mx) - (fmap (flip Ss.runStateT s) c) - -instance (MonadContinue e f m, Monoid l) => MonadContinue e f (WriterT l m) where - addCont mx c = - WriterT $ - addCont (fmap (flip (,) mempty) mx) - (fmap runWriterT c) - -instance (MonadContinue e f m, Monoid l) => MonadContinue e f (Ws.WriterT l m) where - addCont mx c = - Ws.WriterT $ - addCont (fmap (flip (,) mempty) mx) - (fmap Ws.runWriterT c) diff --git a/Control/Continue/Types.hs b/Control/Continue/Types.hs deleted file mode 100644 --- a/Control/Continue/Types.hs +++ /dev/null @@ -1,174 +0,0 @@ --- | --- Module: Control.Continue.Types --- Copyright: (c) 2012 Ertugrul Soeylemez --- License: BSD3 --- Maintainer: Ertugrul Soeylemez --- --- Types used in the continue library. - -{-# LANGUAGE UndecidableInstances #-} - -module Control.Continue.Types - ( -- * Suspendable computations - ContinueT(..), - Continue, - - -- * Convenience types - LastEx - ) - where - -import qualified Data.Bifunctor as Bi -import Control.Applicative -import Control.Arrow -import Control.Continue.Class -import Control.Exception (SomeException) -import Control.Monad -import Control.Monad.Base -import Control.Monad.Error.Class -import Control.Monad.Identity -import Control.Monad.Reader.Class -import Control.Monad.State.Class -import Control.Monad.Trans -import Control.Monad.Trans.Control -import Control.Monad.Writer.Class -import Data.Functor.Plus -import Data.Monoid - - --- | This monad transformer adds continuations under @f@ and @e@-typed --- suspensions to @m@. - -newtype ContinueT e f m a = - ContinueT { - runContinueT :: m (Either e a, f (ContinueT e f m a)) - } - -instance (Monad m, Monoid e, Plus f) => Alternative (ContinueT e f m) where - empty = ContinueT (return (Left mempty, zero)) - - ContinueT c1 <|> ContinueT c2 = - ContinueT $ do - (mx1, cf1) <- c1 - (mx2, cf2) <- c2 - let mx = either (\ex1 -> Bi.first (ex1 <>) mx2) Right mx1 - return (mx, cf1 cf2) - -instance (Monad m, Plus f) => Applicative (ContinueT e f m) where - pure x = ContinueT (return (Right x, zero)) - - ContinueT cf <*> rx@(ContinueT cx) = - ContinueT $ do - (mf, cff) <- cf - case mf of - Left ex -> return (Left ex, fmap (<*> rx) cff) - Right f -> do - (mx, cfx) <- cx - return (fmap f mx, fmap (fmap f) cfx) - -instance (Functor f, Monad m) => Functor (ContinueT e f m) where - fmap f (ContinueT c) = ContinueT (liftM (fmap f *** fmap (fmap f)) c) - -instance (Monad m, Monoid e, Plus f) => Monad (ContinueT e f m) where - return = pure - - ContinueT c >>= f = - ContinueT $ do - (mx, cfx') <- c - let cfx = fmap (>>= f) cfx' - case mx of - Left ex -> return (Left ex, cfx) - Right x -> do - (my, cfy) <- runContinueT (f x) - return (my, cfx cfy) - - fail _ = ContinueT (return (Left mempty, zero)) - -instance (MonadBase b m, Monoid e, Plus f) => MonadBase b (ContinueT e f m) where - liftBase = liftBaseDefault - -instance (MonadBaseControl b m, Monoid e, Plus f) => MonadBaseControl b (ContinueT e f m) where - data StM (ContinueT e f m) a = - StContinueT (StM m (Either e a, f (ContinueT e f m a))) - - liftBaseWith k = - ContinueT $ do - x <- - liftBaseWith $ \runB -> - k $ \(ContinueT c) -> - liftM StContinueT (runB c) - return (Right x, zero) - - restoreM (StContinueT s) = ContinueT (restoreM s) - -instance (Monad m, Monoid e, Plus f) => MonadContinue e f (ContinueT e f m) where - addCont mx cf = ContinueT (return (mx, cf)) - -instance (Monad m, Monoid e, Plus f) => MonadError e (ContinueT e f m) where - throwError ex = ContinueT (return (Left ex, zero)) - catchError (ContinueT c) h = - ContinueT $ do - (mx, cf) <- c - case mx of - Left ex -> do - (mxh, cfh) <- runContinueT (h ex) - return (mxh, cf cfh) - Right _ -> return (mx, cf) - --- | Warning: If feedback is broken by suspension you get a run-time --- error. - -instance (MonadFix m, Monoid e, Plus f) => MonadFix (ContinueT e f m) where - mfix f = - ContinueT . mfix $ \ ~(mx, _) -> - runContinueT . f . - either (const $ error "Feedback broken by suspension") id $ mx - -instance (MonadIO m, Monoid e, Plus f) => MonadIO (ContinueT e f m) where - liftIO = ContinueT . liftM (\x -> (Right x, zero)) . liftIO - -instance (Monad m, Monoid e, Plus f) => MonadPlus (ContinueT e f m) where - mzero = empty - mplus = (<|>) - -instance (MonadReader r m, Monoid e, Plus f) => MonadReader r (ContinueT e f m) where - ask = lift ask - local f (ContinueT c) = ContinueT (local f c) - reader = ContinueT . liftM (\x -> (Right x, zero)) . reader - -instance (MonadState s m, Monoid e, Plus f) => MonadState s (ContinueT e f m) where - get = lift get - put = lift . put - state = lift . state - -instance (Plus f) => MonadTrans (ContinueT e f) where - lift = ContinueT . liftM (\x -> (Right x, zero)) - -instance (MonadWriter l m, Monoid e, Plus f) => MonadWriter l (ContinueT e f m) where - listen (ContinueT c) = - ContinueT $ do - ((mx, cf), w) <- listen c - let addLog x = (x, w) - return (fmap addLog mx, fmap (fmap addLog) cf) - - pass (ContinueT c) = - ContinueT . pass $ do - (mx, cf') <- c - let cf = fmap (fmap fst) cf' - case mx of - Left ex -> return ((Left ex, cf), id) - Right (x, f) -> return ((Right x, cf), f) - - tell = lift . tell - writer = lift . writer - - --- | 'ContinueT' over 'Identity'. - -type Continue e f = ContinueT e f Identity - - --- | Type alias for the common case of using @'Last' 'SomeException'@ as --- the suspension monoid. - -type LastEx = Last SomeException diff --git a/Control/Continue/Utils.hs b/Control/Continue/Utils.hs deleted file mode 100644 --- a/Control/Continue/Utils.hs +++ /dev/null @@ -1,51 +0,0 @@ --- | --- Module: Control.Continue.Utils --- Copyright: (c) 2012 Ertugrul Soeylemez --- License: BSD3 --- Maintainer: Ertugrul Soeylemez --- --- Suspension/continuation utilities. - -module Control.Continue.Utils - ( -- * Basic utilities - addCont_, - continue, - continue_, - suspend - ) - where - -import Control.Continue.Class -import Data.Functor.Plus - - --- | Add the given set of continuations without suspending. - -addCont_ :: (MonadContinue e f m) => f (m ()) -> m () -addCont_ = addCont (Right ()) - - --- | Allow to continue here with the given value. - -continue :: - (MonadContinue e f m) - => Either e a -- ^ What to return now (left suspends). - -> f (Either e a) -- ^ What to return when reentering (left suspends). - -> m a -continue mx = addCont mx . fmap (\mx -> addCont mx zero) - - --- | Allow to continue here. - -continue_ :: - (MonadContinue e f m) - => f () -- ^ Reentering key. - -> m () -continue_ = addCont (Right ()) . fmap (const $ return ()) - - --- | Suspend with the given value. Does not register any continuation --- spots. Note that @suspend mempty@ is equivalent to @empty@. - -suspend :: (MonadContinue e f m) => e -> m a -suspend ex = addCont (Left ex) zero diff --git a/Control/Monad/Continue.hs b/Control/Monad/Continue.hs new file mode 100644 --- /dev/null +++ b/Control/Monad/Continue.hs @@ -0,0 +1,305 @@ +-- | +-- Module: Control.Monad.Continue +-- Copyright: (c) 2012 Ertugrul Soeylemez +-- License: BSD3 +-- Maintainer: Ertugrul Soeylemez +-- +-- This library implements a monad transformer for suspendable +-- computations, similar and related to free comonads. It allows to +-- write continuation-based web frameworks, command line applications +-- and similar interfaces, where you want to reenter a computation at +-- arbitrary spots. + +{-# LANGUAGE UndecidableInstances #-} + +module Control.Monad.Continue + ( -- $doc + + -- * Continue + Continue, + runContinue, + + -- * ContinueT + ContinueT(..), + mapContinueT, + + -- * Combinators + orElse, + + -- * Convenience types + LastEx, + + -- * Reexports + module Control.Monad.Continue.Class, + Alt(..), + Plus(..) + ) + where + +import qualified Data.Bifunctor as Bi +import Control.Applicative +import Control.Arrow +import Control.Exception (SomeException) +import Control.Monad +import Control.Monad.Base +import Control.Monad.Continue.Class +import Control.Monad.Error.Class +import Control.Monad.Fix +import Control.Monad.Identity +import Control.Monad.Reader.Class +import Control.Monad.State.Class +import Control.Monad.Trans +import Control.Monad.Trans.Control +import Control.Monad.Writer.Class +import Data.Functor.Plus +import Data.Monoid + + +-- | This monad transformer adds continuations under @f@ and @e@-typed +-- suspensions to @m@. + +newtype ContinueT e f m a = + ContinueT { + runContinueT :: m (Either e a, f (ContinueT e f m a)) + } + +instance (Monad m, Monoid e, Plus f) => Alternative (ContinueT e f m) where + empty = ContinueT (return (Left mempty, zero)) + + ContinueT c1 <|> ContinueT c2 = + ContinueT $ do + (mx1, cf1) <- c1 + (mx2, cf2) <- c2 + let mx = either (\ex1 -> Bi.first (ex1 <>) mx2) Right mx1 + return (mx, cf1 cf2) + +instance (Monad m, Plus f) => Applicative (ContinueT e f m) where + pure x = ContinueT (return (Right x, zero)) + + ContinueT cf <*> rx@(ContinueT cx) = + ContinueT $ do + (mf, cff) <- cf + case mf of + Left ex -> return (Left ex, fmap (<*> rx) cff) + Right f -> do + (mx, cfx) <- cx + return (fmap f mx, fmap (fmap f) cfx) + +instance (Functor f, Monad m) => Functor (ContinueT e f m) where + fmap f (ContinueT c) = ContinueT (liftM (fmap f *** fmap (fmap f)) c) + +instance (Monad m, Monoid e, Plus f) => Monad (ContinueT e f m) where + return = pure + + ContinueT c >>= f = + ContinueT $ do + (mx, cfx') <- c + let cfx = fmap (>>= f) cfx' + case mx of + Left ex -> return (Left ex, cfx) + Right x -> do + (my, cfy) <- runContinueT (f x) + return (my, cfx cfy) + + fail _ = ContinueT (return (Left mempty, zero)) + +instance (MonadBase b m, Monoid e, Plus f) => MonadBase b (ContinueT e f m) where + liftBase = liftBaseDefault + +instance (MonadBaseControl b m, Monoid e, Plus f) => MonadBaseControl b (ContinueT e f m) where + data StM (ContinueT e f m) a = + StContinueT (StM m (Either e a, f (ContinueT e f m a))) + + liftBaseWith k = + ContinueT $ do + x <- + liftBaseWith $ \runB -> + k $ \(ContinueT c) -> + liftM StContinueT (runB c) + return (Right x, zero) + + restoreM (StContinueT s) = ContinueT (restoreM s) + +instance (Monad m, Monoid e, Plus f) => MonadContinue e f (ContinueT e f m) where + addCont mx cf = ContinueT (return (mx, cf)) + +instance (Monad m, Monoid e, Plus f) => MonadError e (ContinueT e f m) where + throwError ex = ContinueT (return (Left ex, zero)) + catchError (ContinueT c) h = + ContinueT $ do + (mx, cf) <- c + case mx of + Left ex -> do + (mxh, cfh) <- runContinueT (h ex) + return (mxh, cf cfh) + Right _ -> return (mx, cf) + +-- | Warning: If feedback is broken by suspension you get a run-time +-- error. + +instance (MonadFix m, Monoid e, Plus f) => MonadFix (ContinueT e f m) where + mfix f = + ContinueT . mfix $ \ ~(mx, _) -> + runContinueT . f . + either (const $ error "Feedback broken by suspension") id $ mx + +instance (MonadIO m, Monoid e, Plus f) => MonadIO (ContinueT e f m) where + liftIO = ContinueT . liftM (\x -> (Right x, zero)) . liftIO + +instance (Monad m, Monoid e, Plus f) => MonadPlus (ContinueT e f m) where + mzero = empty + mplus = (<|>) + +instance (MonadReader r m, Monoid e, Plus f) => MonadReader r (ContinueT e f m) where + ask = lift ask + local f (ContinueT c) = ContinueT (local f c) + reader = ContinueT . liftM (\x -> (Right x, zero)) . reader + +instance (MonadState s m, Monoid e, Plus f) => MonadState s (ContinueT e f m) where + get = lift get + put = lift . put + state = lift . state + +instance (Plus f) => MonadTrans (ContinueT e f) where + lift = ContinueT . liftM (\x -> (Right x, zero)) + +instance (MonadWriter l m, Monoid e, Plus f) => MonadWriter l (ContinueT e f m) where + listen (ContinueT c) = + ContinueT $ do + ((mx, cf), w) <- listen c + let addLog x = (x, w) + return (fmap addLog mx, fmap (fmap addLog) cf) + + pass (ContinueT c) = + ContinueT . pass $ do + (mx, cf') <- c + let cf = fmap (fmap fst) cf' + case mx of + Left ex -> return ((Left ex, cf), id) + Right (x, f) -> return ((Right x, cf), f) + + tell = lift . tell + writer = lift . writer + + +-- | 'ContinueT' over 'Identity'. + +type Continue e f = ContinueT e f Identity + + +-- | Type alias for the common case of using @'Last' 'SomeException'@ as +-- the suspension monoid. + +type LastEx = Last SomeException + + +-- | Apply the given morphism to the underlying monad. + +mapContinueT :: + (Functor f, Monad n) + => (forall a. m a -> n a) -- ^ Monad morphism to apply. + -> ContinueT e f m a + -> ContinueT e f n a +mapContinueT mm (ContinueT c) = + ContinueT $ do + (mx, cf) <- mm c + return (mx, fmap (mapContinueT mm) cf) + + +-- | Similar to '<|>', but tries the second computation only if the +-- first one actually suspends. Note that not running the second +-- computation also means that it can't register reentry spots. +-- +-- As an operator this function is infixr 3. + +orElse :: + (Alt f, Monad m, Monoid e) + => ContinueT e f m a + -> ContinueT e f m a + -> ContinueT e f m a +orElse (ContinueT c1) (ContinueT c2) = + ContinueT $ do + (mx1, cf1) <- c1 + case mx1 of + Left ex1 -> do + (mx2, cf2) <- c2 + return (Bi.first (ex1 <>) mx2, cf1 cf2) + Right _ -> return (mx1, cf1) + +infixr 3 `orElse` + + +-- | Run the given 'Continue' computation. + +runContinue :: Continue e f a -> (Either e a, f (Continue e f a)) +runContinue = runIdentity . runContinueT + + +{- $doc + +A computation of type @'ContinueT' e f m a@ is a computation that may +either conclude with a value of type @a@ or suspend with a value of type +@e@. Before suspending or concluding it may register a set of reentry +spots of type @f (ContinueT e f m a)@. These spots are collected and +returned along with the suspension/conclusion value: + +> newtype ContinueT e f m a + +To run a @ContinueT@ computation you can use the 'runContinueT' +function: + +> runContinueT :: ContinueT e f m a +> -> m (Either e a, f (ContinueT e f m a)) + +The result is either a suspension value of type @e@ or a conclusion of +type @a@. In both cases you can reenter the computation at the +registered spots. Example: + +> type MyMonad = ContinueT () (Map String) Identity +> +> myComp :: MyMonad Integer +> myComp = do +> x <- continue (Right 3) (M.singleton "x" (Right 15)) +> y <- continue (Right 4) (M.singleton "y" (Right 17)) +> return (x + y) + +When you first run this computation the result will be the conclusion 3 ++ 4. Since 'MyMonad' transforms to 'Identity' we can use the +convenience type alias 'Continue' and the function 'runContinue': + +> type MyMonad = Continue () (Map String) +> +> runContinue myComp +> = (Right 7, reentryMap) + +Along with the result you will also get a reentry map of type @Map +String (MyMonad Integer)@. If you run the computation indexed by \"x\", +you will get the result 15 + 4. This iteration itself will return a new +reentry map on its part. That map will contain only the reentry spot +\"y\", because the reentry indexed by \"x\" does not register itself +again. + +You can use the more general 'addCont' function to register arbitrary +reentry spots, which themselves are allowed to register new spots. Also +In some kinds of applications you would want to combine the reentry maps +produced. You can use the '' function to do that: + +> let overallReentryMap = reentryMap1 reentryMap2 + +Since @e@ is required to be a monoid, @ContinueT@ forms a family of +alternative functors that implement choice based on suspension and +conclusion. The computation 'empty' always suspends with 'mempty'. + +> x <|> y + +This computation concludes with the conclusion of either @x@ or @y@ +trying them in that order, or suspends if both of them suspend. Note +that both computations are performed to their conclusion or suspension. +This allows @y@ both to have monadic effects as well as to register +reentry points, even if @x@ concludes. + +There is also a combinator 'orElse' that tries @y@ only if @x@ actually +suspends. In that case, if @x@ concludes, then @y@ cannot register +reentry spots or have effects in the underlying monad. + +-} diff --git a/Control/Monad/Continue/Class.hs b/Control/Monad/Continue/Class.hs new file mode 100644 --- /dev/null +++ b/Control/Monad/Continue/Class.hs @@ -0,0 +1,123 @@ +-- | +-- Module: Control.Monad.Continue.Class +-- Copyright: (c) 2013 Ertugrul Soeylemez +-- License: BSD3 +-- Maintainer: Ertugrul Soeylemez + +{-# LANGUAGE UndecidableInstances #-} + +module Control.Monad.Continue.Class + ( -- * Suspension + MonadContinue(..), + + -- * Basic utilities + addCont_, + continue, + continue_, + suspend, + suspendWith + ) + where + +import qualified Control.Monad.Trans.State.Strict as Ss +import qualified Control.Monad.Trans.Writer.Strict as Ws +import Control.Monad.Trans.Identity +import Control.Monad.Trans.Maybe +import Control.Monad.Trans.Reader +import Control.Monad.Trans.State.Lazy +import Control.Monad.Trans.Writer.Lazy +import Data.Functor.Plus +import Data.Monoid + + +-- | Type class for monads that support suspension and continuation +-- spots. + +class (Plus f, Monad m, Monoid e) => MonadContinue e f m | m -> e, m -> f where + -- | Add the given set of continuations and possibly suspend. + addCont :: + Either e a -- ^ What to return now (left suspends). + -> f (m a) -- ^ What to run and return when reentering. + -> m a + +instance (MonadContinue e f m) => MonadContinue e f (IdentityT m) where + addCont mx c = IdentityT $ addCont mx (fmap runIdentityT c) + +instance (MonadContinue e f m) => MonadContinue e f (MaybeT m) where + addCont mx c = + MaybeT $ + addCont (fmap Just mx) (fmap runMaybeT c) + +instance (MonadContinue e f m) => MonadContinue e f (ReaderT r m) where + addCont mx c = + ReaderT $ \env -> + addCont mx (fmap (flip runReaderT env) c) + +-- | Time travel warning: Captures the current state, not the state at +-- reentry. Use 'ContinueT' over 'StateT' instead to fix this. + +instance (MonadContinue e f m) => MonadContinue e f (StateT s m) where + addCont mx c = + StateT $ \s -> + addCont (fmap (flip (,) s) mx) + (fmap (flip runStateT s) c) + +-- | Time travel warning: Captures the current state, not the state at +-- reentry. Use 'ContinueT' over 'StateT' instead to fix this. + +instance (MonadContinue e f m) => MonadContinue e f (Ss.StateT s m) where + addCont mx c = + Ss.StateT $ \s -> + addCont (fmap (flip (,) s) mx) + (fmap (flip Ss.runStateT s) c) + +instance (MonadContinue e f m, Monoid l) => MonadContinue e f (WriterT l m) where + addCont mx c = + WriterT $ + addCont (fmap (flip (,) mempty) mx) + (fmap runWriterT c) + +instance (MonadContinue e f m, Monoid l) => MonadContinue e f (Ws.WriterT l m) where + addCont mx c = + Ws.WriterT $ + addCont (fmap (flip (,) mempty) mx) + (fmap Ws.runWriterT c) + + +-- | Add the given set of continuations without suspending. + +addCont_ :: (MonadContinue e f m) => f (m ()) -> m () +addCont_ = addCont (Right ()) + + +-- | Allow to continue here with the given value. + +continue :: + (MonadContinue e f m) + => Either e a -- ^ What to return now (left suspends). + -> f (Either e a) -- ^ What to return when reentering (left suspends). + -> m a +continue mx = addCont mx . fmap (\mx -> addCont mx zero) + + +-- | Allow to continue here. + +continue_ :: + (MonadContinue e f m) + => f () -- ^ Reentering key. + -> m () +continue_ = addCont (Right ()) . fmap (const $ return ()) + + +-- | Suspend with the given value. Does not register any continuation +-- spots. Note that @suspend mempty@ is equivalent to @empty@. + +suspend :: (MonadContinue e f m) => e -> m a +suspend ex = addCont (Left ex) zero + + +-- | Suspend with 'mempty' and register the given continuations. Note +-- that @suspendWith zero@ is equivalent to @empty@. + +suspendWith :: (MonadContinue e f m) => f (m a) -> m a +suspendWith = addCont (Left mempty) diff --git a/continue.cabal b/continue.cabal --- a/continue.cabal +++ b/continue.cabal @@ -1,7 +1,7 @@ Name: continue -Version: 0.1.1 +Version: 0.2.0 Category: Control -Synopsis: Continuation-based user interaction monad +Synopsis: Monads with suspension and arbitrary-spot reentry Maintainer: Ertugrul Söylemez Author: Ertugrul Söylemez Copyright: (c) 2012 Ertugrul Söylemez @@ -15,7 +15,8 @@ This library implements a monad transformer for suspendable computations, similar and related to free comonads. It allows to write continuation-based web frameworks, command line applications - and similar interfaces. + and similar interfaces, where you want to reenter a computation at + arbitrary spots. Source-repository head type: git @@ -34,29 +35,39 @@ Default-extensions: FlexibleInstances FunctionalDependencies + RankNTypes MultiParamTypeClasses TypeFamilies Other-extensions: UndecidableInstances GHC-Options: -W Exposed-modules: - Control.Continue - Control.Continue.Class - Control.Continue.Types - Control.Continue.Utils + Control.Monad.Continue + Control.Monad.Continue.Class -- Test-suite continue-test -- Type: exitcode-stdio-1.0 -- Build-depends: -- base >= 4.5 && < 5, +-- blaze-builder, +-- boomerang, -- conduit, -- containers, -- continue, -- http-types, +-- mtl, -- wai, --- warp +-- warp, +-- web-routes, +-- web-routes-boomerang -- Default-language: Haskell2010 -- Default-extensions: +-- FlexibleInstances +-- MultiParamTypeClasses +-- OverloadedStrings +-- TemplateHaskell +-- TypeOperators +-- UndecidableInstances -- GHC-Options: -threaded -rtsopts -- Hs-source-dirs: test -- Main-is: Main.hs