packages feed

multistate 0.6.2.0 → 0.7.0.0

raw patch · 10 files changed

+463/−155 lines, 10 filesdep +monad-controldep +transformers-basedep ~basedep ~hspecdep ~mtlPVP ok

version bump matches the API change (PVP)

Dependencies added: monad-control, transformers-base

Dependency ranges changed: base, hspec, mtl, transformers

API changes (from Hackage documentation)

- Control.Monad.MultiReader: runMultiReaderTRaw :: MultiReaderT x m a -> StateT (HList x) m a
- Control.Monad.MultiState: runMultiStateTRaw :: MultiStateT x m a -> StateT (HList x) m a
- Control.Monad.MultiWriter: runMultiWriterTRaw :: MultiWriterT x m a -> StateT (HList x) m a
- Control.Monad.Trans.MultiRWS: runMultiRWSTRaw :: MultiRWST r w s m a -> StateT (HList r, HList w, HList s) m a
- Control.Monad.Trans.MultiRWS.Lazy: instance [overlap ok] (Applicative m, Monad m) => Applicative (MultiRWST r w s m)
- Control.Monad.Trans.MultiRWS.Lazy: instance [overlap ok] (Monad m, ContainsType a r) => MonadMultiReader a (MultiRWST r w s m)
- Control.Monad.Trans.MultiRWS.Lazy: instance [overlap ok] (Monad m, ContainsType a s) => MonadMultiState a (MultiRWST r w s m)
- Control.Monad.Trans.MultiRWS.Lazy: instance [overlap ok] (Monad m, ContainsType a w, Monoid a) => MonadMultiWriter a (MultiRWST r w s m)
- Control.Monad.Trans.MultiRWS.Lazy: instance [overlap ok] Functor f => Functor (MultiRWST r w s f)
- Control.Monad.Trans.MultiRWS.Lazy: instance [overlap ok] Monad m => Monad (MultiRWST r w s m)
- Control.Monad.Trans.MultiRWS.Lazy: instance [overlap ok] MonadFix m => MonadFix (MultiRWST r w s m)
- Control.Monad.Trans.MultiRWS.Lazy: instance [overlap ok] MonadTrans (MultiRWST r w s)
- Control.Monad.Trans.MultiRWS.Lazy: runMultiRWSTRaw :: MultiRWST r w s m a -> StateT (HList r, HList w, HList s) m a
- Control.Monad.Trans.MultiRWS.Strict: instance [overlap ok] (Applicative m, Monad m) => Applicative (MultiRWST r w s m)
- Control.Monad.Trans.MultiRWS.Strict: instance [overlap ok] (Monad m, ContainsType a r) => MonadMultiReader a (MultiRWST r w s m)
- Control.Monad.Trans.MultiRWS.Strict: instance [overlap ok] (Monad m, ContainsType a s) => MonadMultiState a (MultiRWST r w s m)
- Control.Monad.Trans.MultiRWS.Strict: instance [overlap ok] (Monad m, ContainsType a w, Monoid a) => MonadMultiWriter a (MultiRWST r w s m)
- Control.Monad.Trans.MultiRWS.Strict: instance [overlap ok] Functor f => Functor (MultiRWST r w s f)
- Control.Monad.Trans.MultiRWS.Strict: instance [overlap ok] Monad m => Monad (MultiRWST r w s m)
- Control.Monad.Trans.MultiRWS.Strict: instance [overlap ok] MonadFix m => MonadFix (MultiRWST r w s m)
- Control.Monad.Trans.MultiRWS.Strict: instance [overlap ok] MonadTrans (MultiRWST r w s)
- Control.Monad.Trans.MultiRWS.Strict: runMultiRWSTRaw :: MultiRWST r w s m a -> StateT (HList r, HList w, HList s) m a
- Control.Monad.Trans.MultiReader: runMultiReaderTRaw :: MultiReaderT x m a -> StateT (HList x) m a
- Control.Monad.Trans.MultiReader.Class: instance [overlap ok] (MonadTrans t, Monad (t m), MonadMultiReader a m) => MonadMultiReader a (t m)
- Control.Monad.Trans.MultiReader.Lazy: instance [overlap ok] (Applicative m, Monad m) => Applicative (MultiReaderT x m)
- Control.Monad.Trans.MultiReader.Lazy: instance [overlap ok] (Monad m, ContainsType a c) => MonadMultiReader a (MultiReaderT c m)
- Control.Monad.Trans.MultiReader.Lazy: instance [overlap ok] Functor f => Functor (MultiReaderT x f)
- Control.Monad.Trans.MultiReader.Lazy: instance [overlap ok] Monad m => Monad (MultiReaderT x m)
- Control.Monad.Trans.MultiReader.Lazy: instance [overlap ok] MonadFix m => MonadFix (MultiReaderT r m)
- Control.Monad.Trans.MultiReader.Lazy: instance [overlap ok] MonadState s m => MonadState s (MultiReaderT c m)
- Control.Monad.Trans.MultiReader.Lazy: instance [overlap ok] MonadTrans (MultiReaderT x)
- Control.Monad.Trans.MultiReader.Lazy: instance [overlap ok] MonadWriter w m => MonadWriter w (MultiReaderT c m)
- Control.Monad.Trans.MultiReader.Lazy: runMultiReaderTRaw :: MultiReaderT x m a -> StateT (HList x) m a
- Control.Monad.Trans.MultiReader.Strict: instance [overlap ok] (Applicative m, Monad m) => Applicative (MultiReaderT x m)
- Control.Monad.Trans.MultiReader.Strict: instance [overlap ok] (Monad m, ContainsType a c) => MonadMultiReader a (MultiReaderT c m)
- Control.Monad.Trans.MultiReader.Strict: instance [overlap ok] Functor f => Functor (MultiReaderT x f)
- Control.Monad.Trans.MultiReader.Strict: instance [overlap ok] Monad m => Monad (MultiReaderT x m)
- Control.Monad.Trans.MultiReader.Strict: instance [overlap ok] MonadFix m => MonadFix (MultiReaderT r m)
- Control.Monad.Trans.MultiReader.Strict: instance [overlap ok] MonadState s m => MonadState s (MultiReaderT c m)
- Control.Monad.Trans.MultiReader.Strict: instance [overlap ok] MonadTrans (MultiReaderT x)
- Control.Monad.Trans.MultiReader.Strict: instance [overlap ok] MonadWriter w m => MonadWriter w (MultiReaderT c m)
- Control.Monad.Trans.MultiReader.Strict: runMultiReaderTRaw :: MultiReaderT x m a -> StateT (HList x) m a
- Control.Monad.Trans.MultiState: runMultiStateTRaw :: MultiStateT x m a -> StateT (HList x) m a
- Control.Monad.Trans.MultiState.Class: instance [overlap ok] (MonadTrans t, Monad (t m), MonadMultiState a m) => MonadMultiState a (t m)
- Control.Monad.Trans.MultiState.Lazy: instance [overlap ok] (Applicative m, Monad m) => Applicative (MultiStateT x m)
- Control.Monad.Trans.MultiState.Lazy: instance [overlap ok] (Monad m, ContainsType a c) => MonadMultiState a (MultiStateT c m)
- Control.Monad.Trans.MultiState.Lazy: instance [overlap ok] Functor f => Functor (MultiStateT x f)
- Control.Monad.Trans.MultiState.Lazy: instance [overlap ok] Monad m => Monad (MultiStateT x m)
- Control.Monad.Trans.MultiState.Lazy: instance [overlap ok] MonadFix m => MonadFix (MultiStateT s m)
- Control.Monad.Trans.MultiState.Lazy: instance [overlap ok] MonadState s m => MonadState s (MultiStateT c m)
- Control.Monad.Trans.MultiState.Lazy: instance [overlap ok] MonadTrans (MultiStateT x)
- Control.Monad.Trans.MultiState.Lazy: instance [overlap ok] MonadWriter w m => MonadWriter w (MultiStateT c m)
- Control.Monad.Trans.MultiState.Lazy: runMultiStateTRaw :: MultiStateT x m a -> StateT (HList x) m a
- Control.Monad.Trans.MultiState.Strict: instance [overlap ok] (Applicative m, Monad m) => Applicative (MultiStateT x m)
- Control.Monad.Trans.MultiState.Strict: instance [overlap ok] (Monad m, ContainsType a c) => MonadMultiState a (MultiStateT c m)
- Control.Monad.Trans.MultiState.Strict: instance [overlap ok] Functor f => Functor (MultiStateT x f)
- Control.Monad.Trans.MultiState.Strict: instance [overlap ok] Monad m => Monad (MultiStateT x m)
- Control.Monad.Trans.MultiState.Strict: instance [overlap ok] MonadFix m => MonadFix (MultiStateT s m)
- Control.Monad.Trans.MultiState.Strict: instance [overlap ok] MonadState s m => MonadState s (MultiStateT c m)
- Control.Monad.Trans.MultiState.Strict: instance [overlap ok] MonadTrans (MultiStateT x)
- Control.Monad.Trans.MultiState.Strict: instance [overlap ok] MonadWriter w m => MonadWriter w (MultiStateT c m)
- Control.Monad.Trans.MultiState.Strict: runMultiStateTRaw :: MultiStateT x m a -> StateT (HList x) m a
- Control.Monad.Trans.MultiWriter: runMultiWriterTRaw :: MultiWriterT x m a -> StateT (HList x) m a
- Control.Monad.Trans.MultiWriter.Class: instance [overlap ok] (MonadTrans t, Monad (t m), MonadMultiWriter a m) => MonadMultiWriter a (t m)
- Control.Monad.Trans.MultiWriter.Lazy: instance [overlap ok] (Applicative m, Monad m) => Applicative (MultiWriterT x m)
- Control.Monad.Trans.MultiWriter.Lazy: instance [overlap ok] (Monad m, ContainsType a c, Monoid a) => MonadMultiWriter a (MultiWriterT c m)
- Control.Monad.Trans.MultiWriter.Lazy: instance [overlap ok] Functor f => Functor (MultiWriterT x f)
- Control.Monad.Trans.MultiWriter.Lazy: instance [overlap ok] Monad m => Monad (MultiWriterT x m)
- Control.Monad.Trans.MultiWriter.Lazy: instance [overlap ok] MonadFix m => MonadFix (MultiWriterT w m)
- Control.Monad.Trans.MultiWriter.Lazy: instance [overlap ok] MonadState s m => MonadState s (MultiWriterT c m)
- Control.Monad.Trans.MultiWriter.Lazy: instance [overlap ok] MonadTrans (MultiWriterT x)
- Control.Monad.Trans.MultiWriter.Lazy: instance [overlap ok] MonadWriter w m => MonadWriter w (MultiWriterT c m)
- Control.Monad.Trans.MultiWriter.Lazy: runMultiWriterTRaw :: MultiWriterT x m a -> StateT (HList x) m a
- Control.Monad.Trans.MultiWriter.Strict: instance [overlap ok] (Applicative m, Monad m) => Applicative (MultiWriterT x m)
- Control.Monad.Trans.MultiWriter.Strict: instance [overlap ok] (Monad m, ContainsType a c, Monoid a) => MonadMultiWriter a (MultiWriterT c m)
- Control.Monad.Trans.MultiWriter.Strict: instance [overlap ok] Functor f => Functor (MultiWriterT x f)
- Control.Monad.Trans.MultiWriter.Strict: instance [overlap ok] Monad m => Monad (MultiWriterT x m)
- Control.Monad.Trans.MultiWriter.Strict: instance [overlap ok] MonadFix m => MonadFix (MultiWriterT w m)
- Control.Monad.Trans.MultiWriter.Strict: instance [overlap ok] MonadState s m => MonadState s (MultiWriterT c m)
- Control.Monad.Trans.MultiWriter.Strict: instance [overlap ok] MonadTrans (MultiWriterT x)
- Control.Monad.Trans.MultiWriter.Strict: instance [overlap ok] MonadWriter w m => MonadWriter w (MultiWriterT c m)
- Control.Monad.Trans.MultiWriter.Strict: runMultiWriterTRaw :: MultiWriterT x m a -> StateT (HList x) m a
- Data.HList.ContainsType: instance [overlap ok] ContainsType a (a : xs)
- Data.HList.ContainsType: instance [overlap ok] ContainsType a xs => ContainsType a (x : xs)
- Data.HList.HList: instance [overlap ok] (Eq x, Eq (HList xs)) => Eq (HList (x : xs))
- Data.HList.HList: instance [overlap ok] (Monoid x, Monoid (HList xs)) => Monoid (HList (x : xs))
- Data.HList.HList: instance [overlap ok] (Show a, Show (HList b)) => Show (HList (a : b))
- Data.HList.HList: instance [overlap ok] Eq (HList '[])
- Data.HList.HList: instance [overlap ok] HInit '[]
- Data.HList.HList: instance [overlap ok] HInit l1 => HInit (x : l1)
- Data.HList.HList: instance [overlap ok] Monoid (HList '[])
- Data.HList.HList: instance [overlap ok] Show (HList '[])
+ Control.Monad.MultiReader: [runMultiReaderTRaw] :: MultiReaderT x m a -> StateT (HList x) m a
+ Control.Monad.MultiState: [runMultiStateTRaw] :: MultiStateT x m a -> StateT (HList x) m a
+ Control.Monad.MultiWriter: [runMultiWriterTRaw] :: MultiWriterT x m a -> StateT (HList x) m a
+ Control.Monad.Trans.MultiRWS: [runMultiRWSTRaw] :: MultiRWST r w s m a -> StateT (HList r, HList w, HList s) m a
+ Control.Monad.Trans.MultiRWS.Lazy: [runMultiRWSTRaw] :: MultiRWST r w s m a -> StateT (HList r, HList w, HList s) m a
+ Control.Monad.Trans.MultiRWS.Lazy: instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Lazy: instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Lazy: instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a r) => Control.Monad.Trans.MultiReader.Class.MonadMultiReader a (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Lazy: instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a s) => Control.Monad.Trans.MultiState.Class.MonadMultiState a (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Lazy: instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a w, GHC.Base.Monoid a) => Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Lazy: instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Lazy: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Lazy: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Lazy: instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s)
+ Control.Monad.Trans.MultiRWS.Lazy: instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Lazy: instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s)
+ Control.Monad.Trans.MultiRWS.Lazy: instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s f)
+ Control.Monad.Trans.MultiRWS.Lazy: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Lazy: instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Strict: [runMultiRWSTRaw] :: MultiRWST r w s m a -> StateT (HList r, HList w, HList s) m a
+ Control.Monad.Trans.MultiRWS.Strict: instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Strict: instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Strict: instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a r) => Control.Monad.Trans.MultiReader.Class.MonadMultiReader a (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Strict: instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a s) => Control.Monad.Trans.MultiState.Class.MonadMultiState a (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Strict: instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a w, GHC.Base.Monoid a) => Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Strict: instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Strict: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Strict: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Strict: instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s)
+ Control.Monad.Trans.MultiRWS.Strict: instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Strict: instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s)
+ Control.Monad.Trans.MultiRWS.Strict: instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s f)
+ Control.Monad.Trans.MultiRWS.Strict: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
+ Control.Monad.Trans.MultiRWS.Strict: instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
+ Control.Monad.Trans.MultiReader: [runMultiReaderTRaw] :: MultiReaderT x m a -> StateT (HList x) m a
+ Control.Monad.Trans.MultiReader.Class: instance (Control.Monad.Trans.Class.MonadTrans t, GHC.Base.Monad (t m), Control.Monad.Trans.MultiReader.Class.MonadMultiReader a m) => Control.Monad.Trans.MultiReader.Class.MonadMultiReader a (t m)
+ Control.Monad.Trans.MultiReader.Lazy: [runMultiReaderTRaw] :: MultiReaderT x m a -> StateT (HList x) m a
+ Control.Monad.Trans.MultiReader.Lazy: instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT x m)
+ Control.Monad.Trans.MultiReader.Lazy: instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
+ Control.Monad.Trans.MultiReader.Lazy: instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a c) => Control.Monad.Trans.MultiReader.Class.MonadMultiReader a (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
+ Control.Monad.Trans.MultiReader.Lazy: instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT r m)
+ Control.Monad.Trans.MultiReader.Lazy: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT r m)
+ Control.Monad.Trans.MultiReader.Lazy: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
+ Control.Monad.Trans.MultiReader.Lazy: instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
+ Control.Monad.Trans.MultiReader.Lazy: instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT x)
+ Control.Monad.Trans.MultiReader.Lazy: instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT r m)
+ Control.Monad.Trans.MultiReader.Lazy: instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT r)
+ Control.Monad.Trans.MultiReader.Lazy: instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
+ Control.Monad.Trans.MultiReader.Lazy: instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT x f)
+ Control.Monad.Trans.MultiReader.Lazy: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT x m)
+ Control.Monad.Trans.MultiReader.Lazy: instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
+ Control.Monad.Trans.MultiReader.Strict: [runMultiReaderTRaw] :: MultiReaderT x m a -> StateT (HList x) m a
+ Control.Monad.Trans.MultiReader.Strict: instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiReader.Strict.MultiReaderT x m)
+ Control.Monad.Trans.MultiReader.Strict: instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
+ Control.Monad.Trans.MultiReader.Strict: instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a c) => Control.Monad.Trans.MultiReader.Class.MonadMultiReader a (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
+ Control.Monad.Trans.MultiReader.Strict: instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiReader.Strict.MultiReaderT r m)
+ Control.Monad.Trans.MultiReader.Strict: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiReader.Strict.MultiReaderT r m)
+ Control.Monad.Trans.MultiReader.Strict: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
+ Control.Monad.Trans.MultiReader.Strict: instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
+ Control.Monad.Trans.MultiReader.Strict: instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiReader.Strict.MultiReaderT x)
+ Control.Monad.Trans.MultiReader.Strict: instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiReader.Strict.MultiReaderT r m)
+ Control.Monad.Trans.MultiReader.Strict: instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiReader.Strict.MultiReaderT r)
+ Control.Monad.Trans.MultiReader.Strict: instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
+ Control.Monad.Trans.MultiReader.Strict: instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiReader.Strict.MultiReaderT x f)
+ Control.Monad.Trans.MultiReader.Strict: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiReader.Strict.MultiReaderT x m)
+ Control.Monad.Trans.MultiReader.Strict: instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
+ Control.Monad.Trans.MultiState: [runMultiStateTRaw] :: MultiStateT x m a -> StateT (HList x) m a
+ Control.Monad.Trans.MultiState.Class: instance (Control.Monad.Trans.Class.MonadTrans t, GHC.Base.Monad (t m), Control.Monad.Trans.MultiState.Class.MonadMultiState a m) => Control.Monad.Trans.MultiState.Class.MonadMultiState a (t m)
+ Control.Monad.Trans.MultiState.Lazy: [runMultiStateTRaw] :: MultiStateT x m a -> StateT (HList x) m a
+ Control.Monad.Trans.MultiState.Lazy: instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiState.Lazy.MultiStateT x m)
+ Control.Monad.Trans.MultiState.Lazy: instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiState.Lazy.MultiStateT s m)
+ Control.Monad.Trans.MultiState.Lazy: instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a c) => Control.Monad.Trans.MultiState.Class.MonadMultiState a (Control.Monad.Trans.MultiState.Lazy.MultiStateT c m)
+ Control.Monad.Trans.MultiState.Lazy: instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiState.Lazy.MultiStateT s m)
+ Control.Monad.Trans.MultiState.Lazy: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiState.Lazy.MultiStateT s m)
+ Control.Monad.Trans.MultiState.Lazy: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiState.Lazy.MultiStateT c m)
+ Control.Monad.Trans.MultiState.Lazy: instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.MultiState.Lazy.MultiStateT c m)
+ Control.Monad.Trans.MultiState.Lazy: instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiState.Lazy.MultiStateT x)
+ Control.Monad.Trans.MultiState.Lazy: instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiState.Lazy.MultiStateT s m)
+ Control.Monad.Trans.MultiState.Lazy: instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiState.Lazy.MultiStateT s)
+ Control.Monad.Trans.MultiState.Lazy: instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiState.Lazy.MultiStateT c m)
+ Control.Monad.Trans.MultiState.Lazy: instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiState.Lazy.MultiStateT x f)
+ Control.Monad.Trans.MultiState.Lazy: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiState.Lazy.MultiStateT x m)
+ Control.Monad.Trans.MultiState.Lazy: instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiState.Lazy.MultiStateT s m)
+ Control.Monad.Trans.MultiState.Strict: [runMultiStateTRaw] :: MultiStateT x m a -> StateT (HList x) m a
+ Control.Monad.Trans.MultiState.Strict: instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiState.Strict.MultiStateT x m)
+ Control.Monad.Trans.MultiState.Strict: instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiState.Strict.MultiStateT s m)
+ Control.Monad.Trans.MultiState.Strict: instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a c) => Control.Monad.Trans.MultiState.Class.MonadMultiState a (Control.Monad.Trans.MultiState.Strict.MultiStateT c m)
+ Control.Monad.Trans.MultiState.Strict: instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiState.Strict.MultiStateT s m)
+ Control.Monad.Trans.MultiState.Strict: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiState.Strict.MultiStateT s m)
+ Control.Monad.Trans.MultiState.Strict: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiState.Strict.MultiStateT c m)
+ Control.Monad.Trans.MultiState.Strict: instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.MultiState.Strict.MultiStateT c m)
+ Control.Monad.Trans.MultiState.Strict: instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiState.Strict.MultiStateT x)
+ Control.Monad.Trans.MultiState.Strict: instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiState.Strict.MultiStateT s m)
+ Control.Monad.Trans.MultiState.Strict: instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiState.Strict.MultiStateT s)
+ Control.Monad.Trans.MultiState.Strict: instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiState.Strict.MultiStateT c m)
+ Control.Monad.Trans.MultiState.Strict: instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiState.Strict.MultiStateT x f)
+ Control.Monad.Trans.MultiState.Strict: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiState.Strict.MultiStateT x m)
+ Control.Monad.Trans.MultiState.Strict: instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiState.Strict.MultiStateT s m)
+ Control.Monad.Trans.MultiWriter: [runMultiWriterTRaw] :: MultiWriterT x m a -> StateT (HList x) m a
+ Control.Monad.Trans.MultiWriter.Class: instance (Control.Monad.Trans.Class.MonadTrans t, GHC.Base.Monad (t m), Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a m) => Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a (t m)
+ Control.Monad.Trans.MultiWriter.Lazy: [runMultiWriterTRaw] :: MultiWriterT x m a -> StateT (HList x) m a
+ Control.Monad.Trans.MultiWriter.Lazy: instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT x m)
+ Control.Monad.Trans.MultiWriter.Lazy: instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Lazy: instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a c, GHC.Base.Monoid a) => Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Lazy: instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Lazy: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT w m)
+ Control.Monad.Trans.MultiWriter.Lazy: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Lazy: instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Lazy: instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT x)
+ Control.Monad.Trans.MultiWriter.Lazy: instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Lazy: instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c)
+ Control.Monad.Trans.MultiWriter.Lazy: instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Lazy: instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT x f)
+ Control.Monad.Trans.MultiWriter.Lazy: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT x m)
+ Control.Monad.Trans.MultiWriter.Lazy: instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Strict: [runMultiWriterTRaw] :: MultiWriterT x m a -> StateT (HList x) m a
+ Control.Monad.Trans.MultiWriter.Strict: instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT x m)
+ Control.Monad.Trans.MultiWriter.Strict: instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Strict: instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a c, GHC.Base.Monoid a) => Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Strict: instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Strict: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT w m)
+ Control.Monad.Trans.MultiWriter.Strict: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Strict: instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Strict: instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT x)
+ Control.Monad.Trans.MultiWriter.Strict: instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Strict: instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c)
+ Control.Monad.Trans.MultiWriter.Strict: instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
+ Control.Monad.Trans.MultiWriter.Strict: instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT x f)
+ Control.Monad.Trans.MultiWriter.Strict: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT x m)
+ Control.Monad.Trans.MultiWriter.Strict: instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
+ Data.HList.ContainsType: instance Data.HList.ContainsType.ContainsType a (a : xs)
+ Data.HList.ContainsType: instance Data.HList.ContainsType.ContainsType a xs => Data.HList.ContainsType.ContainsType a (x : xs)
+ Data.HList.HList: instance (GHC.Base.Monoid x, GHC.Base.Monoid (Data.HList.HList.HList xs)) => GHC.Base.Monoid (Data.HList.HList.HList (x : xs))
+ Data.HList.HList: instance (GHC.Classes.Eq x, GHC.Classes.Eq (Data.HList.HList.HList xs)) => GHC.Classes.Eq (Data.HList.HList.HList (x : xs))
+ Data.HList.HList: instance (GHC.Show.Show a, GHC.Show.Show (Data.HList.HList.HList b)) => GHC.Show.Show (Data.HList.HList.HList (a : b))
+ Data.HList.HList: instance Data.HList.HList.HInit '[]
+ Data.HList.HList: instance Data.HList.HList.HInit l1 => Data.HList.HList.HInit (x : l1)
+ Data.HList.HList: instance GHC.Base.Monoid (Data.HList.HList.HList '[])
+ Data.HList.HList: instance GHC.Classes.Eq (Data.HList.HList.HList '[])
+ Data.HList.HList: instance GHC.Show.Show (Data.HList.HList.HList '[])
- Control.Monad.MultiReader: class Monad m => MonadMultiReader a m
+ Control.Monad.MultiReader: class (Monad m) => MonadMultiReader a m
- Control.Monad.MultiReader: runMultiReaderTNil :: Monad m => MultiReaderT [] m a -> m a
+ Control.Monad.MultiReader: runMultiReaderTNil :: Monad m => MultiReaderT '[] m a -> m a
- Control.Monad.MultiReader: runMultiReaderTNil_ :: Functor m => MultiReaderT [] m a -> m ()
+ Control.Monad.MultiReader: runMultiReaderTNil_ :: Functor m => MultiReaderT '[] m a -> m ()
- Control.Monad.MultiReader: type MultiReaderTNull = MultiReaderT []
+ Control.Monad.MultiReader: type MultiReaderTNull = MultiReaderT '[]
- Control.Monad.MultiState: class Monad m => MonadMultiState a m
+ Control.Monad.MultiState: class (Monad m) => MonadMultiState a m
- Control.Monad.MultiState: runMultiStateTNil :: Monad m => MultiStateT [] m a -> m a
+ Control.Monad.MultiState: runMultiStateTNil :: Monad m => MultiStateT '[] m a -> m a
- Control.Monad.MultiState: runMultiStateTNil_ :: Functor m => MultiStateT [] m a -> m ()
+ Control.Monad.MultiState: runMultiStateTNil_ :: Functor m => MultiStateT '[] m a -> m ()
- Control.Monad.MultiState: type MultiStateTNull = MultiStateT []
+ Control.Monad.MultiState: type MultiStateTNull = MultiStateT '[]
- Control.Monad.MultiWriter: runMultiWriterTNil :: Monad m => MultiWriterT [] m a -> m a
+ Control.Monad.MultiWriter: runMultiWriterTNil :: Monad m => MultiWriterT '[] m a -> m a
- Control.Monad.MultiWriter: runMultiWriterTNil_ :: Functor m => MultiWriterT [] m a -> m ()
+ Control.Monad.MultiWriter: runMultiWriterTNil_ :: Functor m => MultiWriterT '[] m a -> m ()
- Control.Monad.MultiWriter: type MultiWriterTNull = MultiWriterT []
+ Control.Monad.MultiWriter: type MultiWriterTNull = MultiWriterT '[]
- Control.Monad.Trans.MultiRWS: class Monad m => MonadMultiReader a m
+ Control.Monad.Trans.MultiRWS: class (Monad m) => MonadMultiReader a m
- Control.Monad.Trans.MultiRWS: class Monad m => MonadMultiState a m
+ Control.Monad.Trans.MultiRWS: class (Monad m) => MonadMultiState a m
- Control.Monad.Trans.MultiRWS: mapMultiRWST :: ss ~ (HList r, HList w, HList s) => (m (a, ss) -> m' (a', ss)) -> MultiRWST r w s m a -> MultiRWST r w s m' a'
+ Control.Monad.Trans.MultiRWS: mapMultiRWST :: (ss ~ (HList r, HList w, HList s)) => (m (a, ss) -> m' (a', ss)) -> MultiRWST r w s m a -> MultiRWST r w s m' a'
- Control.Monad.Trans.MultiRWS: runMultiRWSTNil :: Monad m => MultiRWST [] [] [] m a -> m a
+ Control.Monad.Trans.MultiRWS: runMultiRWSTNil :: (Monad m) => MultiRWST '[] '[] '[] m a -> m a
- Control.Monad.Trans.MultiRWS: runMultiRWSTNil_ :: (Monad m, Functor m) => MultiRWST [] [] [] m a -> m ()
+ Control.Monad.Trans.MultiRWS: runMultiRWSTNil_ :: (Monad m, Functor m) => MultiRWST '[] '[] '[] m a -> m ()
- Control.Monad.Trans.MultiRWS: type MultiRWSTNull = MultiRWST [] [] []
+ Control.Monad.Trans.MultiRWS: type MultiRWSTNull = MultiRWST '[] '[] '[]
- Control.Monad.Trans.MultiRWS.Lazy: class Monad m => MonadMultiReader a m
+ Control.Monad.Trans.MultiRWS.Lazy: class (Monad m) => MonadMultiReader a m
- Control.Monad.Trans.MultiRWS.Lazy: class Monad m => MonadMultiState a m
+ Control.Monad.Trans.MultiRWS.Lazy: class (Monad m) => MonadMultiState a m
- Control.Monad.Trans.MultiRWS.Lazy: mapMultiRWST :: ss ~ (HList r, HList w, HList s) => (m (a, ss) -> m' (a', ss)) -> MultiRWST r w s m a -> MultiRWST r w s m' a'
+ Control.Monad.Trans.MultiRWS.Lazy: mapMultiRWST :: (ss ~ (HList r, HList w, HList s)) => (m (a, ss) -> m' (a', ss)) -> MultiRWST r w s m a -> MultiRWST r w s m' a'
- Control.Monad.Trans.MultiRWS.Lazy: runMultiRWSTNil :: Monad m => MultiRWST [] [] [] m a -> m a
+ Control.Monad.Trans.MultiRWS.Lazy: runMultiRWSTNil :: (Monad m) => MultiRWST '[] '[] '[] m a -> m a
- Control.Monad.Trans.MultiRWS.Lazy: runMultiRWSTNil_ :: (Monad m, Functor m) => MultiRWST [] [] [] m a -> m ()
+ Control.Monad.Trans.MultiRWS.Lazy: runMultiRWSTNil_ :: (Monad m, Functor m) => MultiRWST '[] '[] '[] m a -> m ()
- Control.Monad.Trans.MultiRWS.Lazy: type MultiRWSTNull = MultiRWST [] [] []
+ Control.Monad.Trans.MultiRWS.Lazy: type MultiRWSTNull = MultiRWST '[] '[] '[]
- Control.Monad.Trans.MultiRWS.Strict: class Monad m => MonadMultiReader a m
+ Control.Monad.Trans.MultiRWS.Strict: class (Monad m) => MonadMultiReader a m
- Control.Monad.Trans.MultiRWS.Strict: class Monad m => MonadMultiState a m
+ Control.Monad.Trans.MultiRWS.Strict: class (Monad m) => MonadMultiState a m
- Control.Monad.Trans.MultiRWS.Strict: mapMultiRWST :: ss ~ (HList r, HList w, HList s) => (m (a, ss) -> m' (a', ss)) -> MultiRWST r w s m a -> MultiRWST r w s m' a'
+ Control.Monad.Trans.MultiRWS.Strict: mapMultiRWST :: (ss ~ (HList r, HList w, HList s)) => (m (a, ss) -> m' (a', ss)) -> MultiRWST r w s m a -> MultiRWST r w s m' a'
- Control.Monad.Trans.MultiRWS.Strict: runMultiRWSTNil :: Monad m => MultiRWST [] [] [] m a -> m a
+ Control.Monad.Trans.MultiRWS.Strict: runMultiRWSTNil :: (Monad m) => MultiRWST '[] '[] '[] m a -> m a
- Control.Monad.Trans.MultiRWS.Strict: runMultiRWSTNil_ :: (Monad m, Functor m) => MultiRWST [] [] [] m a -> m ()
+ Control.Monad.Trans.MultiRWS.Strict: runMultiRWSTNil_ :: (Monad m, Functor m) => MultiRWST '[] '[] '[] m a -> m ()
- Control.Monad.Trans.MultiRWS.Strict: type MultiRWSTNull = MultiRWST [] [] []
+ Control.Monad.Trans.MultiRWS.Strict: type MultiRWSTNull = MultiRWST '[] '[] '[]
- Control.Monad.Trans.MultiReader: class Monad m => MonadMultiReader a m
+ Control.Monad.Trans.MultiReader: class (Monad m) => MonadMultiReader a m
- Control.Monad.Trans.MultiReader: runMultiReaderTNil :: Monad m => MultiReaderT [] m a -> m a
+ Control.Monad.Trans.MultiReader: runMultiReaderTNil :: Monad m => MultiReaderT '[] m a -> m a
- Control.Monad.Trans.MultiReader: runMultiReaderTNil_ :: Functor m => MultiReaderT [] m a -> m ()
+ Control.Monad.Trans.MultiReader: runMultiReaderTNil_ :: Functor m => MultiReaderT '[] m a -> m ()
- Control.Monad.Trans.MultiReader: type MultiReaderTNull = MultiReaderT []
+ Control.Monad.Trans.MultiReader: type MultiReaderTNull = MultiReaderT '[]
- Control.Monad.Trans.MultiReader.Class: class Monad m => MonadMultiReader a m
+ Control.Monad.Trans.MultiReader.Class: class (Monad m) => MonadMultiReader a m
- Control.Monad.Trans.MultiReader.Lazy: class Monad m => MonadMultiReader a m
+ Control.Monad.Trans.MultiReader.Lazy: class (Monad m) => MonadMultiReader a m
- Control.Monad.Trans.MultiReader.Lazy: runMultiReaderTNil :: Monad m => MultiReaderT [] m a -> m a
+ Control.Monad.Trans.MultiReader.Lazy: runMultiReaderTNil :: Monad m => MultiReaderT '[] m a -> m a
- Control.Monad.Trans.MultiReader.Lazy: runMultiReaderTNil_ :: Functor m => MultiReaderT [] m a -> m ()
+ Control.Monad.Trans.MultiReader.Lazy: runMultiReaderTNil_ :: Functor m => MultiReaderT '[] m a -> m ()
- Control.Monad.Trans.MultiReader.Lazy: type MultiReaderTNull = MultiReaderT []
+ Control.Monad.Trans.MultiReader.Lazy: type MultiReaderTNull = MultiReaderT '[]
- Control.Monad.Trans.MultiReader.Strict: class Monad m => MonadMultiReader a m
+ Control.Monad.Trans.MultiReader.Strict: class (Monad m) => MonadMultiReader a m
- Control.Monad.Trans.MultiReader.Strict: runMultiReaderTNil :: Monad m => MultiReaderT [] m a -> m a
+ Control.Monad.Trans.MultiReader.Strict: runMultiReaderTNil :: Monad m => MultiReaderT '[] m a -> m a
- Control.Monad.Trans.MultiReader.Strict: runMultiReaderTNil_ :: Functor m => MultiReaderT [] m a -> m ()
+ Control.Monad.Trans.MultiReader.Strict: runMultiReaderTNil_ :: Functor m => MultiReaderT '[] m a -> m ()
- Control.Monad.Trans.MultiReader.Strict: type MultiReaderTNull = MultiReaderT []
+ Control.Monad.Trans.MultiReader.Strict: type MultiReaderTNull = MultiReaderT '[]
- Control.Monad.Trans.MultiState: class Monad m => MonadMultiState a m
+ Control.Monad.Trans.MultiState: class (Monad m) => MonadMultiState a m
- Control.Monad.Trans.MultiState: runMultiStateTNil :: Monad m => MultiStateT [] m a -> m a
+ Control.Monad.Trans.MultiState: runMultiStateTNil :: Monad m => MultiStateT '[] m a -> m a
- Control.Monad.Trans.MultiState: runMultiStateTNil_ :: Functor m => MultiStateT [] m a -> m ()
+ Control.Monad.Trans.MultiState: runMultiStateTNil_ :: Functor m => MultiStateT '[] m a -> m ()
- Control.Monad.Trans.MultiState: type MultiStateTNull = MultiStateT []
+ Control.Monad.Trans.MultiState: type MultiStateTNull = MultiStateT '[]
- Control.Monad.Trans.MultiState.Class: class Monad m => MonadMultiState a m
+ Control.Monad.Trans.MultiState.Class: class (Monad m) => MonadMultiState a m
- Control.Monad.Trans.MultiState.Lazy: class Monad m => MonadMultiState a m
+ Control.Monad.Trans.MultiState.Lazy: class (Monad m) => MonadMultiState a m
- Control.Monad.Trans.MultiState.Lazy: runMultiStateTNil :: Monad m => MultiStateT [] m a -> m a
+ Control.Monad.Trans.MultiState.Lazy: runMultiStateTNil :: Monad m => MultiStateT '[] m a -> m a
- Control.Monad.Trans.MultiState.Lazy: runMultiStateTNil_ :: Functor m => MultiStateT [] m a -> m ()
+ Control.Monad.Trans.MultiState.Lazy: runMultiStateTNil_ :: Functor m => MultiStateT '[] m a -> m ()
- Control.Monad.Trans.MultiState.Lazy: type MultiStateTNull = MultiStateT []
+ Control.Monad.Trans.MultiState.Lazy: type MultiStateTNull = MultiStateT '[]
- Control.Monad.Trans.MultiState.Strict: class Monad m => MonadMultiState a m
+ Control.Monad.Trans.MultiState.Strict: class (Monad m) => MonadMultiState a m
- Control.Monad.Trans.MultiState.Strict: runMultiStateTNil :: Monad m => MultiStateT [] m a -> m a
+ Control.Monad.Trans.MultiState.Strict: runMultiStateTNil :: Monad m => MultiStateT '[] m a -> m a
- Control.Monad.Trans.MultiState.Strict: runMultiStateTNil_ :: Functor m => MultiStateT [] m a -> m ()
+ Control.Monad.Trans.MultiState.Strict: runMultiStateTNil_ :: Functor m => MultiStateT '[] m a -> m ()
- Control.Monad.Trans.MultiState.Strict: type MultiStateTNull = MultiStateT []
+ Control.Monad.Trans.MultiState.Strict: type MultiStateTNull = MultiStateT '[]
- Control.Monad.Trans.MultiWriter: runMultiWriterTNil :: Monad m => MultiWriterT [] m a -> m a
+ Control.Monad.Trans.MultiWriter: runMultiWriterTNil :: Monad m => MultiWriterT '[] m a -> m a
- Control.Monad.Trans.MultiWriter: runMultiWriterTNil_ :: Functor m => MultiWriterT [] m a -> m ()
+ Control.Monad.Trans.MultiWriter: runMultiWriterTNil_ :: Functor m => MultiWriterT '[] m a -> m ()
- Control.Monad.Trans.MultiWriter: type MultiWriterTNull = MultiWriterT []
+ Control.Monad.Trans.MultiWriter: type MultiWriterTNull = MultiWriterT '[]
- Control.Monad.Trans.MultiWriter.Lazy: runMultiWriterTNil :: Monad m => MultiWriterT [] m a -> m a
+ Control.Monad.Trans.MultiWriter.Lazy: runMultiWriterTNil :: Monad m => MultiWriterT '[] m a -> m a
- Control.Monad.Trans.MultiWriter.Lazy: runMultiWriterTNil_ :: Functor m => MultiWriterT [] m a -> m ()
+ Control.Monad.Trans.MultiWriter.Lazy: runMultiWriterTNil_ :: Functor m => MultiWriterT '[] m a -> m ()
- Control.Monad.Trans.MultiWriter.Lazy: type MultiWriterTNull = MultiWriterT []
+ Control.Monad.Trans.MultiWriter.Lazy: type MultiWriterTNull = MultiWriterT '[]
- Control.Monad.Trans.MultiWriter.Strict: runMultiWriterTNil :: Monad m => MultiWriterT [] m a -> m a
+ Control.Monad.Trans.MultiWriter.Strict: runMultiWriterTNil :: Monad m => MultiWriterT '[] m a -> m a
- Control.Monad.Trans.MultiWriter.Strict: runMultiWriterTNil_ :: Functor m => MultiWriterT [] m a -> m ()
+ Control.Monad.Trans.MultiWriter.Strict: runMultiWriterTNil_ :: Functor m => MultiWriterT '[] m a -> m ()
- Control.Monad.Trans.MultiWriter.Strict: type MultiWriterTNull = MultiWriterT []
+ Control.Monad.Trans.MultiWriter.Strict: type MultiWriterTNull = MultiWriterT '[]
- Data.HList.HList: HNil :: HList []
+ Data.HList.HList: HNil :: HList '[]

Files

changelog.md view
@@ -1,5 +1,16 @@ # Changelog for [`multistate` package](https://hackage.haskell.org/package/multistate) +## 0.7.0.0 *February 2016*++  * Add instances:++    + MonadIO+    + Alternative+    + MonadPlus+    + MonadBase+    + MonadTransControl+    + MonadBaseControl+ ## 0.6.2.0 *June 2015*    * Add MonadFix instances
multistate.cabal view
@@ -1,5 +1,5 @@ Name:          multistate-Version:       0.6.2.0+Version:       0.7.0.0 Cabal-Version: >= 1.10 Build-Type:    Simple license:       BSD3@@ -71,7 +71,9 @@     base         >= 4.6   && <4.9,     mtl          >= 2.1   && <2.3,     transformers >= 0.3   && <0.5,-    tagged       >= 0.7   && <0.9+    tagged       >= 0.7   && <0.9,+    transformers-base <0.5,+    monad-control     <1.1   default-extensions:     GADTs     TypeFamilies@@ -82,7 +84,10 @@     UndecidableInstances     TypeOperators     DataKinds-  ghc-options: -Wall+  ghc-options: {+    -Wall+    -fno-warn-unused-imports+  }   hs-source-dirs: src } @@ -94,9 +99,9 @@     -- no version constraints necessary, because they are already     -- given by library     multistate,-    base,-    transformers,-    hspec+    base <4.9,+    transformers <0.5,+    hspec <2.3   ghc-options:      -Wall   main-is:          Test.hs   hs-source-dirs:   test@@ -111,9 +116,9 @@       -- no version constraints necessary, because they are already       -- given by library       multistate,-      base,-      mtl,-      transformers+      base <4.9,+      mtl <2.3,+      transformers <0.5   } else {     buildable: False   }
src/Control/Monad/Trans/MultiRWS/Lazy.hs view
@@ -79,23 +79,36 @@ import Control.Monad.Trans.MultiState.Lazy   ( MultiStateT(..)                                              , runMultiStateT ) -import Control.Monad.State.Lazy   ( StateT(..)-                                  , MonadState(..)-                                  , execStateT-                                  , evalStateT-                                  , mapStateT )-import Control.Monad.Reader       ( ReaderT(..) )-import Control.Monad.Writer.Lazy  ( WriterT(..) )-import Control.Monad.Trans.Class  ( MonadTrans-                                  , lift )+import Control.Monad.State.Lazy        ( StateT(..)+                                       , MonadState(..)+                                       , execStateT+                                       , evalStateT+                                       , mapStateT )+import Control.Monad.Reader            ( ReaderT(..) )+import Control.Monad.Writer.Lazy       ( WriterT(..) )+import Control.Monad.Trans.Class       ( MonadTrans+                                       , lift ) -import Data.Functor.Identity      ( Identity )+import Data.Functor.Identity           ( Identity ) -import Control.Applicative        ( Applicative(..) )-import Control.Monad              ( liftM-                                  , ap-                                  , void )-import Control.Monad.Fix          ( MonadFix(..) )+import Control.Applicative             ( Applicative(..)+                                       , Alternative(..)+                                       )+import Control.Monad                   ( MonadPlus(..)+                                       , liftM+                                       , ap+                                       , void )+import Control.Monad.Base              ( MonadBase(..)+                                       , liftBaseDefault+                                       )+import Control.Monad.Trans.Control     ( MonadTransControl(..)+                                       , MonadBaseControl(..)+                                       , ComposeSt+                                       , defaultLiftBaseWith+                                       , defaultRestoreM+                                       )+import Control.Monad.Fix               ( MonadFix(..) )+import Control.Monad.IO.Class          ( MonadIO(..) )  import Data.Monoid @@ -411,3 +424,29 @@              -> MultiRWST r w s m a              -> MultiRWST r w s m' a' mapMultiRWST f = MultiRWST . mapStateT f . runMultiRWSTRaw++-- foreign lifting instances++instance MonadIO m => MonadIO (MultiRWST r w s m) where+  liftIO = lift . liftIO++instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiRWST r w s m) where+  empty = lift mzero+  MultiRWST m <|> MultiRWST n = MultiRWST $ m <|> n++instance MonadPlus m => MonadPlus (MultiRWST r w s m) where+  mzero = MultiRWST $ mzero+  MultiRWST m `mplus` MultiRWST n = MultiRWST $ m `mplus` n++instance MonadBase b m => MonadBase b (MultiRWST r w s m) where+  liftBase = liftBaseDefault++instance MonadTransControl (MultiRWST r w s) where+  type StT (MultiRWST r w s) a = (a, (HList r, HList w, HList s))+  liftWith f = MultiRWST $ liftWith $ \s -> f $ \r -> s $ runMultiRWSTRaw r+  restoreT = MultiRWST . restoreT++instance MonadBaseControl b m => MonadBaseControl b (MultiRWST r w s m) where+  type StM (MultiRWST r w s m) a = ComposeSt (MultiRWST r w s) m a+  liftBaseWith = defaultLiftBaseWith+  restoreM = defaultRestoreM
src/Control/Monad/Trans/MultiRWS/Strict.hs view
@@ -79,23 +79,36 @@ import Control.Monad.Trans.MultiState.Strict  ( MultiStateT(..)                                               , runMultiStateT ) -import Control.Monad.State.Strict   ( StateT(..)-                                    , MonadState(..)-                                    , execStateT-                                    , evalStateT-                                    , mapStateT )-import Control.Monad.Reader         ( ReaderT(..) )-import Control.Monad.Writer.Strict  ( WriterT(..) )-import Control.Monad.Trans.Class    ( MonadTrans-                                    , lift )+import Control.Monad.State.Strict      ( StateT(..)+                                       , MonadState(..)+                                       , execStateT+                                       , evalStateT+                                       , mapStateT )+import Control.Monad.Reader            ( ReaderT(..) )+import Control.Monad.Writer.Strict     ( WriterT(..) )+import Control.Monad.Trans.Class       ( MonadTrans+                                       , lift ) -import Data.Functor.Identity        ( Identity )+import Data.Functor.Identity           ( Identity ) -import Control.Applicative          ( Applicative(..) )-import Control.Monad                ( liftM-                                    , ap-                                    , void )-import Control.Monad.Fix            ( MonadFix(..) )+import Control.Applicative             ( Applicative(..)+                                       , Alternative(..)+                                       )+import Control.Monad                   ( MonadPlus(..)+                                       , liftM+                                       , ap+                                       , void )+import Control.Monad.Base              ( MonadBase(..)+                                       , liftBaseDefault+                                       )+import Control.Monad.Trans.Control     ( MonadTransControl(..)+                                       , MonadBaseControl(..)+                                       , ComposeSt+                                       , defaultLiftBaseWith+                                       , defaultRestoreM+                                       )+import Control.Monad.Fix               ( MonadFix(..) )+import Control.Monad.IO.Class          ( MonadIO(..) )  import Data.Monoid @@ -411,3 +424,29 @@              -> MultiRWST r w s m a              -> MultiRWST r w s m' a' mapMultiRWST f = MultiRWST . mapStateT f . runMultiRWSTRaw++-- foreign lifting instances++instance MonadIO m => MonadIO (MultiRWST r w s m) where+  liftIO = lift . liftIO++instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiRWST r w s m) where+  empty = lift mzero+  MultiRWST m <|> MultiRWST n = MultiRWST $ m <|> n++instance MonadPlus m => MonadPlus (MultiRWST r w s m) where+  mzero = MultiRWST $ mzero+  MultiRWST m `mplus` MultiRWST n = MultiRWST $ m `mplus` n++instance MonadBase b m => MonadBase b (MultiRWST r w s m) where+  liftBase = liftBaseDefault++instance MonadTransControl (MultiRWST r w s) where+  type StT (MultiRWST r w s) a = (a, (HList r, HList w, HList s))+  liftWith f = MultiRWST $ liftWith $ \s -> f $ \r -> s $ runMultiRWSTRaw r+  restoreT = MultiRWST . restoreT++instance MonadBaseControl b m => MonadBaseControl b (MultiRWST r w s m) where+  type StM (MultiRWST r w s m) a = ComposeSt (MultiRWST r w s) m a+  liftBaseWith = defaultLiftBaseWith+  restoreM = defaultRestoreM
src/Control/Monad/Trans/MultiReader/Lazy.hs view
@@ -33,26 +33,39 @@  import Control.Monad.Trans.MultiReader.Class ( MonadMultiReader(..) ) -import Control.Monad.State.Lazy   ( StateT(..)-                                  , MonadState(..)-                                  , evalStateT-                                  , mapStateT )-import Control.Monad.Reader       ( ReaderT(..) )-import Control.Monad.Trans.Class  ( MonadTrans-                                  , lift )-import Control.Monad.Writer.Class ( MonadWriter-                                  , listen-                                  , tell-                                  , writer-                                  , pass )+import Control.Monad.State.Lazy        ( StateT(..)+                                       , MonadState(..)+                                       , evalStateT+                                       , mapStateT )+import Control.Monad.Reader            ( ReaderT(..) )+import Control.Monad.Trans.Class       ( MonadTrans+                                       , lift )+import Control.Monad.Writer.Class      ( MonadWriter+                                       , listen+                                       , tell+                                       , writer+                                       , pass ) -import Data.Functor.Identity      ( Identity )+import Data.Functor.Identity           ( Identity ) -import Control.Applicative        ( Applicative(..) )-import Control.Monad              ( liftM-                                  , ap-                                  , void )-import Control.Monad.Fix          ( MonadFix(..) )+import Control.Applicative             ( Applicative(..)+                                       , Alternative(..)+                                       )+import Control.Monad                   ( MonadPlus(..)+                                       , liftM+                                       , ap+                                       , void )+import Control.Monad.Base              ( MonadBase(..)+                                       , liftBaseDefault+                                       )+import Control.Monad.Trans.Control     ( MonadTransControl(..)+                                       , MonadBaseControl(..)+                                       , ComposeSt+                                       , defaultLiftBaseWith+                                       , defaultRestoreM+                                       )+import Control.Monad.Fix               ( MonadFix(..) )+import Control.Monad.IO.Class          ( MonadIO(..) )   @@ -176,6 +189,26 @@     mapStateT (pass . liftM (\(~(~(a, f), w)) -> ((a, w), f))) .     runMultiReaderTRaw   +instance MonadIO m => MonadIO (MultiReaderT c m) where+  liftIO = lift . liftIO +instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiReaderT c m) where+  empty = lift mzero+  MultiReaderT m <|> MultiReaderT n = MultiReaderT $ m <|> n +instance MonadPlus m => MonadPlus (MultiReaderT c m) where+  mzero = MultiReaderT $ mzero+  MultiReaderT m `mplus` MultiReaderT n = MultiReaderT $ m `mplus` n +instance MonadBase b m => MonadBase b (MultiReaderT r m) where+  liftBase = liftBaseDefault++instance MonadTransControl (MultiReaderT r) where+  type StT (MultiReaderT r) a = (a, HList r)+  liftWith f = MultiReaderT $ liftWith $ \s -> f $ \r -> s $ runMultiReaderTRaw r+  restoreT = MultiReaderT . restoreT++instance MonadBaseControl b m => MonadBaseControl b (MultiReaderT r m) where+  type StM (MultiReaderT r m) a = ComposeSt (MultiReaderT r) m a+  liftBaseWith = defaultLiftBaseWith+  restoreM = defaultRestoreM
src/Control/Monad/Trans/MultiReader/Strict.hs view
@@ -33,26 +33,39 @@  import Control.Monad.Trans.MultiReader.Class ( MonadMultiReader(..) ) -import Control.Monad.State.Strict ( StateT(..)-                                  , MonadState(..)-                                  , evalStateT-                                  , mapStateT )-import Control.Monad.Reader       ( ReaderT(..) )-import Control.Monad.Trans.Class  ( MonadTrans-                                  , lift )-import Control.Monad.Writer.Class ( MonadWriter-                                  , listen-                                  , tell-                                  , writer-                                  , pass )+import Control.Monad.State.Strict      ( StateT(..)+                                       , MonadState(..)+                                       , evalStateT+                                       , mapStateT )+import Control.Monad.Reader            ( ReaderT(..) )+import Control.Monad.Trans.Class       ( MonadTrans+                                       , lift )+import Control.Monad.Writer.Class      ( MonadWriter+                                       , listen+                                       , tell+                                       , writer+                                       , pass ) -import Data.Functor.Identity      ( Identity )+import Data.Functor.Identity           ( Identity ) -import Control.Applicative        ( Applicative(..) )-import Control.Monad              ( liftM-                                  , ap-                                  , void )-import Control.Monad.Fix          ( MonadFix(..) )+import Control.Applicative             ( Applicative(..)+                                       , Alternative(..)+                                       )+import Control.Monad                   ( MonadPlus(..)+                                       , liftM+                                       , ap+                                       , void )+import Control.Monad.Base              ( MonadBase(..)+                                       , liftBaseDefault+                                       )+import Control.Monad.Trans.Control     ( MonadTransControl(..)+                                       , MonadBaseControl(..)+                                       , ComposeSt+                                       , defaultLiftBaseWith+                                       , defaultRestoreM+                                       )+import Control.Monad.Fix               ( MonadFix(..) )+import Control.Monad.IO.Class          ( MonadIO(..) )   @@ -176,6 +189,26 @@     mapStateT (pass . liftM (\((a, f), w) -> ((a, w), f))) .     runMultiReaderTRaw   +instance MonadIO m => MonadIO (MultiReaderT c m) where+  liftIO = lift . liftIO +instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiReaderT c m) where+  empty = lift mzero+  MultiReaderT m <|> MultiReaderT n = MultiReaderT $ m <|> n +instance MonadPlus m => MonadPlus (MultiReaderT c m) where+  mzero = MultiReaderT $ mzero+  MultiReaderT m `mplus` MultiReaderT n = MultiReaderT $ m `mplus` n +instance MonadBase b m => MonadBase b (MultiReaderT r m) where+  liftBase = liftBaseDefault++instance MonadTransControl (MultiReaderT r) where+  type StT (MultiReaderT r) a = (a, HList r)+  liftWith f = MultiReaderT $ liftWith $ \s -> f $ \r -> s $ runMultiReaderTRaw r+  restoreT = MultiReaderT . restoreT++instance MonadBaseControl b m => MonadBaseControl b (MultiReaderT r m) where+  type StM (MultiReaderT r m) a = ComposeSt (MultiReaderT r) m a+  liftBaseWith = defaultLiftBaseWith+  restoreM = defaultRestoreM
src/Control/Monad/Trans/MultiState/Lazy.hs view
@@ -47,29 +47,42 @@  import Control.Monad.Trans.MultiState.Class -import Control.Monad.State.Lazy   ( StateT(..)-                                  , MonadState(..)-                                  , evalStateT-                                  , execStateT-                                  , mapStateT )-import Control.Monad.Reader       ( ReaderT(..) )-import Control.Monad.Writer.Lazy  ( WriterT(..) )-import Control.Monad.Trans.Class  ( MonadTrans-                                  , lift )-import Control.Monad.Writer.Class ( MonadWriter-                                  , listen-                                  , tell-                                  , writer-                                  , pass )+import Control.Monad.State.Lazy        ( StateT(..)+                                       , MonadState(..)+                                       , evalStateT+                                       , execStateT+                                       , mapStateT )+import Control.Monad.Reader            ( ReaderT(..) )+import Control.Monad.Writer.Lazy       ( WriterT(..) )+import Control.Monad.Trans.Class       ( MonadTrans+                                       , lift )+import Control.Monad.Writer.Class      ( MonadWriter+                                       , listen+                                       , tell+                                       , writer+                                       , pass ) -import Data.Functor.Identity      ( Identity )+import Data.Functor.Identity           ( Identity ) -import Control.Applicative        ( Applicative(..) )-import Control.Monad              ( liftM-                                  , ap-                                  , void )-import Data.Monoid                ( Monoid )-import Control.Monad.Fix          ( MonadFix(..) )+import Control.Applicative             ( Applicative(..)+                                       , Alternative(..)+                                       )+import Control.Monad                   ( MonadPlus(..)+                                       , liftM+                                       , ap+                                       , void )+import Control.Monad.Base              ( MonadBase(..)+                                       , liftBaseDefault+                                       )+import Control.Monad.Trans.Control     ( MonadTransControl(..)+                                       , MonadBaseControl(..)+                                       , ComposeSt+                                       , defaultLiftBaseWith+                                       , defaultRestoreM+                                       )+import Data.Monoid                     ( Monoid )+import Control.Monad.Fix               ( MonadFix(..) )+import Control.Monad.IO.Class          ( MonadIO(..) )   @@ -247,3 +260,27 @@   pass = MultiStateT .     mapStateT (pass . liftM (\(~(~(a, f), w)) -> ((a, w), f))) .     runMultiStateTRaw  ++instance MonadIO m => MonadIO (MultiStateT c m) where+  liftIO = lift . liftIO++instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiStateT s m) where+  empty = lift mzero+  MultiStateT m <|> MultiStateT n = MultiStateT $ m <|> n++instance MonadPlus m => MonadPlus (MultiStateT s m) where+  mzero = MultiStateT $ mzero+  MultiStateT m `mplus` MultiStateT n = MultiStateT $ m `mplus` n++instance MonadBase b m => MonadBase b (MultiStateT s m) where+  liftBase = liftBaseDefault++instance MonadTransControl (MultiStateT s) where+  type StT (MultiStateT s) a = (a, HList s)+  liftWith f = MultiStateT $ liftWith $ \s -> f $ \r -> s $ runMultiStateTRaw r+  restoreT = MultiStateT . restoreT++instance MonadBaseControl b m => MonadBaseControl b (MultiStateT s m) where+  type StM (MultiStateT s m) a = ComposeSt (MultiStateT s) m a+  liftBaseWith = defaultLiftBaseWith+  restoreM = defaultRestoreM
src/Control/Monad/Trans/MultiState/Strict.hs view
@@ -47,29 +47,42 @@  import Control.Monad.Trans.MultiState.Class -import Control.Monad.State.Strict  ( StateT(..)-                                   , MonadState(..)-                                   , evalStateT-                                   , execStateT-                                   , mapStateT )-import Control.Monad.Reader        ( ReaderT(..) )-import Control.Monad.Writer.Strict ( WriterT(..) )-import Control.Monad.Trans.Class   ( MonadTrans-                                   , lift )-import Control.Monad.Writer.Class  ( MonadWriter-                                   , listen-                                   , tell-                                   , writer-                                   , pass )+import Control.Monad.State.Strict      ( StateT(..)+                                       , MonadState(..)+                                       , evalStateT+                                       , execStateT+                                       , mapStateT )+import Control.Monad.Reader            ( ReaderT(..) )+import Control.Monad.Writer.Strict     ( WriterT(..) )+import Control.Monad.Trans.Class       ( MonadTrans+                                       , lift )+import Control.Monad.Writer.Class      ( MonadWriter+                                       , listen+                                       , tell+                                       , writer+                                       , pass ) -import Data.Functor.Identity       ( Identity )+import Data.Functor.Identity           ( Identity ) -import Control.Applicative         ( Applicative(..) )-import Control.Monad               ( liftM-                                   , ap-                                   , void )-import Data.Monoid                 ( Monoid )-import Control.Monad.Fix           ( MonadFix(..) )+import Control.Applicative             ( Applicative(..)+                                       , Alternative(..)+                                       )+import Control.Monad                   ( MonadPlus(..)+                                       , liftM+                                       , ap+                                       , void )+import Control.Monad.Base              ( MonadBase(..)+                                       , liftBaseDefault+                                       )+import Control.Monad.Trans.Control     ( MonadTransControl(..)+                                       , MonadBaseControl(..)+                                       , ComposeSt+                                       , defaultLiftBaseWith+                                       , defaultRestoreM+                                       )+import Data.Monoid                     ( Monoid )+import Control.Monad.Fix               ( MonadFix(..) )+import Control.Monad.IO.Class          ( MonadIO(..) )   @@ -245,3 +258,27 @@   pass = MultiStateT .     mapStateT (pass . liftM (\((a, f), w) -> ((a, w), f))) .     runMultiStateTRaw  ++instance MonadIO m => MonadIO (MultiStateT c m) where+  liftIO = lift . liftIO++instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiStateT s m) where+  empty = lift mzero+  MultiStateT m <|> MultiStateT n = MultiStateT $ m <|> n++instance MonadPlus m => MonadPlus (MultiStateT s m) where+  mzero = MultiStateT $ mzero+  MultiStateT m `mplus` MultiStateT n = MultiStateT $ m `mplus` n++instance MonadBase b m => MonadBase b (MultiStateT s m) where+  liftBase = liftBaseDefault++instance MonadTransControl (MultiStateT s) where+  type StT (MultiStateT s) a = (a, HList s)+  liftWith f = MultiStateT $ liftWith $ \s -> f $ \r -> s $ runMultiStateTRaw r+  restoreT = MultiStateT . restoreT++instance MonadBaseControl b m => MonadBaseControl b (MultiStateT s m) where+  type StM (MultiStateT s m) a = ComposeSt (MultiStateT s) m a+  liftBaseWith = defaultLiftBaseWith+  restoreM = defaultRestoreM
src/Control/Monad/Trans/MultiWriter/Lazy.hs view
@@ -44,27 +44,40 @@  import Control.Monad.Trans.MultiWriter.Class ( MonadMultiWriter(..) ) -import Control.Monad.State.Lazy   ( StateT(..)-                                  , MonadState(..)-                                  , execStateT-                                  , evalStateT-                                  , mapStateT )-import Control.Monad.Writer.Lazy  ( WriterT(..) ) -import Control.Monad.Trans.Class  ( MonadTrans-                                  , lift )-import Control.Monad.Writer.Class ( MonadWriter-                                  , listen-                                  , tell-                                  , writer-                                  , pass )+import Control.Monad.State.Lazy        ( StateT(..)+                                       , MonadState(..)+                                       , execStateT+                                       , evalStateT+                                       , mapStateT )+import Control.Monad.Writer.Lazy       ( WriterT(..) )+import Control.Monad.Trans.Class       ( MonadTrans+                                       , lift )+import Control.Monad.Writer.Class      ( MonadWriter+                                       , listen+                                       , tell+                                       , writer+                                       , pass ) -import Data.Functor.Identity      ( Identity )+import Data.Functor.Identity           ( Identity ) -import Control.Applicative        ( Applicative(..) )-import Control.Monad              ( liftM-                                  , ap-                                  , void )-import Control.Monad.Fix          ( MonadFix(..) )+import Control.Applicative             ( Applicative(..)+                                       , Alternative(..)+                                       )+import Control.Monad                   ( MonadPlus(..)+                                       , liftM+                                       , ap+                                       , void )+import Control.Monad.Base              ( MonadBase(..)+                                       , liftBaseDefault+                                       )+import Control.Monad.Trans.Control     ( MonadTransControl(..)+                                       , MonadBaseControl(..)+                                       , ComposeSt+                                       , defaultLiftBaseWith+                                       , defaultRestoreM+                                       )+import Control.Monad.Fix               ( MonadFix(..) )+import Control.Monad.IO.Class          ( MonadIO(..) )  import Data.Monoid @@ -226,3 +239,27 @@   pass = MultiWriterT .     mapStateT (pass . liftM (\(~(~(a, f), w)) -> ((a, w), f))) .     runMultiWriterTRaw++instance MonadIO m => MonadIO (MultiWriterT c m) where+  liftIO = lift . liftIO++instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiWriterT c m) where+  empty = lift mzero+  MultiWriterT m <|> MultiWriterT n = MultiWriterT $ m <|> n++instance MonadPlus m => MonadPlus (MultiWriterT c m) where+  mzero = MultiWriterT $ mzero+  MultiWriterT m `mplus` MultiWriterT n = MultiWriterT $ m `mplus` n++instance MonadBase b m => MonadBase b (MultiWriterT c m) where+  liftBase = liftBaseDefault++instance MonadTransControl (MultiWriterT c) where+  type StT (MultiWriterT c) a = (a, HList c)+  liftWith f = MultiWriterT $ liftWith $ \s -> f $ \r -> s $ runMultiWriterTRaw r+  restoreT = MultiWriterT . restoreT++instance MonadBaseControl b m => MonadBaseControl b (MultiWriterT c m) where+  type StM (MultiWriterT c m) a = ComposeSt (MultiWriterT c) m a+  liftBaseWith = defaultLiftBaseWith+  restoreM = defaultRestoreM
src/Control/Monad/Trans/MultiWriter/Strict.hs view
@@ -44,27 +44,40 @@  import Control.Monad.Trans.MultiWriter.Class ( MonadMultiWriter(..) ) -import Control.Monad.State.Strict  ( StateT(..)-                                   , MonadState(..)-                                   , execStateT-                                   , evalStateT-                                   , mapStateT )-import Control.Monad.Writer.Strict ( WriterT(..) )-import Control.Monad.Trans.Class   ( MonadTrans-                                   , lift )-import Control.Monad.Writer.Class  ( MonadWriter-                                   , listen-                                   , tell-                                   , writer-                                   , pass )+import Control.Monad.State.Strict      ( StateT(..)+                                       , MonadState(..)+                                       , execStateT+                                       , evalStateT+                                       , mapStateT )+import Control.Monad.Writer.Strict     ( WriterT(..) )+import Control.Monad.Trans.Class       ( MonadTrans+                                       , lift )+import Control.Monad.Writer.Class      ( MonadWriter+                                       , listen+                                       , tell+                                       , writer+                                       , pass ) -import Data.Functor.Identity       ( Identity )+import Data.Functor.Identity           ( Identity ) -import Control.Applicative         ( Applicative(..) )-import Control.Monad               ( liftM-                                   , ap-                                   , void )-import Control.Monad.Fix           ( MonadFix(..) )+import Control.Applicative             ( Applicative(..)+                                       , Alternative(..)+                                       )+import Control.Monad                   ( MonadPlus(..)+                                       , liftM+                                       , ap+                                       , void )+import Control.Monad.Base              ( MonadBase(..)+                                       , liftBaseDefault+                                       )+import Control.Monad.Trans.Control     ( MonadTransControl(..)+                                       , MonadBaseControl(..)+                                       , ComposeSt+                                       , defaultLiftBaseWith+                                       , defaultRestoreM+                                       )+import Control.Monad.Fix               ( MonadFix(..) )+import Control.Monad.IO.Class          ( MonadIO(..) )  import Data.Monoid @@ -226,3 +239,27 @@   pass = MultiWriterT .     mapStateT (pass . liftM (\((a, f), w) -> ((a, w), f))) .     runMultiWriterTRaw++instance MonadIO m => MonadIO (MultiWriterT c m) where+  liftIO = lift . liftIO++instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiWriterT c m) where+  empty = lift mzero+  MultiWriterT m <|> MultiWriterT n = MultiWriterT $ m <|> n++instance MonadPlus m => MonadPlus (MultiWriterT c m) where+  mzero = MultiWriterT $ mzero+  MultiWriterT m `mplus` MultiWriterT n = MultiWriterT $ m `mplus` n++instance MonadBase b m => MonadBase b (MultiWriterT c m) where+  liftBase = liftBaseDefault++instance MonadTransControl (MultiWriterT c) where+  type StT (MultiWriterT c) a = (a, HList c)+  liftWith f = MultiWriterT $ liftWith $ \s -> f $ \r -> s $ runMultiWriterTRaw r+  restoreT = MultiWriterT . restoreT++instance MonadBaseControl b m => MonadBaseControl b (MultiWriterT c m) where+  type StM (MultiWriterT c m) a = ComposeSt (MultiWriterT c) m a+  liftBaseWith = defaultLiftBaseWith+  restoreM = defaultRestoreM