contstuff 0.5.1 → 0.6.0

raw patch · 2 files changed

+345/−305 lines, 2 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• Control/ContStuff.hs +338/−301
• contstuff.cabal +7/−4

@@ -14,57 +14,59 @@   TypeFamilies #-}  module Control.ContStuff-  ( -- * Monad transformers-    -- ** Identity transformer-    IdT(..),-    -- ** ContT-    ContT(..), runContT, evalContT, modifyContT,-    -- ** Choice/nondeterminism-    ChoiceT(..), runChoiceT, choice, findFirst, findFirst_, findAll,-                 findAll_, listChoiceT, listA, maybeChoiceT,-    -- ** Exceptions-    EitherT(..), runEitherT, evalEitherT, modifyEitherT,-    MaybeT(..), runMaybeT, evalMaybeT, modifyMaybeT,-    -- ** State-    StateT(..), runStateT, evalStateT, execStateT,-    -- ** Writer monads-    WriterT, runWriterT,-    OldWriterT, runOldWriterT, evalOldWriterT, execOldWriterT,+    ( -- * Monad transformers+      -- ** Identity transformer+      IdT(..),+      -- ** ContT+      ContT(..), runContT, evalContT, modifyContT,+      -- ** Choice/nondeterminism+      ChoiceT(..), runChoiceT, choice, findAll, findAll_, findFirst,+                   findFirst_, listA, listChoiceT, maybeChoiceT,+      -- ** Exceptions+      EitherT(..), runEitherT, evalEitherT, modifyEitherT,+      MaybeT(..), runMaybeT, evalMaybeT, modifyMaybeT,+      -- ** State+      StateT(..), runStateT, evalStateT, execStateT,+      -- ** Writer monads+      WriterT, runWriterT,+      OldWriterT, runOldWriterT, evalOldWriterT, execOldWriterT, -    -- * Monads-    -- ** Identity monad-    Id(..),-    -- ** Choice-    Choice, listChoice, maybeChoice,-    -- ** Cont-    Cont, runCont, evalCont, modifyCont,-    -- ** State-    State, runState, evalState, execState,-    -- ** Writer-    OldWriter, runOldWriter, evalOldWriter, execOldWriter,+      -- * Monads+      -- ** Identity monad+      Id(..),+      -- ** Choice+      Choice, listChoice, maybeChoice,+      -- ** Cont+      Cont, runCont, evalCont, modifyCont,+      -- ** State+      State, runState, evalState, execState,+      -- ** Writer+      OldWriter, runOldWriter, evalOldWriter, execOldWriter, -    -- * Effect classes-    -- ** Abortion-    Abortable(..),-    -- ** Call with current continuation-    CallCC(..), Label, labelCC, goto,-    -- ** Exceptions-    HasExceptions(..), catch, handle, finally, bracket, bracket_,-    -- ** Lifting-    Transformer(..),-    LiftBase(..), io,-    -- ** Running-    Runnable(..),-    -- ** State-    Stateful(..), getField, modify, modifyField, modifyFieldLazy, modifyLazy,-    -- ** Logging support (writers)-    Writable(..),+      -- * Effect classes+      -- ** Abortion+      Abortable(..),+      -- ** Call with current continuation+      CallCC(..), Label, labelCC, goto,+      -- ** Exceptions+      HasExceptions(..), bracket, bracket_, catch, finally, forbid,+                         handle, raiseUnless, raiseWhen, require,+      -- ** Lifting+      Transformer(..),+      LiftBase(..), io,+      -- ** Running+      Runnable(..),+      -- ** State+      Stateful(..), getField, modify, modifyField, modifyFieldLazy,+                    modifyLazy,+      -- ** Logging support (writers)+      Writable(..), -    -- * Module reexports-    module Control.Applicative,-    module Control.Monad-  )-  where+      -- * Module reexports+      module Control.Applicative,+      module Control.Monad+    )+    where  import qualified Control.Exception as E import Control.Applicative@@ -87,21 +89,21 @@ newtype Id a = Id { getId :: a }  instance Functor Id where-  fmap f (Id x) = Id (f x)+    fmap f (Id x) = Id (f x)  instance Applicative Id where-  pure = Id-  Id f <*> Id x = Id (f x)+    pure = Id+    Id f <*> Id x = Id (f x)  instance Monad Id where-  return = Id-  Id x >>= f = f x+    return = Id+    Id x >>= f = f x  instance MonadFix Id where-  mfix f = fix (f . getId)+    mfix f = fix (f . getId)  instance Show a => Show (Id a) where-  show x = "Id " ++ show x+    show x = "Id " ++ show x   -- ================== --@@ -118,55 +120,55 @@ -- represented as a CPS-based left-fold function.  newtype ChoiceT r i m a =-  ChoiceT { getChoiceT ::-              (i -> a -> (i -> m r) -> m r)-                -> i-                -> (i -> m r)-                -> m r }+    ChoiceT { getChoiceT ::+                  (i -> a -> (i -> m r) -> m r)+                      -> i+                      -> (i -> m r)+                      -> m r }  instance Applicative m => Abortable (ChoiceT r i m) where-  type Result (ChoiceT r i m) = r-  abort x = ChoiceT $ \_ _ _ -> pure x+    type Result (ChoiceT r i m) = r+    abort x = ChoiceT $ \_ _ _ -> pure x  instance Alternative (ChoiceT r i m) where-  empty = ChoiceT $ \_ z k -> k z-  ChoiceT c <|> ChoiceT d =-    ChoiceT $ \fold z k ->-      c fold z (\zc -> d fold zc k)+    empty = ChoiceT $ \_ z k -> k z+    ChoiceT c <|> ChoiceT d =+        ChoiceT $ \fold z k ->+            c fold z (\zc -> d fold zc k)  instance Applicative (ChoiceT r i m) where-  pure x = ChoiceT $ \fold z k -> fold z x k-  ChoiceT cf <*> ChoiceT cx =-    ChoiceT $ \fold z k ->-      cx (\xx yx kx -> cf (\xf yf kf -> fold xf (yf yx) kf) xx kx) z k+    pure x = ChoiceT $ \fold z k -> fold z x k+    ChoiceT cf <*> ChoiceT cx =+        ChoiceT $ \fold z k ->+            cx (\xx yx kx -> cf (\xf yf kf -> fold xf (yf yx) kf) xx kx) z k  instance Functor (ChoiceT r i m) where-  fmap f (ChoiceT c) =-    ChoiceT $ \fold z k ->-      c (\x y k -> fold x (f y) k) z k+    fmap f (ChoiceT c) =+        ChoiceT $ \fold z k ->+            c (\x y k -> fold x (f y) k) z k  instance Monad (ChoiceT r i m) where-  return x = ChoiceT $ \fold z k -> fold z x k-  ChoiceT c >>= f =-    ChoiceT $ \fold z k ->-      c (\x y kc -> getChoiceT (f y) fold x kc) z k+    return x = ChoiceT $ \fold z k -> fold z x k+    ChoiceT c >>= f =+        ChoiceT $ \fold z k ->+            c (\x y kc -> getChoiceT (f y) fold x kc) z k  instance MonadPlus (ChoiceT r i m) where-  mzero = empty-  mplus = (<|>)+    mzero = empty+    mplus = (<|>)  instance Transformer (ChoiceT r i) where-  lift c = ChoiceT $ \fold z k -> c >>= \x -> fold z x k+    lift c = ChoiceT $ \fold z k -> c >>= \x -> fold z x k   -- | Run a choice computation.  runChoiceT ::-  (i -> a -> (i -> m r) -> m r)-    -> i-    -> (i -> m r)-    -> ChoiceT r i m a-    -> m r+    (i -> a -> (i -> m r) -> m r)+        -> i+        -> (i -> m r)+        -> ChoiceT r i m a+        -> m r runChoiceT fold z k (ChoiceT c) = c fold z k  @@ -174,11 +176,23 @@  choice :: [a] -> ChoiceT r i m a choice xs = ChoiceT (choice' xs)-  where+    where     choice' []     = \_ z k -> k z     choice' (x:xs) = \fold z k -> fold z x (\y -> choice' xs fold y k)  +-- | Find all solutions.++findAll :: (Alternative f, Applicative m) => ChoiceT (f a) (f a) m a -> m (f a)+findAll = runChoiceT (\x y k -> k (x <|> pure y)) empty pure+++-- | Find all solutions and ignore them.++findAll_ :: Applicative m => ChoiceT () i m a -> m ()+findAll_ = runChoiceT (\_ _ k -> k undefined) undefined (const $ pure ())++ -- | Find the first solution.  findFirst :: (Alternative f, Applicative m) => ChoiceT (f a) (f a) m a -> m (f a)@@ -191,16 +205,10 @@ findFirst_ = runChoiceT (\_ _ _ -> pure ()) undefined (const $ pure ())  --- | Find all solutions.--findAll :: (Alternative f, Applicative m) => ChoiceT (f a) (f a) m a -> m (f a)-findAll = runChoiceT (\x y k -> k (x <|> pure y)) empty pure----- | Find all solutions and ignore them.+-- | Turn a list into a computation with alternatives. -findAll_ :: Applicative m => ChoiceT () i m a -> m ()-findAll_ = runChoiceT (\_ _ k -> k undefined) undefined (const $ pure ())+listA :: Alternative f => [a] -> f a+listA = foldr (<|>) empty . map pure   -- | Get list of solutions (faster than 'findAll', but returns solutions@@ -210,12 +218,6 @@ listChoiceT = runChoiceT (\x y k -> k (y:x)) [] pure  --- | Turn a list into a computation with alternatives.--listA :: Alternative f => [a] -> f a-listA = foldr (<|>) empty . map pure-- -- | Get one solution (faster than 'findFirst').  maybeChoiceT :: Applicative m => ChoiceT (Maybe a) (Maybe a) m a -> m (Maybe a)@@ -247,48 +249,48 @@ -- transformer models the most basic form of CPS.  newtype ContT r m a =-  ContT { getContT :: (a -> m r) -> m r }+    ContT { getContT :: (a -> m r) -> m r }  instance Applicative m => Abortable (ContT r m) where-  type Result (ContT r m) = r-  abort = ContT . const . pure+    type Result (ContT r m) = r+    abort = ContT . const . pure  instance Alternative m => Alternative (ContT r m) where-  empty = ContT $ const empty-  ContT c <|> ContT d = ContT $ \k -> c k <|> d k+    empty = ContT $ const empty+    ContT c <|> ContT d = ContT $ \k -> c k <|> d k  instance Applicative (ContT r m) where-  pure = return-  ContT cf <*> ContT cx =-    ContT $ \k -> cf (\f -> cx (\x -> k (f x)))+    pure = return+    ContT cf <*> ContT cx =+        ContT $ \k -> cf (\f -> cx (\x -> k (f x)))  instance CallCC (ContT r m) where-  callCC f = ContT $ \k -> getContT (f (ContT . const . k)) k+    callCC f = ContT $ \k -> getContT (f (ContT . const . k)) k  instance Functor (ContT r m) where-  fmap f (ContT c) = ContT $ \k -> c (\x -> k (f x))+    fmap f (ContT c) = ContT $ \k -> c (\x -> k (f x))  instance Monad (ContT r m) where-  return x = ContT $ \k -> k x-  ContT c >>= f =-    ContT $ \k -> c (\x -> getContT (f x) k)+    return x = ContT $ \k -> k x+    ContT c >>= f =+        ContT $ \k -> c (\x -> getContT (f x) k)  instance Alternative m => MonadPlus (ContT r m) where-  mzero = empty-  mplus = (<|>)+    mzero = empty+    mplus = (<|>)  instance Runnable (ContT r) r m a where-  type Argument (ContT r) r m a = a -> m r-  runT k (ContT c) = c k+    type Argument (ContT r) r m a = a -> m r+    runT k (ContT c) = c k  instance Transformer (ContT r) where-  lift c = ContT $ \k -> c >>= k+    lift c = ContT $ \k -> c >>= k  instance Alternative m => Writable (ContT r m) r where-  tell x = ContT $ \k -> pure x <|> k ()+    tell x = ContT $ \k -> pure x <|> k ()  instance (Functor m, Monoid w) => Writable (ContT (r, w) m) w where-  tell x = ContT $ \k -> fmap (second (`mappend` x)) (k ())+    tell x = ContT $ \k -> fmap (second (`mappend` x)) (k ())   -- | Run a CPS-style computation given the supplied final continuation.@@ -340,58 +342,58 @@ -- continuation.  newtype EitherT r e m a =-  EitherT { getEitherT :: (a -> m r) -> (e -> m r) -> m r }+    EitherT { getEitherT :: (a -> m r) -> (e -> m r) -> m r }  instance Applicative m => Abortable (EitherT r e m) where-  type Result (EitherT r e m) = r-  abort x = EitherT $ \_ _ -> pure x+    type Result (EitherT r e m) = r+    abort x = EitherT $ \_ _ -> pure x  instance Applicative (EitherT r e m) where-  pure x = EitherT $ \k _ -> k x-  EitherT cf <*> EitherT cx =-    EitherT $ \k expk -> cf (\f -> cx (\x -> k (f x)) expk) expk+    pure x = EitherT $ \k _ -> k x+    EitherT cf <*> EitherT cx =+        EitherT $ \k expk -> cf (\f -> cx (\x -> k (f x)) expk) expk  instance Alternative m => Alternative (EitherT r e m) where-  empty = EitherT $ \_ _ -> empty-  EitherT c <|> EitherT d =-    EitherT $ \k expk -> c k expk <|> d k expk+    empty = EitherT $ \_ _ -> empty+    EitherT c <|> EitherT d =+        EitherT $ \k expk -> c k expk <|> d k expk  instance CallCC (EitherT r e m) where-  callCC f =-    EitherT $ \k expk ->-      getEitherT (f (\x -> EitherT $ \_ _ -> k x)) k expk+    callCC f =+        EitherT $ \k expk ->+            getEitherT (f (\x -> EitherT $ \_ _ -> k x)) k expk  instance HasExceptions (EitherT r e m) where-  type Exception (EitherT r e m) = e-  raise exp = EitherT $ \_ expk -> expk exp-  try (EitherT c) = EitherT $ \k _ -> c (k . Right) (k . Left)+    type Exception (EitherT r e m) = e+    raise exp = EitherT $ \_ expk -> expk exp+    try (EitherT c) = EitherT $ \k _ -> c (k . Right) (k . Left)  instance Functor (EitherT r e m) where-  fmap f (EitherT c) =-    EitherT $ \k expk -> c (k . f) expk+    fmap f (EitherT c) =+        EitherT $ \k expk -> c (k . f) expk  instance Monad (EitherT r e m) where-  return x = EitherT $ \k _ -> k x-  EitherT c >>= f =-    EitherT $ \k expk ->-      c (\x -> getEitherT (f x) k expk) expk+    return x = EitherT $ \k _ -> k x+    EitherT c >>= f =+        EitherT $ \k expk ->+            c (\x -> getEitherT (f x) k expk) expk  instance Alternative m => MonadPlus (EitherT r e m) where-  mzero = empty-  mplus = (<|>)+    mzero = empty+    mplus = (<|>)  instance Runnable (EitherT r e) r m a where-  type Argument (EitherT r e) r m a = (a -> m r, e -> m r)-  runT (k, expk) (EitherT c) = c k expk+    type Argument (EitherT r e) r m a = (a -> m r, e -> m r)+    runT (k, expk) (EitherT c) = c k expk  instance Transformer (EitherT r e) where-  lift c = EitherT $ \k _ -> c >>= k+    lift c = EitherT $ \k _ -> c >>= k  instance Alternative m => Writable (EitherT r e m) r where-  tell x = EitherT $ \k _ -> pure x <|> k ()+    tell x = EitherT $ \k _ -> pure x <|> k ()  instance (Functor m, Monoid w) => Writable (EitherT (r, w) e m) w where-  tell x = EitherT $ \k _ -> fmap (second (`mappend` x)) (k ())+    tell x = EitherT $ \k _ -> fmap (second (`mappend` x)) (k ())   -- | Run an 'EitherT' transformer.@@ -424,33 +426,33 @@ newtype IdT m a = IdT { getIdT :: m a }  instance Alternative m => Alternative (IdT m) where-  empty = IdT empty-  IdT c <|> IdT d = IdT (c <|> d)+    empty = IdT empty+    IdT c <|> IdT d = IdT (c <|> d)  instance Applicative m => Applicative (IdT m) where-  pure = IdT . pure-  IdT cf <*> IdT cx = IdT $ cf <*> cx+    pure = IdT . pure+    IdT cf <*> IdT cx = IdT $ cf <*> cx  instance Functor m => Functor (IdT m) where-  fmap f (IdT c) = IdT (fmap f c)+    fmap f (IdT c) = IdT (fmap f c)  instance Monad m => Monad (IdT m) where-  return = IdT . return-  IdT c >>= f = IdT $ c >>= getIdT . f+    return = IdT . return+    IdT c >>= f = IdT $ c >>= getIdT . f  instance (Alternative m, Monad m) => MonadPlus (IdT m) where-  mzero = empty-  mplus = (<|>)+    mzero = empty+    mplus = (<|>)  instance MonadFix m => MonadFix (IdT m) where-  mfix f = IdT $ mfix (getIdT . f)+    mfix f = IdT $ mfix (getIdT . f)  instance Runnable IdT r m r where-  type Argument IdT r m r = ()-  runT _ (IdT c) = c+    type Argument IdT r m r = ()+    runT _ (IdT c) = c  instance Transformer IdT where-  lift = IdT+    lift = IdT   ------------@@ -461,59 +463,59 @@ -- continuation with no argument.  newtype MaybeT r m a =-  MaybeT { getMaybeT :: (a -> m r) -> m r -> m r }+    MaybeT { getMaybeT :: (a -> m r) -> m r -> m r }  instance Applicative m => Abortable (MaybeT r m) where-  type Result (MaybeT r m) = r-  abort x = MaybeT $ \_ _ -> pure x+    type Result (MaybeT r m) = r+    abort x = MaybeT $ \_ _ -> pure x  instance Applicative (MaybeT r m) where-  pure x = MaybeT $ \just _ -> just x-  MaybeT cf <*> MaybeT cx =-    MaybeT $ \just noth -> cf (\f -> cx (\x -> just (f x)) noth) noth+    pure x = MaybeT $ \just _ -> just x+    MaybeT cf <*> MaybeT cx =+        MaybeT $ \just noth -> cf (\f -> cx (\x -> just (f x)) noth) noth  instance Alternative (MaybeT r m) where-  empty = MaybeT $ \_ noth -> noth-  MaybeT c <|> MaybeT d =-    MaybeT $ \just noth ->-      c (\x -> just x) (d (\x -> just x) noth)+    empty = MaybeT $ \_ noth -> noth+    MaybeT c <|> MaybeT d =+        MaybeT $ \just noth ->+            c (\x -> just x) (d (\x -> just x) noth)  instance CallCC (MaybeT r m) where-  callCC f =-    MaybeT $ \just noth ->-      getMaybeT (f (\x -> MaybeT $ \_ _ -> just x)) just noth+    callCC f =+        MaybeT $ \just noth ->+            getMaybeT (f (\x -> MaybeT $ \_ _ -> just x)) just noth  instance HasExceptions (MaybeT r m) where-  type Exception (MaybeT r m) = ()-  raise _ = MaybeT $ const id-  try (MaybeT c) = MaybeT $ \just _ -> c (just . Right) (just $ Left ())+    type Exception (MaybeT r m) = ()+    raise _ = MaybeT $ const id+    try (MaybeT c) = MaybeT $ \just _ -> c (just . Right) (just $ Left ())  instance Functor (MaybeT r m) where-  fmap f (MaybeT c) =-    MaybeT $ \just noth -> c (just . f) noth+    fmap f (MaybeT c) =+        MaybeT $ \just noth -> c (just . f) noth  instance Monad (MaybeT r m) where-  return x = MaybeT $ \just _ -> just x-  MaybeT c >>= f =-    MaybeT $ \just noth ->-      c (\x -> getMaybeT (f x) just noth) noth+    return x = MaybeT $ \just _ -> just x+    MaybeT c >>= f =+        MaybeT $ \just noth ->+            c (\x -> getMaybeT (f x) just noth) noth  instance Alternative m => MonadPlus (MaybeT r m) where-  mzero = empty-  mplus = (<|>)+    mzero = empty+    mplus = (<|>)  instance Runnable (MaybeT r) r m a where-  type Argument (MaybeT r) r m a = (a -> m r, m r)-  runT (just, noth) (MaybeT c) = c just noth+    type Argument (MaybeT r) r m a = (a -> m r, m r)+    runT (just, noth) (MaybeT c) = c just noth  instance Transformer (MaybeT r) where-  lift c = MaybeT $ \just _ -> c >>= just+    lift c = MaybeT $ \just _ -> c >>= just  instance Alternative m => Writable (MaybeT r m) r where-  tell x = MaybeT $ \just _ -> pure x <|> just ()+    tell x = MaybeT $ \just _ -> pure x <|> just ()  instance (Functor m, Monoid w) => Writable (MaybeT (r, w) m) w where-  tell x = MaybeT $ \just _ -> fmap (second (`mappend` x)) (just ())+    tell x = MaybeT $ \just _ -> fmap (second (`mappend` x)) (just ())   -- | Run a 'MaybeT' transformer.@@ -591,58 +593,58 @@ -- | Monad transformer for stateful computations.  newtype StateT r s m a =-  StateT { getStateT :: s -> (s -> a -> m r) -> m r }+    StateT { getStateT :: s -> (s -> a -> m r) -> m r }  instance Applicative m => Abortable (StateT r s m) where-  type Result (StateT r s m) = r-  abort x = StateT $ \_ _ -> pure x+    type Result (StateT r s m) = r+    abort x = StateT $ \_ _ -> pure x  instance Alternative m => Alternative (StateT r s m) where-  empty = StateT . const . const $ empty-  StateT c <|> StateT d =-    StateT $ \s0 k -> c s0 k <|> d s0 k+    empty = StateT . const . const $ empty+    StateT c <|> StateT d =+        StateT $ \s0 k -> c s0 k <|> d s0 k  instance Applicative (StateT r s m) where-  pure = return-  StateT cf <*> StateT cx =-    StateT $ \s0 k -> cf s0 (\s1 f -> cx s1 (\s2 x -> k s2 (f x)))+    pure = return+    StateT cf <*> StateT cx =+        StateT $ \s0 k -> cf s0 (\s1 f -> cx s1 (\s2 x -> k s2 (f x)))  instance CallCC (StateT r s m) where-  callCC f =-    StateT $ \s0 k ->-      getStateT (f (\x -> StateT $ \s1 _ -> k s1 x)) s0 k+    callCC f =+        StateT $ \s0 k ->+            getStateT (f (\x -> StateT $ \s1 _ -> k s1 x)) s0 k  instance Functor (StateT r s m) where-  fmap f (StateT c) =-    StateT $ \s0 k -> c s0 (\s1 -> k s1 . f)+    fmap f (StateT c) =+        StateT $ \s0 k -> c s0 (\s1 -> k s1 . f)  instance Monad (StateT r s m) where-  return x = StateT $ \s0 k -> k s0 x-  StateT c >>= f =-    StateT $ \s0 k -> c s0 (\s1 x -> getStateT (f x) s1 k)+    return x = StateT $ \s0 k -> k s0 x+    StateT c >>= f =+        StateT $ \s0 k -> c s0 (\s1 x -> getStateT (f x) s1 k)  instance Alternative m => MonadPlus (StateT r s m) where-  mzero = empty-  mplus = (<|>)+    mzero = empty+    mplus = (<|>)  instance Runnable (StateT r s) r m a where-  type Argument (StateT r s) r m a = (s, s -> a -> m r)-  runT (s0, k) (StateT c) = c s0 k+    type Argument (StateT r s) r m a = (s, s -> a -> m r)+    runT (s0, k) (StateT c) = c s0 k  instance Stateful (StateT r s m) where-  type StateOf (StateT r s m) = s-  get = StateT $ \s0 k -> k s0 s0-  put s1 = s1 `seq` StateT $ \_ k -> k s1 ()-  putLazy s1 = StateT $ \_ k -> k s1 ()+    type StateOf (StateT r s m) = s+    get = StateT $ \s0 k -> k s0 s0+    put s1 = s1 `seq` StateT $ \_ k -> k s1 ()+    putLazy s1 = StateT $ \_ k -> k s1 ()  instance Transformer (StateT r s) where-  lift c = StateT $ \s0 k -> c >>= k s0+    lift c = StateT $ \s0 k -> c >>= k s0  instance Alternative m => Writable (StateT r s m) r where-  tell x = StateT $ \s0 k -> pure x <|> k s0 ()+    tell x = StateT $ \s0 k -> pure x <|> k s0 ()  instance (Functor m, Monoid w) => Writable (StateT (r, w) s m) w where-  tell x = StateT $ \s0 k -> fmap (second (`mappend` x)) (k s0 ())+    tell x = StateT $ \s0 k -> fmap (second (`mappend` x)) (k s0 ())   -- | Run a state transformer.@@ -709,18 +711,18 @@ -- | Monads supporting abortion.  class Abortable m where-  -- | End result of the computation.-  type Result m+    -- | End result of the computation.+    type Result m -  -- | Ignore current continuation and abort.-  abort :: Result m -> m a+    -- | Ignore current continuation and abort.+    abort :: Result m -> m a   -- | Monads supporting *call-with-current-continuation* (aka callCC).  class CallCC m where-  -- | Call with current continuation.-  callCC :: ((a -> m b) -> m a) -> m a+    -- | Call with current continuation.+    callCC :: ((a -> m b) -> m a) -> m a   newtype Label m a = Label (a -> Label m a -> m ())@@ -741,48 +743,29 @@ -- | Monads with exception support.  class HasExceptions m where-  -- | The exception type.-  type Exception m+    -- | The exception type.+    type Exception m -  -- | Raise an exception.-  raise :: Exception m -> m a+    -- | Raise an exception.+    raise :: Exception m -> m a -  -- | Run computation catching exceptions.-  try :: m a -> m (Either (Exception m) a)+    -- | Run computation catching exceptions.+    try :: m a -> m (Either (Exception m) a)  instance HasExceptions (Either e) where-  type Exception (Either e) = e-  raise = Left-  try = Right+    type Exception (Either e) = e+    raise = Left+    try = Right  instance HasExceptions Maybe where-  type Exception Maybe = ()-  raise = const Nothing-  try = Just . maybe (Left ()) Right+    type Exception Maybe = ()+    raise = const Nothing+    try = Just . maybe (Left ()) Right  instance HasExceptions IO where-  type Exception IO = E.SomeException-  raise = E.throwIO-  try = E.try----- | Catch exceptions using an exception handler.--catch :: (HasExceptions m, Monad m) => m a -> (Exception m -> m a) -> m a-catch c h = try c >>= either h return----- | Catch exceptions using an exception handler (flip 'catch').--handle :: (HasExceptions m, Monad m) => (Exception m -> m a) -> m a -> m a-handle h c = try c >>= either h return----- | Run a final computation regardless of whether an exception was--- raised.--finally :: (HasExceptions m, Monad m) => m a -> m b -> m a-finally c d = try c >>= either (\exp -> d >> raise exp) (\x -> d >> return x)+    type Exception IO = E.SomeException+    raise = E.throwIO+    try = E.try   -- | Get a resource, run a computation, then release the resource, even@@ -796,10 +779,10 @@  bracket :: (HasExceptions m, Monad m) => m res -> (res -> m b) -> (res -> m a) -> m a bracket acquire release use = do-  resource <- acquire-  result <- try (use resource)-  try (release resource)-  either raise return result+    resource <- acquire+    result <- try (use resource)+    try (release resource)+    either raise return result   -- | Initialize, then run, then clean up safely, even if an exception is@@ -813,20 +796,73 @@  bracket_ :: (HasExceptions m, Monad m) => m a -> m b -> m c -> m c bracket_ init cleanup run = do-  init-  result <- try run-  try cleanup-  either raise return result+    init+    result <- try run+    try cleanup+    either raise return result  +-- | Catch exceptions using an exception handler.++catch :: (HasExceptions m, Monad m) => m a -> (Exception m -> m a) -> m a+catch c h = try c >>= either h return+++-- | Run a final computation regardless of whether an exception was+-- raised.++finally :: (HasExceptions m, Monad m) => m a -> m b -> m a+finally c d = try c >>= either (\exp -> d >> raise exp) (\x -> d >> return x)+++-- | Fail (in the sense of the given transformer), if the given+-- underlying computation returns 'True'.++forbid ::+    ( Exception (t m) ~ (), HasExceptions (t m),+      Monad m, Monad (t m), Transformer t ) =>+    m Bool -> t m ()+forbid = raiseWhen () . lift+++-- | Catch exceptions using an exception handler (flip 'catch').++handle :: (HasExceptions m, Monad m) => (Exception m -> m a) -> m a -> m a+handle h c = try c >>= either h return+++-- | Throw given exception, if the given computation does not return+-- 'True'.++raiseUnless :: (HasExceptions m, Monad m) => Exception m -> m Bool -> m ()+raiseUnless ex c = do b <- c; unless b (raise ex)+++-- | Throw given exception, if the given computation does not return+-- 'True'.++raiseWhen :: (HasExceptions m, Monad m) => Exception m -> m Bool -> m ()+raiseWhen ex c = do b <- c; unless b (raise ex)+++-- | Fail (in the sense of the given transformer), if the given+-- underlying computation returns 'False'.++require ::+    ( Exception (t m) ~ (), HasExceptions (t m),+      Monad m, Monad (t m), Transformer t ) =>+    m Bool -> t m ()+require = raiseUnless () . lift++ -- | Monads, which support lifting base monad computations.  class LiftBase m where-  -- | Base monad of @m@.-  type Base m :: * -> *+    -- | Base monad of @m@.+    type Base m :: * -> * -  -- | Promote a base monad computation.-  base :: Base m a -> m a+    -- | Promote a base monad computation.+    base :: Base m a -> m a   instance LiftBase IO where type Base IO = IO; base = id@@ -837,17 +873,17 @@ instance LiftBase ((->) r) where type Base ((->) r) = (->) r; base = id  instance (LiftBase m, Monad m) => LiftBase (IdT m) where-  type Base (IdT m) = Base m; base = lift . base+    type Base (IdT m) = Base m; base = lift . base instance (LiftBase m, Monad m) => LiftBase (ChoiceT r i m) where-  type Base (ChoiceT r i m) = Base m; base = lift . base+    type Base (ChoiceT r i m) = Base m; base = lift . base instance (LiftBase m, Monad m) => LiftBase (ContT r m) where-  type Base (ContT r m) = Base m; base = lift . base+    type Base (ContT r m) = Base m; base = lift . base instance (LiftBase m, Monad m) => LiftBase (EitherT r e m) where-  type Base (EitherT r e m) = Base m; base = lift . base+    type Base (EitherT r e m) = Base m; base = lift . base instance (LiftBase m, Monad m) => LiftBase (MaybeT r m) where-  type Base (MaybeT r m) = Base m; base = lift . base+    type Base (MaybeT r m) = Base m; base = lift . base instance (LiftBase m, Monad m) => LiftBase (StateT r s m) where-  type Base (StateT r s m) = Base m; base = lift . base+    type Base (StateT r s m) = Base m; base = lift . base   -- | Handy alias for lifting 'IO' computations.@@ -860,11 +896,11 @@ -- @m a@ can be an instance of this class.  class Runnable t r m a where-  -- | Arguments needed to run.-  type Argument t r m a+    -- | Arguments needed to run.+    type Argument t r m a -  -- | Run the transformer.-  runT :: Argument t r m a -> t m a -> m r+    -- | Run the transformer.+    runT :: Argument t r m a -> t m a -> m r   -- | Stateful monads.@@ -872,30 +908,30 @@ -- Minimal complete definition: 'StateOf', 'get' and 'putLazy'.  class Stateful m where-  -- | State type of @m@.-  type StateOf m+    -- | State type of @m@.+    type StateOf m -  -- | Get the current state.-  get :: m (StateOf m)+    -- | Get the current state.+    get :: m (StateOf m) -  -- | Set the current state and force it.-  put :: StateOf m -> m ()-  put x = x `seq` putLazy x+    -- | Set the current state and force it.+    put :: StateOf m -> m ()+    put x = x `seq` putLazy x -  -- | Set the current state, but don't force it.-  putLazy :: StateOf m -> m ()+    -- | Set the current state, but don't force it.+    putLazy :: StateOf m -> m ()  instance (Monad m, Stateful m) => Stateful (ContT r m) where-  type StateOf (ContT r m) = StateOf m-  get = lift get-  put = lift . put-  putLazy = lift . putLazy+    type StateOf (ContT r m) = StateOf m+    get = lift get+    put = lift . put+    putLazy = lift . putLazy  instance (Monad m, Stateful m) => Stateful (EitherT r e m) where-  type StateOf (EitherT r e m) = StateOf m-  get = lift get-  put = lift . put-  putLazy = lift . putLazy+    type StateOf (EitherT r e m) = StateOf m+    get = lift get+    put = lift . put+    putLazy = lift . putLazy   -- | Get a certain field.@@ -935,12 +971,13 @@ -- underlying monad to the transformer.  class Transformer t where-  -- | Promote a monadic computation to the transformer.-  lift :: Monad m => m a -> t m a+    -- | Promote a monadic computation to the transformer.+    lift :: Monad m => m a -> t m a   -- | Monads with support for logging.  Traditionally these are called -- *writer monads*.  class Writable m w where-  tell :: w -> m ()+    -- | Log a value.+    tell :: w -> m ()

@@ -1,7 +1,7 @@ Name:          contstuff-Version:       0.5.1-Category:      Control, Monads-Synopsis:      Easy to use CPS-based monads+Version:       0.6.0+Category:      Control, Monads, Parsing, Text+Synopsis:      Fast, easy to use CPS-based monads Maintainer:    Ertugrul Söylemez <es@ertes.de> Author:        Ertugrul Söylemez <es@ertes.de> Copyright:     (c) 2010 Ertugrul Söylemez@@ -12,8 +12,10 @@ Stability:     experimental Cabal-version: >= 1.6 Description:-  This library implements easy to use CPS-based monads. +  This library implements fast and easy to use CPS-based monad+  transformers.  Most of the usual monads are implemented.+ Library   Build-depends:     base >= 4 && <= 5@@ -24,6 +26,7 @@     TypeFamilies   Exposed-modules:     Control.ContStuff+--    Text.ContParser  --Executable test --  Build-depends: