transformers 0.6.2.0 → 0.6.3.0
raw patch · 4 files changed
+28/−1 lines, 4 filesPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
API changes (from Hackage documentation)
+ Control.Monad.Trans.Except: onE :: forall (m :: Type -> Type) e a b. Monad m => ExceptT e m a -> ExceptT e m b -> ExceptT e m a
+ Control.Monad.Trans.State.Lazy: lazyToStrictStateT :: forall s (m :: Type -> Type) a. StateT s m a -> StateT s m a
+ Control.Monad.Trans.State.Lazy: strictToLazyStateT :: forall s (m :: Type -> Type) a. StateT s m a -> StateT s m a
- Control.Applicative.Backwards: Backwards :: f a -> Backwards f a
+ Control.Applicative.Backwards: Backwards :: f a -> Backwards (f :: k -> Type) (a :: k)
- Control.Applicative.Backwards: [forwards] :: Backwards f a -> f a
+ Control.Applicative.Backwards: [forwards] :: Backwards (f :: k -> Type) (a :: k) -> f a
- Control.Applicative.Backwards: newtype Backwards f a
+ Control.Applicative.Backwards: newtype Backwards (f :: k -> Type) (a :: k)
- Control.Applicative.Lift: Other :: f a -> Lift f a
+ Control.Applicative.Lift: Other :: f a -> Lift (f :: Type -> Type) a
- Control.Applicative.Lift: Pure :: a -> Lift f a
+ Control.Applicative.Lift: Pure :: a -> Lift (f :: Type -> Type) a
- Control.Applicative.Lift: data Lift f a
+ Control.Applicative.Lift: data Lift (f :: Type -> Type) a
- Control.Applicative.Lift: type Errors e = Lift (Constant e)
+ Control.Applicative.Lift: type Errors e = Lift Constant e :: Type -> Type
- Control.Monad.Signatures: type CallCC m a b = ((a -> m b) -> m a) -> m a
+ Control.Monad.Signatures: type CallCC (m :: Type -> Type) a b = a -> m b -> m a -> m a
- Control.Monad.Signatures: type Catch e m a = m a -> (e -> m a) -> m a
+ Control.Monad.Signatures: type Catch e (m :: k -> Type) (a :: k) = m a -> e -> m a -> m a
- Control.Monad.Signatures: type Listen w m a = m a -> m (a, w)
+ Control.Monad.Signatures: type Listen w (m :: Type -> Type) a = m a -> m (a, w)
- Control.Monad.Signatures: type Pass w m a = m (a, w -> w) -> m a
+ Control.Monad.Signatures: type Pass w (m :: Type -> Type) a = m (a, w -> w) -> m a
- Control.Monad.Trans.Accum: AccumT :: (w -> m (a, w)) -> AccumT w m a
+ Control.Monad.Trans.Accum: AccumT :: (w -> m (a, w)) -> AccumT w (m :: Type -> Type) a
- Control.Monad.Trans.Accum: [runAccumT] :: AccumT w m a -> w -> m (a, w)
+ Control.Monad.Trans.Accum: [runAccumT] :: AccumT w (m :: Type -> Type) a -> w -> m (a, w)
- Control.Monad.Trans.Accum: accum :: Monad m => (w -> (a, w)) -> AccumT w m a
+ Control.Monad.Trans.Accum: accum :: forall (m :: Type -> Type) w a. Monad m => (w -> (a, w)) -> AccumT w m a
- Control.Monad.Trans.Accum: accumToStateT :: (Functor m, Monoid s) => AccumT s m a -> StateT s m a
+ Control.Monad.Trans.Accum: accumToStateT :: forall (m :: Type -> Type) s a. (Functor m, Monoid s) => AccumT s m a -> StateT s m a
- Control.Monad.Trans.Accum: add :: Monad m => w -> AccumT w m ()
+ Control.Monad.Trans.Accum: add :: forall (m :: Type -> Type) w. Monad m => w -> AccumT w m ()
- Control.Monad.Trans.Accum: look :: (Monoid w, Monad m) => AccumT w m w
+ Control.Monad.Trans.Accum: look :: forall w (m :: Type -> Type). (Monoid w, Monad m) => AccumT w m w
- Control.Monad.Trans.Accum: looks :: (Monoid w, Monad m) => (w -> a) -> AccumT w m a
+ Control.Monad.Trans.Accum: looks :: forall w (m :: Type -> Type) a. (Monoid w, Monad m) => (w -> a) -> AccumT w m a
- Control.Monad.Trans.Accum: newtype AccumT w m a
+ Control.Monad.Trans.Accum: newtype AccumT w (m :: Type -> Type) a
- Control.Monad.Trans.Accum: readerToAccumT :: (Functor m, Monoid w) => ReaderT w m a -> AccumT w m a
+ Control.Monad.Trans.Accum: readerToAccumT :: forall (m :: Type -> Type) w a. (Functor m, Monoid w) => ReaderT w m a -> AccumT w m a
- Control.Monad.Trans.Accum: writerToAccumT :: WriterT w m a -> AccumT w m a
+ Control.Monad.Trans.Accum: writerToAccumT :: forall w (m :: Type -> Type) a. WriterT w m a -> AccumT w m a
- Control.Monad.Trans.Class: class (forall m. Monad m => Monad (t m)) => MonadTrans t
+ Control.Monad.Trans.Class: class forall (m :: Type -> Type). Monad m => Monad t m => MonadTrans (t :: Type -> Type -> Type -> Type)
- Control.Monad.Trans.Cont: ContT :: ((a -> m r) -> m r) -> ContT r m a
+ Control.Monad.Trans.Cont: ContT :: ((a -> m r) -> m r) -> ContT (r :: k) (m :: k -> Type) a
- Control.Monad.Trans.Cont: [runContT] :: ContT r m a -> (a -> m r) -> m r
+ Control.Monad.Trans.Cont: [runContT] :: ContT (r :: k) (m :: k -> Type) a -> (a -> m r) -> m r
- Control.Monad.Trans.Cont: callCC :: ((a -> ContT r m b) -> ContT r m a) -> ContT r m a
+ Control.Monad.Trans.Cont: callCC :: forall {k} a (r :: k) (m :: k -> Type) b. ((a -> ContT r m b) -> ContT r m a) -> ContT r m a
- Control.Monad.Trans.Cont: mapContT :: (m r -> m r) -> ContT r m a -> ContT r m a
+ Control.Monad.Trans.Cont: mapContT :: forall {k} m (r :: k) a. (m r -> m r) -> ContT r m a -> ContT r m a
- Control.Monad.Trans.Cont: newtype ContT r m a
+ Control.Monad.Trans.Cont: newtype ContT (r :: k) (m :: k -> Type) a
- Control.Monad.Trans.Cont: resetT :: Monad m => ContT r m r -> ContT r' m r
+ Control.Monad.Trans.Cont: resetT :: forall (m :: Type -> Type) r r'. Monad m => ContT r m r -> ContT r' m r
- Control.Monad.Trans.Cont: withContT :: ((b -> m r) -> a -> m r) -> ContT r m a -> ContT r m b
+ Control.Monad.Trans.Cont: withContT :: forall {k} b m (r :: k) a. ((b -> m r) -> a -> m r) -> ContT r m a -> ContT r m b
- Control.Monad.Trans.Except: ExceptT :: m (Either e a) -> ExceptT e m a
+ Control.Monad.Trans.Except: ExceptT :: m (Either e a) -> ExceptT e (m :: Type -> Type) a
- Control.Monad.Trans.Except: [runExceptT] :: ExceptT e m a -> m (Either e a)
+ Control.Monad.Trans.Except: [runExceptT] :: ExceptT e (m :: Type -> Type) a -> m (Either e a)
- Control.Monad.Trans.Except: catchE :: Monad m => ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a
+ Control.Monad.Trans.Except: catchE :: forall (m :: Type -> Type) e a e'. Monad m => ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a
- Control.Monad.Trans.Except: except :: Monad m => Either e a -> ExceptT e m a
+ Control.Monad.Trans.Except: except :: forall (m :: Type -> Type) e a. Monad m => Either e a -> ExceptT e m a
- Control.Monad.Trans.Except: finallyE :: Monad m => ExceptT e m a -> ExceptT e m () -> ExceptT e m a
+ Control.Monad.Trans.Except: finallyE :: forall (m :: Type -> Type) e a. Monad m => ExceptT e m a -> ExceptT e m () -> ExceptT e m a
- Control.Monad.Trans.Except: handleE :: Monad m => (e -> ExceptT e' m a) -> ExceptT e m a -> ExceptT e' m a
+ Control.Monad.Trans.Except: handleE :: forall (m :: Type -> Type) e e' a. Monad m => (e -> ExceptT e' m a) -> ExceptT e m a -> ExceptT e' m a
- Control.Monad.Trans.Except: newtype ExceptT e m a
+ Control.Monad.Trans.Except: newtype ExceptT e (m :: Type -> Type) a
- Control.Monad.Trans.Except: throwE :: Monad m => e -> ExceptT e m a
+ Control.Monad.Trans.Except: throwE :: forall (m :: Type -> Type) e a. Monad m => e -> ExceptT e m a
- Control.Monad.Trans.Except: tryE :: Monad m => ExceptT e m a -> ExceptT e m (Either e a)
+ Control.Monad.Trans.Except: tryE :: forall (m :: Type -> Type) e a. Monad m => ExceptT e m a -> ExceptT e m (Either e a)
- Control.Monad.Trans.Except: withExceptT :: Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a
+ Control.Monad.Trans.Except: withExceptT :: forall (m :: Type -> Type) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a
- Control.Monad.Trans.Identity: IdentityT :: f a -> IdentityT f a
+ Control.Monad.Trans.Identity: IdentityT :: f a -> IdentityT (f :: k -> Type) (a :: k)
- Control.Monad.Trans.Identity: [runIdentityT] :: IdentityT f a -> f a
+ Control.Monad.Trans.Identity: [runIdentityT] :: IdentityT (f :: k -> Type) (a :: k) -> f a
- Control.Monad.Trans.Identity: liftCatch :: Catch e m a -> Catch e (IdentityT m) a
+ Control.Monad.Trans.Identity: liftCatch :: forall {k} e m (a :: k). Catch e m a -> Catch e (IdentityT m) a
- Control.Monad.Trans.Identity: mapIdentityT :: (m a -> n b) -> IdentityT m a -> IdentityT n b
+ Control.Monad.Trans.Identity: mapIdentityT :: forall {k1} {k2} m (a :: k1) n (b :: k2). (m a -> n b) -> IdentityT m a -> IdentityT n b
- Control.Monad.Trans.Identity: newtype IdentityT f a
+ Control.Monad.Trans.Identity: newtype IdentityT (f :: k -> Type) (a :: k)
- Control.Monad.Trans.Maybe: MaybeT :: m (Maybe a) -> MaybeT m a
+ Control.Monad.Trans.Maybe: MaybeT :: m (Maybe a) -> MaybeT (m :: Type -> Type) a
- Control.Monad.Trans.Maybe: [runMaybeT] :: MaybeT m a -> m (Maybe a)
+ Control.Monad.Trans.Maybe: [runMaybeT] :: MaybeT (m :: Type -> Type) a -> m (Maybe a)
- Control.Monad.Trans.Maybe: exceptToMaybeT :: Functor m => ExceptT e m a -> MaybeT m a
+ Control.Monad.Trans.Maybe: exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a
- Control.Monad.Trans.Maybe: hoistMaybe :: Applicative m => Maybe b -> MaybeT m b
+ Control.Monad.Trans.Maybe: hoistMaybe :: forall (m :: Type -> Type) b. Applicative m => Maybe b -> MaybeT m b
- Control.Monad.Trans.Maybe: maybeToExceptT :: Functor m => e -> MaybeT m a -> ExceptT e m a
+ Control.Monad.Trans.Maybe: maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a
- Control.Monad.Trans.Maybe: newtype MaybeT m a
+ Control.Monad.Trans.Maybe: newtype MaybeT (m :: Type -> Type) a
- Control.Monad.Trans.RWS.CPS: ask :: Monad m => RWST r w s m r
+ Control.Monad.Trans.RWS.CPS: ask :: forall (m :: Type -> Type) r w s. Monad m => RWST r w s m r
- Control.Monad.Trans.RWS.CPS: asks :: Monad m => (r -> a) -> RWST r w s m a
+ Control.Monad.Trans.RWS.CPS: asks :: forall (m :: Type -> Type) r a w s. Monad m => (r -> a) -> RWST r w s m a
- Control.Monad.Trans.RWS.CPS: censor :: (Monoid w, Monad m) => (w -> w) -> RWST r w s m a -> RWST r w s m a
+ Control.Monad.Trans.RWS.CPS: censor :: forall w (m :: Type -> Type) r s a. (Monoid w, Monad m) => (w -> w) -> RWST r w s m a -> RWST r w s m a
- Control.Monad.Trans.RWS.CPS: data RWST r w s m a
+ Control.Monad.Trans.RWS.CPS: data RWST r w s (m :: Type -> Type) a
- Control.Monad.Trans.RWS.CPS: get :: Monad m => RWST r w s m s
+ Control.Monad.Trans.RWS.CPS: get :: forall (m :: Type -> Type) r w s. Monad m => RWST r w s m s
- Control.Monad.Trans.RWS.CPS: gets :: Monad m => (s -> a) -> RWST r w s m a
+ Control.Monad.Trans.RWS.CPS: gets :: forall (m :: Type -> Type) s a r w. Monad m => (s -> a) -> RWST r w s m a
- Control.Monad.Trans.RWS.CPS: listen :: (Monoid w, Monad m) => RWST r w s m a -> RWST r w s m (a, w)
+ Control.Monad.Trans.RWS.CPS: listen :: forall w (m :: Type -> Type) r s a. (Monoid w, Monad m) => RWST r w s m a -> RWST r w s m (a, w)
- Control.Monad.Trans.RWS.CPS: listens :: (Monoid w, Monad m) => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b)
+ Control.Monad.Trans.RWS.CPS: listens :: forall w (m :: Type -> Type) b r s a. (Monoid w, Monad m) => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b)
- Control.Monad.Trans.RWS.CPS: local :: (r -> r) -> RWST r w s m a -> RWST r w s m a
+ Control.Monad.Trans.RWS.CPS: local :: forall r w s (m :: Type -> Type) a. (r -> r) -> RWST r w s m a -> RWST r w s m a
- Control.Monad.Trans.RWS.CPS: modify :: Monad m => (s -> s) -> RWST r w s m ()
+ Control.Monad.Trans.RWS.CPS: modify :: forall (m :: Type -> Type) s r w. Monad m => (s -> s) -> RWST r w s m ()
- Control.Monad.Trans.RWS.CPS: pass :: (Monoid w, Monoid w', Monad m) => RWST r w s m (a, w -> w') -> RWST r w' s m a
+ Control.Monad.Trans.RWS.CPS: pass :: forall w w' (m :: Type -> Type) r s a. (Monoid w, Monoid w', Monad m) => RWST r w s m (a, w -> w') -> RWST r w' s m a
- Control.Monad.Trans.RWS.CPS: put :: Monad m => s -> RWST r w s m ()
+ Control.Monad.Trans.RWS.CPS: put :: forall (m :: Type -> Type) s r w. Monad m => s -> RWST r w s m ()
- Control.Monad.Trans.RWS.CPS: reader :: Monad m => (r -> a) -> RWST r w s m a
+ Control.Monad.Trans.RWS.CPS: reader :: forall (m :: Type -> Type) r a w s. Monad m => (r -> a) -> RWST r w s m a
- Control.Monad.Trans.RWS.CPS: state :: Monad m => (s -> (a, s)) -> RWST r w s m a
+ Control.Monad.Trans.RWS.CPS: state :: forall (m :: Type -> Type) s a r w. Monad m => (s -> (a, s)) -> RWST r w s m a
- Control.Monad.Trans.RWS.CPS: tell :: (Monoid w, Monad m) => w -> RWST r w s m ()
+ Control.Monad.Trans.RWS.CPS: tell :: forall w (m :: Type -> Type) r s. (Monoid w, Monad m) => w -> RWST r w s m ()
- Control.Monad.Trans.RWS.CPS: withRWST :: (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a
+ Control.Monad.Trans.RWS.CPS: withRWST :: forall r' s r w (m :: Type -> Type) a. (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a
- Control.Monad.Trans.RWS.CPS: writer :: (Monoid w, Monad m) => (a, w) -> RWST r w s m a
+ Control.Monad.Trans.RWS.CPS: writer :: forall w (m :: Type -> Type) a r s. (Monoid w, Monad m) => (a, w) -> RWST r w s m a
- Control.Monad.Trans.RWS.Lazy: RWST :: (r -> s -> m (a, s, w)) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Lazy: RWST :: (r -> s -> m (a, s, w)) -> RWST r w s (m :: Type -> Type) a
- Control.Monad.Trans.RWS.Lazy: [runRWST] :: RWST r w s m a -> r -> s -> m (a, s, w)
+ Control.Monad.Trans.RWS.Lazy: [runRWST] :: RWST r w s (m :: Type -> Type) a -> r -> s -> m (a, s, w)
- Control.Monad.Trans.RWS.Lazy: ask :: (Monoid w, Monad m) => RWST r w s m r
+ Control.Monad.Trans.RWS.Lazy: ask :: forall w (m :: Type -> Type) r s. (Monoid w, Monad m) => RWST r w s m r
- Control.Monad.Trans.RWS.Lazy: asks :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Lazy: asks :: forall w (m :: Type -> Type) r a s. (Monoid w, Monad m) => (r -> a) -> RWST r w s m a
- Control.Monad.Trans.RWS.Lazy: censor :: Monad m => (w -> w) -> RWST r w s m a -> RWST r w s m a
+ Control.Monad.Trans.RWS.Lazy: censor :: forall (m :: Type -> Type) w r s a. Monad m => (w -> w) -> RWST r w s m a -> RWST r w s m a
- Control.Monad.Trans.RWS.Lazy: get :: (Monoid w, Monad m) => RWST r w s m s
+ Control.Monad.Trans.RWS.Lazy: get :: forall w (m :: Type -> Type) r s. (Monoid w, Monad m) => RWST r w s m s
- Control.Monad.Trans.RWS.Lazy: gets :: (Monoid w, Monad m) => (s -> a) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Lazy: gets :: forall w (m :: Type -> Type) s a r. (Monoid w, Monad m) => (s -> a) -> RWST r w s m a
- Control.Monad.Trans.RWS.Lazy: listen :: Monad m => RWST r w s m a -> RWST r w s m (a, w)
+ Control.Monad.Trans.RWS.Lazy: listen :: forall (m :: Type -> Type) r w s a. Monad m => RWST r w s m a -> RWST r w s m (a, w)
- Control.Monad.Trans.RWS.Lazy: listens :: Monad m => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b)
+ Control.Monad.Trans.RWS.Lazy: listens :: forall (m :: Type -> Type) w b r s a. Monad m => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b)
- Control.Monad.Trans.RWS.Lazy: local :: (r -> r) -> RWST r w s m a -> RWST r w s m a
+ Control.Monad.Trans.RWS.Lazy: local :: forall r w s (m :: Type -> Type) a. (r -> r) -> RWST r w s m a -> RWST r w s m a
- Control.Monad.Trans.RWS.Lazy: modify :: (Monoid w, Monad m) => (s -> s) -> RWST r w s m ()
+ Control.Monad.Trans.RWS.Lazy: modify :: forall w (m :: Type -> Type) s r. (Monoid w, Monad m) => (s -> s) -> RWST r w s m ()
- Control.Monad.Trans.RWS.Lazy: newtype RWST r w s m a
+ Control.Monad.Trans.RWS.Lazy: newtype RWST r w s (m :: Type -> Type) a
- Control.Monad.Trans.RWS.Lazy: pass :: Monad m => RWST r w s m (a, w -> w) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Lazy: pass :: forall (m :: Type -> Type) r w s a. Monad m => RWST r w s m (a, w -> w) -> RWST r w s m a
- Control.Monad.Trans.RWS.Lazy: put :: (Monoid w, Monad m) => s -> RWST r w s m ()
+ Control.Monad.Trans.RWS.Lazy: put :: forall w (m :: Type -> Type) s r. (Monoid w, Monad m) => s -> RWST r w s m ()
- Control.Monad.Trans.RWS.Lazy: reader :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Lazy: reader :: forall w (m :: Type -> Type) r a s. (Monoid w, Monad m) => (r -> a) -> RWST r w s m a
- Control.Monad.Trans.RWS.Lazy: state :: (Monoid w, Monad m) => (s -> (a, s)) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Lazy: state :: forall w (m :: Type -> Type) s a r. (Monoid w, Monad m) => (s -> (a, s)) -> RWST r w s m a
- Control.Monad.Trans.RWS.Lazy: tell :: Monad m => w -> RWST r w s m ()
+ Control.Monad.Trans.RWS.Lazy: tell :: forall (m :: Type -> Type) w r s. Monad m => w -> RWST r w s m ()
- Control.Monad.Trans.RWS.Lazy: withRWST :: (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a
+ Control.Monad.Trans.RWS.Lazy: withRWST :: forall r' s r w (m :: Type -> Type) a. (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a
- Control.Monad.Trans.RWS.Lazy: writer :: Monad m => (a, w) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Lazy: writer :: forall (m :: Type -> Type) a w r s. Monad m => (a, w) -> RWST r w s m a
- Control.Monad.Trans.RWS.Strict: RWST :: (r -> s -> m (a, s, w)) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Strict: RWST :: (r -> s -> m (a, s, w)) -> RWST r w s (m :: Type -> Type) a
- Control.Monad.Trans.RWS.Strict: [runRWST] :: RWST r w s m a -> r -> s -> m (a, s, w)
+ Control.Monad.Trans.RWS.Strict: [runRWST] :: RWST r w s (m :: Type -> Type) a -> r -> s -> m (a, s, w)
- Control.Monad.Trans.RWS.Strict: ask :: (Monoid w, Monad m) => RWST r w s m r
+ Control.Monad.Trans.RWS.Strict: ask :: forall w (m :: Type -> Type) r s. (Monoid w, Monad m) => RWST r w s m r
- Control.Monad.Trans.RWS.Strict: asks :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Strict: asks :: forall w (m :: Type -> Type) r a s. (Monoid w, Monad m) => (r -> a) -> RWST r w s m a
- Control.Monad.Trans.RWS.Strict: censor :: Monad m => (w -> w) -> RWST r w s m a -> RWST r w s m a
+ Control.Monad.Trans.RWS.Strict: censor :: forall (m :: Type -> Type) w r s a. Monad m => (w -> w) -> RWST r w s m a -> RWST r w s m a
- Control.Monad.Trans.RWS.Strict: get :: (Monoid w, Monad m) => RWST r w s m s
+ Control.Monad.Trans.RWS.Strict: get :: forall w (m :: Type -> Type) r s. (Monoid w, Monad m) => RWST r w s m s
- Control.Monad.Trans.RWS.Strict: gets :: (Monoid w, Monad m) => (s -> a) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Strict: gets :: forall w (m :: Type -> Type) s a r. (Monoid w, Monad m) => (s -> a) -> RWST r w s m a
- Control.Monad.Trans.RWS.Strict: listen :: Monad m => RWST r w s m a -> RWST r w s m (a, w)
+ Control.Monad.Trans.RWS.Strict: listen :: forall (m :: Type -> Type) r w s a. Monad m => RWST r w s m a -> RWST r w s m (a, w)
- Control.Monad.Trans.RWS.Strict: listens :: Monad m => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b)
+ Control.Monad.Trans.RWS.Strict: listens :: forall (m :: Type -> Type) w b r s a. Monad m => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b)
- Control.Monad.Trans.RWS.Strict: local :: (r -> r) -> RWST r w s m a -> RWST r w s m a
+ Control.Monad.Trans.RWS.Strict: local :: forall r w s (m :: Type -> Type) a. (r -> r) -> RWST r w s m a -> RWST r w s m a
- Control.Monad.Trans.RWS.Strict: modify :: (Monoid w, Monad m) => (s -> s) -> RWST r w s m ()
+ Control.Monad.Trans.RWS.Strict: modify :: forall w (m :: Type -> Type) s r. (Monoid w, Monad m) => (s -> s) -> RWST r w s m ()
- Control.Monad.Trans.RWS.Strict: newtype RWST r w s m a
+ Control.Monad.Trans.RWS.Strict: newtype RWST r w s (m :: Type -> Type) a
- Control.Monad.Trans.RWS.Strict: pass :: Monad m => RWST r w s m (a, w -> w) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Strict: pass :: forall (m :: Type -> Type) r w s a. Monad m => RWST r w s m (a, w -> w) -> RWST r w s m a
- Control.Monad.Trans.RWS.Strict: put :: (Monoid w, Monad m) => s -> RWST r w s m ()
+ Control.Monad.Trans.RWS.Strict: put :: forall w (m :: Type -> Type) s r. (Monoid w, Monad m) => s -> RWST r w s m ()
- Control.Monad.Trans.RWS.Strict: reader :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Strict: reader :: forall w (m :: Type -> Type) r a s. (Monoid w, Monad m) => (r -> a) -> RWST r w s m a
- Control.Monad.Trans.RWS.Strict: state :: (Monoid w, Monad m) => (s -> (a, s)) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Strict: state :: forall w (m :: Type -> Type) s a r. (Monoid w, Monad m) => (s -> (a, s)) -> RWST r w s m a
- Control.Monad.Trans.RWS.Strict: tell :: Monad m => w -> RWST r w s m ()
+ Control.Monad.Trans.RWS.Strict: tell :: forall (m :: Type -> Type) w r s. Monad m => w -> RWST r w s m ()
- Control.Monad.Trans.RWS.Strict: withRWST :: (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a
+ Control.Monad.Trans.RWS.Strict: withRWST :: forall r' s r w (m :: Type -> Type) a. (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a
- Control.Monad.Trans.RWS.Strict: writer :: Monad m => (a, w) -> RWST r w s m a
+ Control.Monad.Trans.RWS.Strict: writer :: forall (m :: Type -> Type) a w r s. Monad m => (a, w) -> RWST r w s m a
- Control.Monad.Trans.Reader: ReaderT :: (r -> m a) -> ReaderT r m a
+ Control.Monad.Trans.Reader: ReaderT :: (r -> m a) -> ReaderT r (m :: Type -> Type) a
- Control.Monad.Trans.Reader: [runReaderT] :: ReaderT r m a -> r -> m a
+ Control.Monad.Trans.Reader: [runReaderT] :: ReaderT r (m :: Type -> Type) a -> r -> m a
- Control.Monad.Trans.Reader: ask :: Monad m => ReaderT r m r
+ Control.Monad.Trans.Reader: ask :: forall (m :: Type -> Type) r. Monad m => ReaderT r m r
- Control.Monad.Trans.Reader: asks :: Monad m => (r -> a) -> ReaderT r m a
+ Control.Monad.Trans.Reader: asks :: forall (m :: Type -> Type) r a. Monad m => (r -> a) -> ReaderT r m a
- Control.Monad.Trans.Reader: local :: (r -> r) -> ReaderT r m a -> ReaderT r m a
+ Control.Monad.Trans.Reader: local :: forall r (m :: Type -> Type) a. (r -> r) -> ReaderT r m a -> ReaderT r m a
- Control.Monad.Trans.Reader: newtype ReaderT r m a
+ Control.Monad.Trans.Reader: newtype ReaderT r (m :: Type -> Type) a
- Control.Monad.Trans.Reader: reader :: Monad m => (r -> a) -> ReaderT r m a
+ Control.Monad.Trans.Reader: reader :: forall (m :: Type -> Type) r a. Monad m => (r -> a) -> ReaderT r m a
- Control.Monad.Trans.Reader: withReaderT :: (r' -> r) -> ReaderT r m a -> ReaderT r' m a
+ Control.Monad.Trans.Reader: withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a
- Control.Monad.Trans.Select: SelectT :: ((a -> m r) -> m a) -> SelectT r m a
+ Control.Monad.Trans.Select: SelectT :: ((a -> m r) -> m a) -> SelectT r (m :: Type -> Type) a
- Control.Monad.Trans.Select: [runSelectT] :: SelectT r m a -> (a -> m r) -> m a
+ Control.Monad.Trans.Select: [runSelectT] :: SelectT r (m :: Type -> Type) a -> (a -> m r) -> m a
- Control.Monad.Trans.Select: newtype SelectT r m a
+ Control.Monad.Trans.Select: newtype SelectT r (m :: Type -> Type) a
- Control.Monad.Trans.Select: selectToContT :: Monad m => SelectT r m a -> ContT r m a
+ Control.Monad.Trans.Select: selectToContT :: forall (m :: Type -> Type) r a. Monad m => SelectT r m a -> ContT r m a
- Control.Monad.Trans.State.Lazy: StateT :: (s -> m (a, s)) -> StateT s m a
+ Control.Monad.Trans.State.Lazy: StateT :: (s -> m (a, s)) -> StateT s (m :: Type -> Type) a
- Control.Monad.Trans.State.Lazy: [runStateT] :: StateT s m a -> s -> m (a, s)
+ Control.Monad.Trans.State.Lazy: [runStateT] :: StateT s (m :: Type -> Type) a -> s -> m (a, s)
- Control.Monad.Trans.State.Lazy: get :: Monad m => StateT s m s
+ Control.Monad.Trans.State.Lazy: get :: forall (m :: Type -> Type) s. Monad m => StateT s m s
- Control.Monad.Trans.State.Lazy: gets :: Monad m => (s -> a) -> StateT s m a
+ Control.Monad.Trans.State.Lazy: gets :: forall (m :: Type -> Type) s a. Monad m => (s -> a) -> StateT s m a
- Control.Monad.Trans.State.Lazy: modify :: Monad m => (s -> s) -> StateT s m ()
+ Control.Monad.Trans.State.Lazy: modify :: forall (m :: Type -> Type) s. Monad m => (s -> s) -> StateT s m ()
- Control.Monad.Trans.State.Lazy: modify' :: Monad m => (s -> s) -> StateT s m ()
+ Control.Monad.Trans.State.Lazy: modify' :: forall (m :: Type -> Type) s. Monad m => (s -> s) -> StateT s m ()
- Control.Monad.Trans.State.Lazy: newtype StateT s m a
+ Control.Monad.Trans.State.Lazy: newtype StateT s (m :: Type -> Type) a
- Control.Monad.Trans.State.Lazy: put :: Monad m => s -> StateT s m ()
+ Control.Monad.Trans.State.Lazy: put :: forall (m :: Type -> Type) s. Monad m => s -> StateT s m ()
- Control.Monad.Trans.State.Lazy: state :: Monad m => (s -> (a, s)) -> StateT s m a
+ Control.Monad.Trans.State.Lazy: state :: forall (m :: Type -> Type) s a. Monad m => (s -> (a, s)) -> StateT s m a
- Control.Monad.Trans.State.Lazy: withStateT :: (s -> s) -> StateT s m a -> StateT s m a
+ Control.Monad.Trans.State.Lazy: withStateT :: forall s (m :: Type -> Type) a. (s -> s) -> StateT s m a -> StateT s m a
- Control.Monad.Trans.State.Strict: StateT :: (s -> m (a, s)) -> StateT s m a
+ Control.Monad.Trans.State.Strict: StateT :: (s -> m (a, s)) -> StateT s (m :: Type -> Type) a
- Control.Monad.Trans.State.Strict: [runStateT] :: StateT s m a -> s -> m (a, s)
+ Control.Monad.Trans.State.Strict: [runStateT] :: StateT s (m :: Type -> Type) a -> s -> m (a, s)
- Control.Monad.Trans.State.Strict: get :: Monad m => StateT s m s
+ Control.Monad.Trans.State.Strict: get :: forall (m :: Type -> Type) s. Monad m => StateT s m s
- Control.Monad.Trans.State.Strict: gets :: Monad m => (s -> a) -> StateT s m a
+ Control.Monad.Trans.State.Strict: gets :: forall (m :: Type -> Type) s a. Monad m => (s -> a) -> StateT s m a
- Control.Monad.Trans.State.Strict: modify :: Monad m => (s -> s) -> StateT s m ()
+ Control.Monad.Trans.State.Strict: modify :: forall (m :: Type -> Type) s. Monad m => (s -> s) -> StateT s m ()
- Control.Monad.Trans.State.Strict: modify' :: Monad m => (s -> s) -> StateT s m ()
+ Control.Monad.Trans.State.Strict: modify' :: forall (m :: Type -> Type) s. Monad m => (s -> s) -> StateT s m ()
- Control.Monad.Trans.State.Strict: newtype StateT s m a
+ Control.Monad.Trans.State.Strict: newtype StateT s (m :: Type -> Type) a
- Control.Monad.Trans.State.Strict: put :: Monad m => s -> StateT s m ()
+ Control.Monad.Trans.State.Strict: put :: forall (m :: Type -> Type) s. Monad m => s -> StateT s m ()
- Control.Monad.Trans.State.Strict: state :: Monad m => (s -> (a, s)) -> StateT s m a
+ Control.Monad.Trans.State.Strict: state :: forall (m :: Type -> Type) s a. Monad m => (s -> (a, s)) -> StateT s m a
- Control.Monad.Trans.State.Strict: withStateT :: (s -> s) -> StateT s m a -> StateT s m a
+ Control.Monad.Trans.State.Strict: withStateT :: forall s (m :: Type -> Type) a. (s -> s) -> StateT s m a -> StateT s m a
- Control.Monad.Trans.Writer.CPS: censor :: (Monoid w, Monad m) => (w -> w) -> WriterT w m a -> WriterT w m a
+ Control.Monad.Trans.Writer.CPS: censor :: forall w (m :: Type -> Type) a. (Monoid w, Monad m) => (w -> w) -> WriterT w m a -> WriterT w m a
- Control.Monad.Trans.Writer.CPS: data WriterT w m a
+ Control.Monad.Trans.Writer.CPS: data WriterT w (m :: Type -> Type) a
- Control.Monad.Trans.Writer.CPS: listen :: (Monoid w, Monad m) => WriterT w m a -> WriterT w m (a, w)
+ Control.Monad.Trans.Writer.CPS: listen :: forall w (m :: Type -> Type) a. (Monoid w, Monad m) => WriterT w m a -> WriterT w m (a, w)
- Control.Monad.Trans.Writer.CPS: listens :: (Monoid w, Monad m) => (w -> b) -> WriterT w m a -> WriterT w m (a, b)
+ Control.Monad.Trans.Writer.CPS: listens :: forall w (m :: Type -> Type) b a. (Monoid w, Monad m) => (w -> b) -> WriterT w m a -> WriterT w m (a, b)
- Control.Monad.Trans.Writer.CPS: pass :: (Monoid w, Monoid w', Monad m) => WriterT w m (a, w -> w') -> WriterT w' m a
+ Control.Monad.Trans.Writer.CPS: pass :: forall w w' (m :: Type -> Type) a. (Monoid w, Monoid w', Monad m) => WriterT w m (a, w -> w') -> WriterT w' m a
- Control.Monad.Trans.Writer.CPS: tell :: (Monoid w, Monad m) => w -> WriterT w m ()
+ Control.Monad.Trans.Writer.CPS: tell :: forall w (m :: Type -> Type). (Monoid w, Monad m) => w -> WriterT w m ()
- Control.Monad.Trans.Writer.CPS: writer :: (Monoid w, Monad m) => (a, w) -> WriterT w m a
+ Control.Monad.Trans.Writer.CPS: writer :: forall w (m :: Type -> Type) a. (Monoid w, Monad m) => (a, w) -> WriterT w m a
- Control.Monad.Trans.Writer.Lazy: WriterT :: m (a, w) -> WriterT w m a
+ Control.Monad.Trans.Writer.Lazy: WriterT :: m (a, w) -> WriterT w (m :: Type -> Type) a
- Control.Monad.Trans.Writer.Lazy: [runWriterT] :: WriterT w m a -> m (a, w)
+ Control.Monad.Trans.Writer.Lazy: [runWriterT] :: WriterT w (m :: Type -> Type) a -> m (a, w)
- Control.Monad.Trans.Writer.Lazy: censor :: Monad m => (w -> w) -> WriterT w m a -> WriterT w m a
+ Control.Monad.Trans.Writer.Lazy: censor :: forall (m :: Type -> Type) w a. Monad m => (w -> w) -> WriterT w m a -> WriterT w m a
- Control.Monad.Trans.Writer.Lazy: listen :: Monad m => WriterT w m a -> WriterT w m (a, w)
+ Control.Monad.Trans.Writer.Lazy: listen :: forall (m :: Type -> Type) w a. Monad m => WriterT w m a -> WriterT w m (a, w)
- Control.Monad.Trans.Writer.Lazy: listens :: Monad m => (w -> b) -> WriterT w m a -> WriterT w m (a, b)
+ Control.Monad.Trans.Writer.Lazy: listens :: forall (m :: Type -> Type) w b a. Monad m => (w -> b) -> WriterT w m a -> WriterT w m (a, b)
- Control.Monad.Trans.Writer.Lazy: newtype WriterT w m a
+ Control.Monad.Trans.Writer.Lazy: newtype WriterT w (m :: Type -> Type) a
- Control.Monad.Trans.Writer.Lazy: pass :: Monad m => WriterT w m (a, w -> w) -> WriterT w m a
+ Control.Monad.Trans.Writer.Lazy: pass :: forall (m :: Type -> Type) w a. Monad m => WriterT w m (a, w -> w) -> WriterT w m a
- Control.Monad.Trans.Writer.Lazy: tell :: Monad m => w -> WriterT w m ()
+ Control.Monad.Trans.Writer.Lazy: tell :: forall (m :: Type -> Type) w. Monad m => w -> WriterT w m ()
- Control.Monad.Trans.Writer.Lazy: writer :: Monad m => (a, w) -> WriterT w m a
+ Control.Monad.Trans.Writer.Lazy: writer :: forall (m :: Type -> Type) a w. Monad m => (a, w) -> WriterT w m a
- Control.Monad.Trans.Writer.Strict: WriterT :: m (a, w) -> WriterT w m a
+ Control.Monad.Trans.Writer.Strict: WriterT :: m (a, w) -> WriterT w (m :: Type -> Type) a
- Control.Monad.Trans.Writer.Strict: [runWriterT] :: WriterT w m a -> m (a, w)
+ Control.Monad.Trans.Writer.Strict: [runWriterT] :: WriterT w (m :: Type -> Type) a -> m (a, w)
- Control.Monad.Trans.Writer.Strict: censor :: Monad m => (w -> w) -> WriterT w m a -> WriterT w m a
+ Control.Monad.Trans.Writer.Strict: censor :: forall (m :: Type -> Type) w a. Monad m => (w -> w) -> WriterT w m a -> WriterT w m a
- Control.Monad.Trans.Writer.Strict: listen :: Monad m => WriterT w m a -> WriterT w m (a, w)
+ Control.Monad.Trans.Writer.Strict: listen :: forall (m :: Type -> Type) w a. Monad m => WriterT w m a -> WriterT w m (a, w)
- Control.Monad.Trans.Writer.Strict: listens :: Monad m => (w -> b) -> WriterT w m a -> WriterT w m (a, b)
+ Control.Monad.Trans.Writer.Strict: listens :: forall (m :: Type -> Type) w b a. Monad m => (w -> b) -> WriterT w m a -> WriterT w m (a, b)
- Control.Monad.Trans.Writer.Strict: newtype WriterT w m a
+ Control.Monad.Trans.Writer.Strict: newtype WriterT w (m :: Type -> Type) a
- Control.Monad.Trans.Writer.Strict: pass :: Monad m => WriterT w m (a, w -> w) -> WriterT w m a
+ Control.Monad.Trans.Writer.Strict: pass :: forall (m :: Type -> Type) w a. Monad m => WriterT w m (a, w -> w) -> WriterT w m a
- Control.Monad.Trans.Writer.Strict: tell :: Monad m => w -> WriterT w m ()
+ Control.Monad.Trans.Writer.Strict: tell :: forall (m :: Type -> Type) w. Monad m => w -> WriterT w m ()
- Control.Monad.Trans.Writer.Strict: writer :: Monad m => (a, w) -> WriterT w m a
+ Control.Monad.Trans.Writer.Strict: writer :: forall (m :: Type -> Type) a w. Monad m => (a, w) -> WriterT w m a
- Data.Functor.Constant: Constant :: a -> Constant a b
+ Data.Functor.Constant: Constant :: a -> Constant a (b :: k)
- Data.Functor.Constant: [getConstant] :: Constant a b -> a
+ Data.Functor.Constant: [getConstant] :: Constant a (b :: k) -> a
- Data.Functor.Constant: newtype Constant a b
+ Data.Functor.Constant: newtype Constant a (b :: k)
- Data.Functor.Reverse: Reverse :: f a -> Reverse f a
+ Data.Functor.Reverse: Reverse :: f a -> Reverse (f :: k -> Type) (a :: k)
- Data.Functor.Reverse: [getReverse] :: Reverse f a -> f a
+ Data.Functor.Reverse: [getReverse] :: Reverse (f :: k -> Type) (a :: k) -> f a
- Data.Functor.Reverse: newtype Reverse f a
+ Data.Functor.Reverse: newtype Reverse (f :: k -> Type) (a :: k)
Files
- Control/Monad/Trans/Except.hs +9/−0
- Control/Monad/Trans/State/Lazy.hs +14/−0
- changelog +4/−0
- transformers.cabal +1/−1
Control/Monad/Trans/Except.hs view
@@ -45,6 +45,7 @@ handleE, tryE, finallyE,+ onE, -- * Lifting other operations liftCallCC, liftListen,@@ -328,6 +329,14 @@ closer either throwE return res {-# INLINE finallyE #-}++-- | If the first action succeeds, return its value, ignoring the+-- second action. If the first action throws an exception, run the+-- second action and then throw an exception, either the one thrown by+-- the second action, if any, or the one thrown by the first action.+onE :: (Monad m) => ExceptT e m a -> ExceptT e m b -> ExceptT e m a+onE action1 action2 = action1 `catchE` \ e -> action2 >> throwE e+{-# INLINE onE #-} -- | Lift a @callCC@ operation to the new monad. liftCallCC :: CallCC m (Either e a) (Either e b) -> CallCC (ExceptT e m) a b
Control/Monad/Trans/State/Lazy.hs view
@@ -64,6 +64,9 @@ liftCatch, liftListen, liftPass,+ -- * Conversion to and from the strict version+ strictToLazyStateT,+ lazyToStrictStateT, -- * Examples -- ** State monads -- $examples@@ -78,6 +81,7 @@ import Control.Monad.IO.Class import Control.Monad.Signatures import Control.Monad.Trans.Class+import qualified Control.Monad.Trans.State.Strict as Strict #if MIN_VERSION_base(4,12,0) import Data.Functor.Contravariant #endif@@ -357,6 +361,16 @@ ~((a, f), s') <- runStateT m s return ((a, s'), f) {-# INLINE liftPass #-}++-- | Convert from the strict version to the lazy version+strictToLazyStateT :: Strict.StateT s m a -> StateT s m a+strictToLazyStateT (Strict.StateT f) = StateT f+{-# INLINE strictToLazyStateT #-}++-- | Convert from the lazy version to the strict version+lazyToStrictStateT :: StateT s m a -> Strict.StateT s m a+lazyToStrictStateT (StateT f) = Strict.StateT f+{-# INLINE lazyToStrictStateT #-} {- $examples
changelog view
@@ -1,5 +1,9 @@ -*-change-log-*- +0.6.3.0 Ross Paterson <R.Paterson@city.ac.uk> Jan 2026+ * Add Control.Monad.Trans.Except.onE+ * Add strictToLazyState and lazyToStrictStateT+ 0.6.2.0 Ross Paterson <R.Paterson@city.ac.uk> Apr 2025 * Redefine runAccumT, runExceptT and runSelectT as fields * Document strictness of some transformers
transformers.cabal view
@@ -1,5 +1,5 @@ name: transformers-version: 0.6.2.0+version: 0.6.3.0 license: BSD3 license-file: LICENSE author: Andy Gill, Ross Paterson