mtl-prelude 2.0.3.1 → 2.0.3.2

raw patch · 3 files changed

+4/−5 lines, 3 filesdep ~mtldep ~transformerssetup-changedPVP: minor bump suggested

API additions: PVP suggests at least a minor version bump

Dependency ranges changed: mtl, transformers

API changes (from Hackage documentation)

+ MTLPrelude: ContT :: ((a -> m r) -> m r) -> ContT (r :: k) (m :: k -> Type) a

+ MTLPrelude: ExceptT :: m (Either e a) -> ExceptT e (m :: Type -> Type) a

+ MTLPrelude: Identity :: a -> Identity a

+ MTLPrelude: MaybeT :: m (Maybe a) -> MaybeT (m :: Type -> Type) a

+ MTLPrelude: RWST :: (r -> s -> m (a, s, w)) -> RWST r w s (m :: Type -> Type) a

+ MTLPrelude: ReaderT :: (r -> m a) -> ReaderT r (m :: Type -> Type) a

+ MTLPrelude: StateT :: (s -> m (a, s)) -> StateT s (m :: Type -> Type) a

+ MTLPrelude: WriterT :: m (a, w) -> WriterT w (m :: Type -> Type) a

+ MTLPrelude: [runContT] :: ContT (r :: k) (m :: k -> Type) a -> (a -> m r) -> m r

+ MTLPrelude: [runIdentity] :: Identity a -> a

+ MTLPrelude: [runMaybeT] :: MaybeT (m :: Type -> Type) a -> m (Maybe a)

+ MTLPrelude: [runRWST] :: RWST r w s (m :: Type -> Type) a -> r -> s -> m (a, s, w)

+ MTLPrelude: [runReaderT] :: ReaderT r (m :: Type -> Type) a -> r -> m a

+ MTLPrelude: [runStateT] :: StateT s (m :: Type -> Type) a -> s -> m (a, s)

+ MTLPrelude: [runWriterT] :: WriterT w (m :: Type -> Type) a -> m (a, w)

+ MTLPrelude: ask :: MonadReader r m => m r

+ MTLPrelude: asks :: MonadReader r m => (r -> a) -> m a

+ MTLPrelude: callCC :: MonadCont m => ((a -> m b) -> m a) -> m a

+ MTLPrelude: catchError :: MonadError e m => m a -> (e -> m a) -> m a

+ MTLPrelude: censor :: MonadWriter w m => (w -> w) -> m a -> m a

+ MTLPrelude: class Error a

+ MTLPrelude: class Monad m => MonadCont (m :: Type -> Type)

+ MTLPrelude: class Monad m => MonadError e (m :: Type -> Type) | m -> e

+ MTLPrelude: class Monad m => MonadIO (m :: Type -> Type)

+ MTLPrelude: class (Monoid w, MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (m :: Type -> Type) | m -> r, m -> w, m -> s

+ MTLPrelude: class Monad m => MonadReader r (m :: Type -> Type) | m -> r

+ MTLPrelude: class Monad m => MonadState s (m :: Type -> Type) | m -> s

+ MTLPrelude: class MonadTrans (t :: Type -> Type -> Type -> Type)

+ MTLPrelude: class (Monoid w, Monad m) => MonadWriter w (m :: Type -> Type) | m -> w

+ MTLPrelude: cont :: ((a -> r) -> r) -> Cont r a

+ MTLPrelude: evalCont :: Cont r r -> r

+ MTLPrelude: evalContT :: Monad m => ContT r m r -> m r

+ MTLPrelude: evalRWS :: RWS r w s a -> r -> s -> (a, w)

+ MTLPrelude: evalRWST :: Monad m => RWST r w s m a -> r -> s -> m (a, w)

+ MTLPrelude: evalState :: State s a -> s -> a

+ MTLPrelude: evalStateT :: Monad m => StateT s m a -> s -> m a

+ MTLPrelude: except :: forall (m :: Type -> Type) e a. Monad m => Either e a -> ExceptT e m a

+ MTLPrelude: exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a

+ MTLPrelude: execRWS :: RWS r w s a -> r -> s -> (s, w)

+ MTLPrelude: execRWST :: Monad m => RWST r w s m a -> r -> s -> m (s, w)

+ MTLPrelude: execState :: State s a -> s -> s

+ MTLPrelude: execStateT :: Monad m => StateT s m a -> s -> m s

+ MTLPrelude: execWriter :: Writer w a -> w

+ MTLPrelude: execWriterT :: Monad m => WriterT w m a -> m w

+ MTLPrelude: get :: MonadState s m => m s

+ MTLPrelude: gets :: MonadState s m => (s -> a) -> m a

+ MTLPrelude: lift :: (MonadTrans t, Monad m) => m a -> t m a

+ MTLPrelude: liftCallCC :: CallCC m (Maybe a) (Maybe b) -> CallCC (MaybeT m) a b

+ MTLPrelude: liftCatch :: Catch e m (Maybe a) -> Catch e (MaybeT m) a

+ MTLPrelude: liftEither :: MonadError e m => Either e a -> m a

+ MTLPrelude: liftIO :: MonadIO m => IO a -> m a

+ MTLPrelude: liftListen :: Monad m => Listen w m (Maybe a) -> Listen w (MaybeT m) a

+ MTLPrelude: liftLocal :: Monad m => m r' -> ((r' -> r') -> m r -> m r) -> (r' -> r') -> ContT r m a -> ContT r m a

+ MTLPrelude: liftPass :: Monad m => Pass w m (Maybe a) -> Pass w (MaybeT m) a

+ MTLPrelude: listen :: MonadWriter w m => m a -> m (a, w)

+ MTLPrelude: listens :: MonadWriter w m => (w -> b) -> m a -> m (a, b)

+ MTLPrelude: local :: MonadReader r m => (r -> r) -> m a -> m a

+ MTLPrelude: mapCont :: (r -> r) -> Cont r a -> Cont r a

+ MTLPrelude: mapContT :: forall {k} m (r :: k) a. (m r -> m r) -> ContT r m a -> ContT r m a

+ MTLPrelude: mapExcept :: (Either e a -> Either e' b) -> Except e a -> Except e' b

+ MTLPrelude: mapExceptT :: (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b

+ MTLPrelude: mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b

+ MTLPrelude: mapRWS :: ((a, s, w) -> (b, s, w')) -> RWS r w s a -> RWS r w' s b

+ MTLPrelude: mapRWST :: (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b

+ MTLPrelude: mapReader :: (a -> b) -> Reader r a -> Reader r b

+ MTLPrelude: mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b

+ MTLPrelude: mapState :: ((a, s) -> (b, s)) -> State s a -> State s b

+ MTLPrelude: mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b

+ MTLPrelude: mapWriter :: ((a, w) -> (b, w')) -> Writer w a -> Writer w' b

+ MTLPrelude: mapWriterT :: (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b

+ MTLPrelude: maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a

+ MTLPrelude: modify :: MonadState s m => (s -> s) -> m ()

+ MTLPrelude: modify' :: MonadState s m => (s -> s) -> m ()

+ MTLPrelude: newtype ContT (r :: k) (m :: k -> Type) a

+ MTLPrelude: newtype ExceptT e (m :: Type -> Type) a

+ MTLPrelude: newtype Identity a

+ MTLPrelude: newtype MaybeT (m :: Type -> Type) a

+ MTLPrelude: newtype RWST r w s (m :: Type -> Type) a

+ MTLPrelude: newtype ReaderT r (m :: Type -> Type) a

+ MTLPrelude: newtype StateT s (m :: Type -> Type) a

+ MTLPrelude: newtype WriterT w (m :: Type -> Type) a

+ MTLPrelude: noMsg :: Error a => a

+ MTLPrelude: pass :: MonadWriter w m => m (a, w -> w) -> m a

+ MTLPrelude: put :: MonadState s m => s -> m ()

+ MTLPrelude: reader :: MonadReader r m => (r -> a) -> m a

+ MTLPrelude: reset :: Cont r r -> Cont r' r

+ MTLPrelude: resetT :: forall (m :: Type -> Type) r r'. Monad m => ContT r m r -> ContT r' m r

+ MTLPrelude: runCont :: Cont r a -> (a -> r) -> r

+ MTLPrelude: runExcept :: Except e a -> Either e a

+ MTLPrelude: runExceptT :: ExceptT e m a -> m (Either e a)

+ MTLPrelude: runRWS :: RWS r w s a -> r -> s -> (a, s, w)

+ MTLPrelude: runReader :: Reader r a -> r -> a

+ MTLPrelude: runState :: State s a -> s -> (a, s)

+ MTLPrelude: runWriter :: Writer w a -> (a, w)

+ MTLPrelude: rws :: (r -> s -> (a, s, w)) -> RWS r w s a

+ MTLPrelude: shift :: ((a -> r) -> Cont r r) -> Cont r a

+ MTLPrelude: shiftT :: Monad m => ((a -> m r) -> ContT r m r) -> ContT r m a

+ MTLPrelude: state :: MonadState s m => (s -> (a, s)) -> m a

+ MTLPrelude: strMsg :: Error a => String -> a

+ MTLPrelude: tell :: MonadWriter w m => w -> m ()

+ MTLPrelude: throwError :: MonadError e m => e -> m a

+ MTLPrelude: type Cont r = ContT r Identity

+ MTLPrelude: type Except e = ExceptT e Identity

+ MTLPrelude: type RWS r w s = RWST r w s Identity

+ MTLPrelude: type Reader r = ReaderT r Identity

+ MTLPrelude: type State s = StateT s Identity

+ MTLPrelude: type Writer w = WriterT w Identity

+ MTLPrelude: withCont :: ((b -> r) -> a -> r) -> Cont r a -> Cont r b

+ MTLPrelude: withContT :: forall {k} b m (r :: k) a. ((b -> m r) -> a -> m r) -> ContT r m a -> ContT r m b

+ MTLPrelude: withExcept :: (e -> e') -> Except e a -> Except e' a

+ MTLPrelude: withExceptT :: forall (m :: Type -> Type) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a

+ MTLPrelude: withRWS :: (r' -> s -> (r, s)) -> RWS r w s a -> RWS r' w s a

+ MTLPrelude: 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

+ MTLPrelude: withReader :: (r' -> r) -> Reader r a -> Reader r' a

+ MTLPrelude: withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a

+ MTLPrelude: withState :: (s -> s) -> State s a -> State s a

+ MTLPrelude: withStateT :: forall s (m :: Type -> Type) a. (s -> s) -> StateT s m a -> StateT s m a

+ MTLPrelude: writer :: MonadWriter w m => (a, w) -> m a

Files

Setup.hs +0/−2
library/MTLPrelude.hs +1/−0
mtl-prelude.cabal +3/−3

− Setup.hs

@@ -1,2 +0,0 @@-import Distribution.Simple-main = defaultMain

library/MTLPrelude.hs view

@@ -14,6 +14,7 @@  import Control.Monad.Cont.Class   as Exports+  hiding (liftCallCC)  import Control.Monad.Trans.Cont   as Exports

mtl-prelude.cabal view

@@ -1,7 +1,7 @@ name:   mtl-prelude version:-  2.0.3.1+  2.0.3.2 synopsis:   Reexports of most definitions from "mtl" and "transformers"  description:@@ -52,8 +52,8 @@   exposed-modules:     MTLPrelude   build-depends:-    transformers >= 0.4 && < 0.6,-    mtl == 2.2.*,+    transformers >= 0.4 && < 0.7,+    mtl >= 2.2 && < 2.4,     base < 5   default-extensions:     NoImplicitPrelude