-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | like mtl's ReaderT / WriterT / StateT, but more than one
--   contained value/type.
--   
--   When using multiple Read/Write/State transformers in the same monad
--   stack, it becomes necessary to lift the operations in order to affect
--   a specific transformer. Using heterogeneous lists (and all kinds of
--   GHC extensions magic), this package provides transformers that remove
--   that necessity: MultiReaderT/MultiWriterT/MultiStateT/MultiRWST can
--   contain a heterogeneous list of values.
--   
--   See the <a>README</a> for a longer description.
@package multistate
@version 0.8.0.2


-- | A GADT HList implementation
--   
--   There exist other implementations of HList on hackage, but none seem
--   to be reliably maintained.
module Data.HList.HList
data HList :: [Type] -> Type
[HNil] :: HList '[]
[:+:] :: x -> HList xs -> HList (x : xs)
hAppend :: HList ts1 -> HList ts2 -> HList (Append ts1 ts2)
class HInit (l1 :: [Type])
hInit :: forall l2. HInit l1 => Proxy l2 -> HList (Append l1 l2) -> HList l1
hSplit :: forall l2. HInit l1 => HList (Append l1 l2) -> (HList l1, HList l2)
instance GHC.Show.Show (Data.HList.HList.HList '[])
instance (GHC.Show.Show a, GHC.Show.Show (Data.HList.HList.HList b)) => GHC.Show.Show (Data.HList.HList.HList (a : b))
instance Data.Semigroup.Semigroup (Data.HList.HList.HList '[])
instance (Data.Semigroup.Semigroup x, Data.Semigroup.Semigroup (Data.HList.HList.HList xs)) => Data.Semigroup.Semigroup (Data.HList.HList.HList (x : xs))
instance GHC.Base.Monoid (Data.HList.HList.HList '[])
instance (Data.Semigroup.Semigroup x, GHC.Base.Monoid x, Data.Semigroup.Semigroup (Data.HList.HList.HList xs), GHC.Base.Monoid (Data.HList.HList.HList xs)) => GHC.Base.Monoid (Data.HList.HList.HList (x : xs))
instance GHC.Classes.Eq (Data.HList.HList.HList '[])
instance (GHC.Classes.Eq x, GHC.Classes.Eq (Data.HList.HList.HList xs)) => GHC.Classes.Eq (Data.HList.HList.HList (x : xs))
instance Data.HList.HList.HInit '[]
instance Data.HList.HList.HInit l1 => Data.HList.HList.HInit (x : l1)


-- | Class to provide type-driven access to elements of a HList
module Data.HList.ContainsType

-- | for get/put of a value in a HList, with type-directed lookup.
class ContainsType a c
setHListElem :: ContainsType a c => a -> HList c -> HList c
getHListElem :: ContainsType a c => HList c -> a
instance Data.HList.ContainsType.ContainsType a (a : xs)
instance Data.HList.ContainsType.ContainsType a xs => Data.HList.ContainsType.ContainsType a (x : xs)


-- | The multi-valued version of mtl's MonadWriter
module Control.Monad.Trans.MultiWriter.Class
class (Monad m, Monoid a) => MonadMultiWriter a m
mTell :: MonadMultiWriter a m => a -> m ()
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)


-- | The multi-valued version of mtl's Writer / WriterT
module Control.Monad.Trans.MultiWriter.Lazy

-- | A Writer transformer monad patameterized by:
--   
--   <ul>
--   <li>x - The list of types that can be written (Monoid instances).</li>
--   <li>m - The inner monad.</li>
--   </ul>
--   
--   <a>MultiWriterT</a> corresponds to mtl's <a>WriterT</a>, but can
--   contain a heterogenous list of types.
--   
--   This heterogenous list is represented using Types.Data.List, i.e:
--   
--   <ul>
--   <li><tt>'[]</tt> - The empty list,</li>
--   <li><tt>a ': b</tt> - A list where <tt><i>a</i></tt> is an arbitrary
--   type and <tt><i>b</i></tt> is the rest list.</li>
--   </ul>
--   
--   For example,
--   
--   <pre>
--   MultiWriterT '[Int, Bool] :: (* -&gt; *) -&gt; (* -&gt; *)
--   </pre>
--   
--   is a Writer transformer containing the types [Int, Bool].
newtype MultiWriterT x m a
MultiWriterT :: StateT (HList x) m a -> MultiWriterT x m a
[runMultiWriterTRaw] :: MultiWriterT x m a -> StateT (HList x) m a

-- | A MultiWriter transformer carrying an empty state.
type MultiWriterTNull = MultiWriterT '[]
type MultiWriter x a = MultiWriterT x Identity a
class (Monad m, Monoid a) => MonadMultiWriter a m
mTell :: MonadMultiWriter a m => a -> m ()
runMultiWriterT :: (Monoid (HList w), Functor m) => MultiWriterT w m a -> m (a, HList w)
runMultiWriterTAW :: (Monoid (HList w), Functor m) => MultiWriterT w m a -> m (a, HList w)
runMultiWriterTWA :: (Monoid (HList w), Monad m) => MultiWriterT w m a -> m (HList w, a)
runMultiWriterTW :: (Monoid (HList w), Monad m) => MultiWriterT w m a -> m (HList w)
runMultiWriterTNil :: Monad m => MultiWriterT '[] m a -> m a
runMultiWriterTNil_ :: Functor m => MultiWriterT '[] m a -> m ()
withMultiWriter :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m (a, w)
withMultiWriterAW :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m (a, w)
withMultiWriterWA :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m (w, a)
withMultiWriterW :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m w
withMultiWriters :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (a, HList w1)
withMultiWritersAW :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (a, HList w1)
withMultiWritersWA :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (HList w1, a)
withMultiWritersW :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (HList w1)
inflateWriter :: (Monad m, Monoid w, ContainsType w ws) => WriterT w m a -> MultiWriterT ws m a

-- | Map both the return value and the state of a computation using the
--   given function.
mapMultiWriterT :: (m (a, HList w) -> m' (a', HList w)) -> MultiWriterT w m a -> MultiWriterT w m' a'

-- | A raw extractor of the contained HList (i.e. the complete state).
mGetRaw :: Monad m => MultiWriterT a m (HList a)
mPutRaw :: Monad m => HList s -> MultiWriterT s m ()
instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT x f)
instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT x m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT x m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT x)
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)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT w m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)


-- | The multi-valued version of mtl's Writer / WriterT
module Control.Monad.Trans.MultiWriter.Strict

-- | A Writer transformer monad patameterized by:
--   
--   <ul>
--   <li>x - The list of types that can be written (Monoid instances).</li>
--   <li>m - The inner monad.</li>
--   </ul>
--   
--   <a>MultiWriterT</a> corresponds to mtl's <a>WriterT</a>, but can
--   contain a heterogenous list of types.
--   
--   This heterogenous list is represented using Types.Data.List, i.e:
--   
--   <ul>
--   <li><tt>'[]</tt> - The empty list,</li>
--   <li><tt>a ': b</tt> - A list where <tt><i>a</i></tt> is an arbitrary
--   type and <tt><i>b</i></tt> is the rest list.</li>
--   </ul>
--   
--   For example,
--   
--   <pre>
--   MultiWriterT '[Int, Bool] :: (* -&gt; *) -&gt; (* -&gt; *)
--   </pre>
--   
--   is a Writer transformer containing the types [Int, Bool].
newtype MultiWriterT x m a
MultiWriterT :: StateT (HList x) m a -> MultiWriterT x m a
[runMultiWriterTRaw] :: MultiWriterT x m a -> StateT (HList x) m a

-- | A MultiWriter transformer carrying an empty state.
type MultiWriterTNull = MultiWriterT '[]
type MultiWriter x a = MultiWriterT x Identity a
class (Monad m, Monoid a) => MonadMultiWriter a m
mTell :: MonadMultiWriter a m => a -> m ()
runMultiWriterT :: (Monoid (HList w), Functor m) => MultiWriterT w m a -> m (a, HList w)
runMultiWriterTAW :: (Monoid (HList w), Functor m) => MultiWriterT w m a -> m (a, HList w)
runMultiWriterTWA :: (Monoid (HList w), Monad m) => MultiWriterT w m a -> m (HList w, a)
runMultiWriterTW :: (Monoid (HList w), Monad m) => MultiWriterT w m a -> m (HList w)
runMultiWriterTNil :: Monad m => MultiWriterT '[] m a -> m a
runMultiWriterTNil_ :: Functor m => MultiWriterT '[] m a -> m ()
withMultiWriter :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m (a, w)
withMultiWriterAW :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m (a, w)
withMultiWriterWA :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m (w, a)
withMultiWriterW :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m w
withMultiWriters :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (a, HList w1)
withMultiWritersAW :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (a, HList w1)
withMultiWritersWA :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (HList w1, a)
withMultiWritersW :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (HList w1)
inflateWriter :: (Monad m, Monoid w, ContainsType w ws) => WriterT w m a -> MultiWriterT ws m a

-- | Map both the return value and the state of a computation using the
--   given function.
mapMultiWriterT :: (m (a, HList w) -> m' (a', HList w)) -> MultiWriterT w m a -> MultiWriterT w m' a'

-- | A raw extractor of the contained HList (i.e. the complete state).
mGetRaw :: Monad m => MultiWriterT a m (HList a)
mPutRaw :: Monad m => HList s -> MultiWriterT s m ()
instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT x f)
instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT x m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT x m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT x)
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)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT w m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)


-- | The multi-valued version of mtl's Writer / WriterT / MonadWriter
module Control.Monad.Trans.MultiWriter

-- | A Writer transformer monad patameterized by:
--   
--   <ul>
--   <li>x - The list of types that can be written (Monoid instances).</li>
--   <li>m - The inner monad.</li>
--   </ul>
--   
--   <a>MultiWriterT</a> corresponds to mtl's <a>WriterT</a>, but can
--   contain a heterogenous list of types.
--   
--   This heterogenous list is represented using Types.Data.List, i.e:
--   
--   <ul>
--   <li><tt>'[]</tt> - The empty list,</li>
--   <li><tt>a ': b</tt> - A list where <tt><i>a</i></tt> is an arbitrary
--   type and <tt><i>b</i></tt> is the rest list.</li>
--   </ul>
--   
--   For example,
--   
--   <pre>
--   MultiWriterT '[Int, Bool] :: (* -&gt; *) -&gt; (* -&gt; *)
--   </pre>
--   
--   is a Writer transformer containing the types [Int, Bool].
newtype MultiWriterT x m a
MultiWriterT :: StateT (HList x) m a -> MultiWriterT x m a
[runMultiWriterTRaw] :: MultiWriterT x m a -> StateT (HList x) m a

-- | A MultiWriter transformer carrying an empty state.
type MultiWriterTNull = MultiWriterT '[]
type MultiWriter x a = MultiWriterT x Identity a
class (Monad m, Monoid a) => MonadMultiWriter a m
mTell :: MonadMultiWriter a m => a -> m ()
runMultiWriterT :: (Monoid (HList w), Functor m) => MultiWriterT w m a -> m (a, HList w)
runMultiWriterTAW :: (Monoid (HList w), Functor m) => MultiWriterT w m a -> m (a, HList w)
runMultiWriterTWA :: (Monoid (HList w), Monad m) => MultiWriterT w m a -> m (HList w, a)
runMultiWriterTW :: (Monoid (HList w), Monad m) => MultiWriterT w m a -> m (HList w)
runMultiWriterTNil :: Monad m => MultiWriterT '[] m a -> m a
runMultiWriterTNil_ :: Functor m => MultiWriterT '[] m a -> m ()
withMultiWriter :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m (a, w)
withMultiWriterAW :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m (a, w)
withMultiWriterWA :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m (w, a)
withMultiWriterW :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m w
withMultiWriters :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (a, HList w1)
withMultiWritersAW :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (a, HList w1)
withMultiWritersWA :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (HList w1, a)
withMultiWritersW :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (HList w1)

-- | Map both the return value and the state of a computation using the
--   given function.
mapMultiWriterT :: (m (a, HList w) -> m' (a', HList w)) -> MultiWriterT w m a -> MultiWriterT w m' a'

-- | A raw extractor of the contained HList (i.e. the complete state).
mGetRaw :: Monad m => MultiWriterT a m (HList a)
mPutRaw :: Monad m => HList s -> MultiWriterT s m ()


-- | The multi-valued version of mtl's MonadReader
module Control.Monad.Trans.MultiReader.Class

-- | All methods must be defined.
--   
--   The idea is: Any monad stack is instance of <tt>MonadMultiReader
--   a</tt>, iff the stack contains a <tt>MultiReaderT x</tt> with <i>a</i>
--   element of <i>x</i>.
class (Monad m) => MonadMultiReader a m
mAsk :: MonadMultiReader a m => m a
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)


-- | The MonadMultiReader type-class
module Control.Monad.Trans.MultiGet.Class

-- | In contrast to MonadMultiReader, MonadMultiGet is defined for State
--   too, so it corresponds to read-access of any kind.
--   
--   Note however that for MultiRWS, only the values from the
--   <tt>state</tt> part can be accessed via <tt>MonadMultiGet</tt>, due to
--   limitations of the design of <tt>MultiRWS</tt> and of the type system.
--   This is issue is resolved in the <tt>MultiGST</tt> type.
class (Monad m) => MonadMultiGet a m
mGet :: MonadMultiGet a m => m a
instance (Control.Monad.Trans.Class.MonadTrans t, GHC.Base.Monad (t m), Control.Monad.Trans.MultiGet.Class.MonadMultiGet a m) => Control.Monad.Trans.MultiGet.Class.MonadMultiGet a (t m)


-- | The multi-valued version of mtl's MonadState
module Control.Monad.Trans.MultiState.Class

-- | In contrast to MonadMultiReader, MonadMultiGet is defined for State
--   too, so it corresponds to read-access of any kind.
--   
--   Note however that for MultiRWS, only the values from the
--   <tt>state</tt> part can be accessed via <tt>MonadMultiGet</tt>, due to
--   limitations of the design of <tt>MultiRWS</tt> and of the type system.
--   This is issue is resolved in the <tt>MultiGST</tt> type.
class (Monad m) => MonadMultiGet a m
mGet :: MonadMultiGet a m => m a
class (MonadMultiGet a m) => MonadMultiState a m
mSet :: MonadMultiState a m => a -> m ()
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)


-- | The multi-valued version of mtl's Reader / ReaderT
module Control.Monad.Trans.MultiReader.Lazy

-- | A Reader transformer monad patameterized by:
--   
--   <ul>
--   <li>x - The list of types constituting the environment / input (to be
--   read),</li>
--   <li>m - The inner monad.</li>
--   </ul>
--   
--   <a>MultiReaderT</a> corresponds to mtl's <a>ReaderT</a>, but can
--   contain a heterogenous list of types.
--   
--   This heterogenous list is represented using Types.Data.List, i.e:
--   
--   <ul>
--   <li><tt>'[]</tt> - The empty list,</li>
--   <li><tt>a ': b</tt> - A list where <tt><i>a</i></tt> is an arbitrary
--   type and <tt><i>b</i></tt> is the rest list.</li>
--   </ul>
--   
--   For example,
--   
--   <pre>
--   MultiReaderT '[Int, Bool] :: (* -&gt; *) -&gt; (* -&gt; *)
--   </pre>
--   
--   is a Reader transformer containing the types [Int, Bool].
newtype MultiReaderT x m a
MultiReaderT :: StateT (HList x) m a -> MultiReaderT x m a
[runMultiReaderTRaw] :: MultiReaderT x m a -> StateT (HList x) m a

-- | A MultiReader transformer carrying an empty state.
type MultiReaderTNull = MultiReaderT '[]

-- | A reader monad parameterized by the list of types x of the environment
--   / input to carry.
--   
--   Similar to <tt>Reader r = ReaderT r Identity</tt>
type MultiReader x = MultiReaderT x Identity

-- | All methods must be defined.
--   
--   The idea is: Any monad stack is instance of <tt>MonadMultiReader
--   a</tt>, iff the stack contains a <tt>MultiReaderT x</tt> with <i>a</i>
--   element of <i>x</i>.
class (Monad m) => MonadMultiReader a m
mAsk :: MonadMultiReader a m => m a

-- | In contrast to MonadMultiReader, MonadMultiGet is defined for State
--   too, so it corresponds to read-access of any kind.
--   
--   Note however that for MultiRWS, only the values from the
--   <tt>state</tt> part can be accessed via <tt>MonadMultiGet</tt>, due to
--   limitations of the design of <tt>MultiRWS</tt> and of the type system.
--   This is issue is resolved in the <tt>MultiGST</tt> type.
class (Monad m) => MonadMultiGet a m
mGet :: MonadMultiGet a m => m a
runMultiReaderT :: Monad m => HList r -> MultiReaderT r m a -> m a
runMultiReaderT_ :: Functor m => HList r -> MultiReaderT r m a -> m ()
runMultiReaderTNil :: Monad m => MultiReaderT '[] m a -> m a
runMultiReaderTNil_ :: Functor m => MultiReaderT '[] m a -> m ()
withMultiReader :: Monad m => r -> MultiReaderT (r : rs) m a -> MultiReaderT rs m a
withMultiReader_ :: (Functor m, Monad m) => r -> MultiReaderT (r : rs) m a -> MultiReaderT rs m ()
withMultiReaders :: Monad m => HList r1 -> MultiReaderT (Append r1 r2) m a -> MultiReaderT r2 m a
withMultiReaders_ :: (Functor m, Monad m) => HList r1 -> MultiReaderT (Append r1 r2) m a -> MultiReaderT r2 m ()
withoutMultiReader :: Monad m => MultiReaderT rs m a -> MultiReaderT (r : rs) m a
inflateReader :: (Monad m, ContainsType r rs) => ReaderT r m a -> MultiReaderT rs m a

-- | Map both the return value and the environment of a computation using
--   the given function.
--   
--   Note that there is a difference to mtl's ReaderT, where it is
--   <i>not</i> possible to modify the environment.
mapMultiReaderT :: (m (a, HList w) -> m' (a', HList w)) -> MultiReaderT w m a -> MultiReaderT w m' a'

-- | A raw extractor of the contained HList (i.e. the complete Reader).
mGetRaw :: Monad m => MultiReaderT a m (HList a)
mPutRaw :: Monad m => HList s -> MultiReaderT s m ()
instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT x f)
instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT x m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT x m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT x)
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)
instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a c) => Control.Monad.Trans.MultiGet.Class.MonadMultiGet a (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT r m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT r m)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT r)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT r m)


-- | The multi-valued version of mtl's Reader / ReaderT / MonadReader
module Control.Monad.Trans.MultiReader

-- | A Reader transformer monad patameterized by:
--   
--   <ul>
--   <li>x - The list of types constituting the environment / input (to be
--   read),</li>
--   <li>m - The inner monad.</li>
--   </ul>
--   
--   <a>MultiReaderT</a> corresponds to mtl's <a>ReaderT</a>, but can
--   contain a heterogenous list of types.
--   
--   This heterogenous list is represented using Types.Data.List, i.e:
--   
--   <ul>
--   <li><tt>'[]</tt> - The empty list,</li>
--   <li><tt>a ': b</tt> - A list where <tt><i>a</i></tt> is an arbitrary
--   type and <tt><i>b</i></tt> is the rest list.</li>
--   </ul>
--   
--   For example,
--   
--   <pre>
--   MultiReaderT '[Int, Bool] :: (* -&gt; *) -&gt; (* -&gt; *)
--   </pre>
--   
--   is a Reader transformer containing the types [Int, Bool].
newtype MultiReaderT x m a
MultiReaderT :: StateT (HList x) m a -> MultiReaderT x m a
[runMultiReaderTRaw] :: MultiReaderT x m a -> StateT (HList x) m a

-- | A MultiReader transformer carrying an empty state.
type MultiReaderTNull = MultiReaderT '[]

-- | A reader monad parameterized by the list of types x of the environment
--   / input to carry.
--   
--   Similar to <tt>Reader r = ReaderT r Identity</tt>
type MultiReader x = MultiReaderT x Identity

-- | All methods must be defined.
--   
--   The idea is: Any monad stack is instance of <tt>MonadMultiReader
--   a</tt>, iff the stack contains a <tt>MultiReaderT x</tt> with <i>a</i>
--   element of <i>x</i>.
class (Monad m) => MonadMultiReader a m
mAsk :: MonadMultiReader a m => m a
runMultiReaderT :: Monad m => HList r -> MultiReaderT r m a -> m a
runMultiReaderT_ :: Functor m => HList r -> MultiReaderT r m a -> m ()
runMultiReaderTNil :: Monad m => MultiReaderT '[] m a -> m a
runMultiReaderTNil_ :: Functor m => MultiReaderT '[] m a -> m ()
withMultiReader :: Monad m => r -> MultiReaderT (r : rs) m a -> MultiReaderT rs m a
withMultiReader_ :: (Functor m, Monad m) => r -> MultiReaderT (r : rs) m a -> MultiReaderT rs m ()
withMultiReaders :: Monad m => HList r1 -> MultiReaderT (Append r1 r2) m a -> MultiReaderT r2 m a
withMultiReaders_ :: (Functor m, Monad m) => HList r1 -> MultiReaderT (Append r1 r2) m a -> MultiReaderT r2 m ()
withoutMultiReader :: Monad m => MultiReaderT rs m a -> MultiReaderT (r : rs) m a
inflateReader :: (Monad m, ContainsType r rs) => ReaderT r m a -> MultiReaderT rs m a

-- | Map both the return value and the environment of a computation using
--   the given function.
--   
--   Note that there is a difference to mtl's ReaderT, where it is
--   <i>not</i> possible to modify the environment.
mapMultiReaderT :: (m (a, HList w) -> m' (a', HList w)) -> MultiReaderT w m a -> MultiReaderT w m' a'

-- | A raw extractor of the contained HList (i.e. the complete Reader).
mGetRaw :: Monad m => MultiReaderT a m (HList a)
mPutRaw :: Monad m => HList s -> MultiReaderT s m ()


-- | The multi-valued version of mtl's Reader / ReaderT
module Control.Monad.Trans.MultiReader.Strict

-- | A Reader transformer monad patameterized by:
--   
--   <ul>
--   <li>x - The list of types constituting the environment / input (to be
--   read),</li>
--   <li>m - The inner monad.</li>
--   </ul>
--   
--   <a>MultiReaderT</a> corresponds to mtl's <a>ReaderT</a>, but can
--   contain a heterogenous list of types.
--   
--   This heterogenous list is represented using Types.Data.List, i.e:
--   
--   <ul>
--   <li><tt>'[]</tt> - The empty list,</li>
--   <li><tt>a ': b</tt> - A list where <tt><i>a</i></tt> is an arbitrary
--   type and <tt><i>b</i></tt> is the rest list.</li>
--   </ul>
--   
--   For example,
--   
--   <pre>
--   MultiReaderT '[Int, Bool] :: (* -&gt; *) -&gt; (* -&gt; *)
--   </pre>
--   
--   is a Reader transformer containing the types [Int, Bool].
newtype MultiReaderT x m a
MultiReaderT :: StateT (HList x) m a -> MultiReaderT x m a
[runMultiReaderTRaw] :: MultiReaderT x m a -> StateT (HList x) m a

-- | A MultiReader transformer carrying an empty state.
type MultiReaderTNull = MultiReaderT '[]

-- | A reader monad parameterized by the list of types x of the environment
--   / input to carry.
--   
--   Similar to <tt>Reader r = ReaderT r Identity</tt>
type MultiReader x = MultiReaderT x Identity

-- | All methods must be defined.
--   
--   The idea is: Any monad stack is instance of <tt>MonadMultiReader
--   a</tt>, iff the stack contains a <tt>MultiReaderT x</tt> with <i>a</i>
--   element of <i>x</i>.
class (Monad m) => MonadMultiReader a m
mAsk :: MonadMultiReader a m => m a

-- | In contrast to MonadMultiReader, MonadMultiGet is defined for State
--   too, so it corresponds to read-access of any kind.
--   
--   Note however that for MultiRWS, only the values from the
--   <tt>state</tt> part can be accessed via <tt>MonadMultiGet</tt>, due to
--   limitations of the design of <tt>MultiRWS</tt> and of the type system.
--   This is issue is resolved in the <tt>MultiGST</tt> type.
class (Monad m) => MonadMultiGet a m
mGet :: MonadMultiGet a m => m a
runMultiReaderT :: Monad m => HList r -> MultiReaderT r m a -> m a
runMultiReaderT_ :: Functor m => HList r -> MultiReaderT r m a -> m ()
runMultiReaderTNil :: Monad m => MultiReaderT '[] m a -> m a
runMultiReaderTNil_ :: Functor m => MultiReaderT '[] m a -> m ()
withMultiReader :: Monad m => r -> MultiReaderT (r : rs) m a -> MultiReaderT rs m a
withMultiReader_ :: (Functor m, Monad m) => r -> MultiReaderT (r : rs) m a -> MultiReaderT rs m ()
withMultiReaders :: Monad m => HList r1 -> MultiReaderT (Append r1 r2) m a -> MultiReaderT r2 m a
withMultiReaders_ :: (Functor m, Monad m) => HList r1 -> MultiReaderT (Append r1 r2) m a -> MultiReaderT r2 m ()
withoutMultiReader :: Monad m => MultiReaderT rs m a -> MultiReaderT (r : rs) m a
inflateReader :: (Monad m, ContainsType r rs) => ReaderT r m a -> MultiReaderT rs m a

-- | Map both the return value and the environment of a computation using
--   the given function.
--   
--   Note that there is a difference to mtl's ReaderT, where it is
--   <i>not</i> possible to modify the environment.
mapMultiReaderT :: (m (a, HList w) -> m' (a', HList w)) -> MultiReaderT w m a -> MultiReaderT w m' a'

-- | A raw extractor of the contained HList (i.e. the complete Reader).
mGetRaw :: Monad m => MultiReaderT a m (HList a)
mPutRaw :: Monad m => HList s -> MultiReaderT s m ()
instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiReader.Strict.MultiReaderT x f)
instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiReader.Strict.MultiReaderT x m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiReader.Strict.MultiReaderT x m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiReader.Strict.MultiReaderT x)
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)
instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a c) => Control.Monad.Trans.MultiGet.Class.MonadMultiGet a (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiReader.Strict.MultiReaderT r m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiReader.Strict.MultiReaderT r m)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiReader.Strict.MultiReaderT r)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiReader.Strict.MultiReaderT r m)


-- | The multi-valued version of mtl's State / StateT
module Control.Monad.Trans.MultiState.Lazy

-- | A State transformer monad patameterized by:
--   
--   <ul>
--   <li>x - The list of types constituting the state,</li>
--   <li>m - The inner monad.</li>
--   </ul>
--   
--   <a>MultiStateT</a> corresponds to mtl's <a>StateT</a>, but can contain
--   a heterogenous list of types.
--   
--   This heterogenous list is represented using Types.Data.List, i.e:
--   
--   <ul>
--   <li><tt>'[]</tt> - The empty list,</li>
--   <li><tt>a ': b</tt> - A list where <tt><i>a</i></tt> is an arbitrary
--   type and <tt><i>b</i></tt> is the rest list.</li>
--   </ul>
--   
--   For example,
--   
--   <pre>
--   MultiStateT '[Int, Bool] :: (* -&gt; *) -&gt; (* -&gt; *)
--   </pre>
--   
--   is a State wrapper containing the types [Int, Bool].
newtype MultiStateT x m a
MultiStateT :: StateT (HList x) m a -> MultiStateT x m a
[runMultiStateTRaw] :: MultiStateT x m a -> StateT (HList x) m a

-- | A MultiState transformer carrying an empty state.
type MultiStateTNull = MultiStateT '[]

-- | A state monad parameterized by the list of types x of the state to
--   carry.
--   
--   Similar to <tt>State s = StateT s Identity</tt>
type MultiState x = MultiStateT x Identity

-- | In contrast to MonadMultiReader, MonadMultiGet is defined for State
--   too, so it corresponds to read-access of any kind.
--   
--   Note however that for MultiRWS, only the values from the
--   <tt>state</tt> part can be accessed via <tt>MonadMultiGet</tt>, due to
--   limitations of the design of <tt>MultiRWS</tt> and of the type system.
--   This is issue is resolved in the <tt>MultiGST</tt> type.
class (Monad m) => MonadMultiGet a m
mGet :: MonadMultiGet a m => m a
class (MonadMultiGet a m) => MonadMultiState a m
mSet :: MonadMultiState a m => a -> m ()
runMultiStateT :: Functor m => HList s -> MultiStateT s m a -> m (a, HList s)
runMultiStateTAS :: Functor m => HList s -> MultiStateT s m a -> m (a, HList s)
runMultiStateTSA :: Monad m => HList s -> MultiStateT s m a -> m (HList s, a)
runMultiStateTA :: Monad m => HList s -> MultiStateT s m a -> m a
runMultiStateTS :: Monad m => HList s -> MultiStateT s m a -> m (HList s)
runMultiStateT_ :: Functor m => HList s -> MultiStateT s m a -> m ()
runMultiStateTNil :: Monad m => MultiStateT '[] m a -> m a
runMultiStateTNil_ :: Functor m => MultiStateT '[] m a -> m ()
withMultiState :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m (a, s)
withMultiStateAS :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m (a, s)
withMultiStateSA :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m (s, a)
withMultiStateA :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m a
withMultiStateS :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m s
withMultiState_ :: (Functor m, Monad m) => s -> MultiStateT (s : ss) m a -> MultiStateT ss m ()
withMultiStates :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)
withMultiStatesAS :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)
withMultiStatesSA :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1, a)
withMultiStatesA :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m a
withMultiStatesS :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1)
withMultiStates_ :: (Functor m, Monad m) => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m ()
withoutMultiState :: (Functor m, Monad m) => MultiStateT ss m a -> MultiStateT (s : ss) m a
inflateState :: (Monad m, ContainsType s ss) => StateT s m a -> MultiStateT ss m a
inflateReader :: (Monad m, ContainsType r ss) => ReaderT r m a -> MultiStateT ss m a
inflateWriter :: (Monad m, ContainsType w ss, Monoid w) => WriterT w m a -> MultiStateT ss m a

-- | Map both the return value and the state of a computation using the
--   given function.
mapMultiStateT :: (m (a, HList w) -> m' (a', HList w)) -> MultiStateT w m a -> MultiStateT w m' a'

-- | A raw extractor of the contained HList (i.e. the complete state).
mGetRaw :: Monad m => MultiStateT a m (HList a)
mPutRaw :: Monad m => HList s -> MultiStateT s m ()
instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiState.Lazy.MultiStateT x f)
instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiState.Lazy.MultiStateT x m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiState.Lazy.MultiStateT x m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiState.Lazy.MultiStateT x)
instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a c) => Control.Monad.Trans.MultiGet.Class.MonadMultiGet a (Control.Monad.Trans.MultiState.Lazy.MultiStateT c m)
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)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiState.Lazy.MultiStateT s m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.MultiState.Lazy.MultiStateT c m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiState.Lazy.MultiStateT c m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiState.Lazy.MultiStateT c m)
instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiState.Lazy.MultiStateT s m)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiState.Lazy.MultiStateT s m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiState.Lazy.MultiStateT s m)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiState.Lazy.MultiStateT s)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiState.Lazy.MultiStateT s m)


-- | The multi-valued version of mtl's RWS / RWST
module Control.Monad.Trans.MultiRWS.Lazy
newtype MultiRWST r w s m a
MultiRWST :: StateT (HList r, HList w, HList s) m a -> MultiRWST r w s m a
[runMultiRWSTRaw] :: MultiRWST r w s m a -> StateT (HList r, HList w, HList s) m a
type MultiRWSTNull = MultiRWST '[] '[] '[]
type MultiRWS r w s = MultiRWST r w s Identity

-- | All methods must be defined.
--   
--   The idea is: Any monad stack is instance of <tt>MonadMultiReader
--   a</tt>, iff the stack contains a <tt>MultiReaderT x</tt> with <i>a</i>
--   element of <i>x</i>.
class (Monad m) => MonadMultiReader a m
mAsk :: MonadMultiReader a m => m a
class (Monad m, Monoid a) => MonadMultiWriter a m
mTell :: MonadMultiWriter a m => a -> m ()

-- | In contrast to MonadMultiReader, MonadMultiGet is defined for State
--   too, so it corresponds to read-access of any kind.
--   
--   Note however that for MultiRWS, only the values from the
--   <tt>state</tt> part can be accessed via <tt>MonadMultiGet</tt>, due to
--   limitations of the design of <tt>MultiRWS</tt> and of the type system.
--   This is issue is resolved in the <tt>MultiGST</tt> type.
class (Monad m) => MonadMultiGet a m
mGet :: MonadMultiGet a m => m a
class (MonadMultiGet a m) => MonadMultiState a m
mSet :: MonadMultiState a m => a -> m ()
runMultiRWST :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)
runMultiRWSTASW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)
runMultiRWSTW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList w)
runMultiRWSTAW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList w)
runMultiRWSTSW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList s, HList w)
runMultiRWSTNil :: (Monad m) => MultiRWST '[] '[] '[] m a -> m a
runMultiRWSTNil_ :: (Monad m, Functor m) => MultiRWST '[] '[] '[] m a -> m ()
withMultiReader :: Monad m => r -> MultiRWST (r : rs) w s m a -> MultiRWST rs w s m a
withMultiReader_ :: (Functor m, Monad m) => r -> MultiRWST (r : rs) w s m a -> MultiRWST rs w s m ()
withMultiReaders :: Monad m => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m a
withMultiReaders_ :: (Functor m, Monad m) => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m ()
withMultiWriter :: (Monoid w, Monad m) => MultiRWST r (w : ws) s m a -> MultiRWST r ws s m (a, w)
withMultiWriterAW :: (Monoid w, Monad m) => MultiRWST r (w : ws) s m a -> MultiRWST r ws s m (a, w)
withMultiWriterWA :: (Monoid w, Monad m) => MultiRWST r (w : ws) s m a -> MultiRWST r ws s m (w, a)
withMultiWriterW :: (Monoid w, Monad m) => MultiRWST r (w : ws) s m a -> MultiRWST r ws s m w
withMultiWriters :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (a, HList w1)
withMultiWritersAW :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (a, HList w1)
withMultiWritersWA :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (HList w1, a)
withMultiWritersW :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (HList w1)
withMultiState :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m (a, s)
withMultiStateAS :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m (a, s)
withMultiStateSA :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m (s, a)
withMultiStateA :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m a
withMultiStateS :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m s
withMultiState_ :: (Functor m, Monad m) => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m ()
withMultiStates :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)
withMultiStatesAS :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)
withMultiStatesSA :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1, a)
withMultiStatesA :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m a
withMultiStatesS :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1)
withMultiStates_ :: (Functor m, Monad m) => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m ()
withoutMultiReader :: Monad m => MultiRWST rs w s m a -> MultiRWST (r : rs) w s m a
withoutMultiState :: Monad m => MultiRWST r w ss m a -> MultiRWST r w (s : ss) m a
inflateReader :: (Monad m, ContainsType r rs) => ReaderT r m a -> MultiRWST rs w s m a
inflateMultiReader :: Monad m => MultiReaderT r m a -> MultiRWST r w s m a
inflateWriter :: (Monad m, ContainsType w ws, Monoid w) => WriterT w m a -> MultiRWST r ws s m a
inflateMultiWriter :: (Functor m, Monad m, Monoid (HList w)) => MultiWriterT w m a -> MultiRWST r w s m a
inflateState :: (Monad m, MonadMultiState s (t m), MonadTrans t) => StateT s m a -> t m a
inflateMultiState :: (Functor m, Monad m) => MultiStateT s m a -> MultiRWST r w s m a
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'
mGetRawR :: Monad m => MultiRWST r w s m (HList r)
mGetRawW :: Monad m => MultiRWST r w s m (HList w)
mGetRawS :: Monad m => MultiRWST r w s m (HList s)
mPutRawR :: Monad m => HList r -> MultiRWST r w s m ()
mPutRawW :: Monad m => HList w -> MultiRWST r w s m ()
mPutRawS :: Monad m => HList s -> MultiRWST r w s m ()
instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s f)
instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s)
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)
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)
instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a s) => Control.Monad.Trans.MultiGet.Class.MonadMultiGet a (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
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)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
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)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)


-- | The multi-valued version of mtl's RWS / RWST
module Control.Monad.Trans.MultiRWS
newtype MultiRWST r w s m a
MultiRWST :: StateT (HList r, HList w, HList s) m a -> MultiRWST r w s m a
[runMultiRWSTRaw] :: MultiRWST r w s m a -> StateT (HList r, HList w, HList s) m a
type MultiRWSTNull = MultiRWST '[] '[] '[]
type MultiRWS r w s = MultiRWST r w s Identity

-- | All methods must be defined.
--   
--   The idea is: Any monad stack is instance of <tt>MonadMultiReader
--   a</tt>, iff the stack contains a <tt>MultiReaderT x</tt> with <i>a</i>
--   element of <i>x</i>.
class (Monad m) => MonadMultiReader a m
mAsk :: MonadMultiReader a m => m a
class (Monad m, Monoid a) => MonadMultiWriter a m
mTell :: MonadMultiWriter a m => a -> m ()

-- | In contrast to MonadMultiReader, MonadMultiGet is defined for State
--   too, so it corresponds to read-access of any kind.
--   
--   Note however that for MultiRWS, only the values from the
--   <tt>state</tt> part can be accessed via <tt>MonadMultiGet</tt>, due to
--   limitations of the design of <tt>MultiRWS</tt> and of the type system.
--   This is issue is resolved in the <tt>MultiGST</tt> type.
class (Monad m) => MonadMultiGet a m
mGet :: MonadMultiGet a m => m a
class (MonadMultiGet a m) => MonadMultiState a m
mSet :: MonadMultiState a m => a -> m ()
runMultiRWST :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)
runMultiRWSTASW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)
runMultiRWSTW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList w)
runMultiRWSTAW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList w)
runMultiRWSTSW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList s, HList w)
runMultiRWSTNil :: (Monad m) => MultiRWST '[] '[] '[] m a -> m a
runMultiRWSTNil_ :: (Monad m, Functor m) => MultiRWST '[] '[] '[] m a -> m ()
withMultiReader :: Monad m => r -> MultiRWST (r : rs) w s m a -> MultiRWST rs w s m a
withMultiReader_ :: (Functor m, Monad m) => r -> MultiRWST (r : rs) w s m a -> MultiRWST rs w s m ()
withMultiReaders :: Monad m => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m a
withMultiReaders_ :: (Functor m, Monad m) => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m ()
withMultiWriter :: (Monoid w, Monad m) => MultiRWST r (w : ws) s m a -> MultiRWST r ws s m (a, w)
withMultiWriterAW :: (Monoid w, Monad m) => MultiRWST r (w : ws) s m a -> MultiRWST r ws s m (a, w)
withMultiWriterWA :: (Monoid w, Monad m) => MultiRWST r (w : ws) s m a -> MultiRWST r ws s m (w, a)
withMultiWriterW :: (Monoid w, Monad m) => MultiRWST r (w : ws) s m a -> MultiRWST r ws s m w
withMultiWriters :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (a, HList w1)
withMultiWritersAW :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (a, HList w1)
withMultiWritersWA :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (HList w1, a)
withMultiWritersW :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (HList w1)
withMultiState :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m (a, s)
withMultiStateAS :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m (a, s)
withMultiStateSA :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m (s, a)
withMultiStateA :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m a
withMultiStateS :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m s
withMultiState_ :: (Functor m, Monad m) => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m ()
withMultiStates :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)
withMultiStatesAS :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)
withMultiStatesSA :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1, a)
withMultiStatesA :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m a
withMultiStatesS :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1)
withMultiStates_ :: (Functor m, Monad m) => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m ()
withoutMultiReader :: Monad m => MultiRWST rs w s m a -> MultiRWST (r : rs) w s m a
withoutMultiState :: Monad m => MultiRWST r w ss m a -> MultiRWST r w (s : ss) m a
inflateReader :: (Monad m, ContainsType r rs) => ReaderT r m a -> MultiRWST rs w s m a
inflateMultiReader :: Monad m => MultiReaderT r m a -> MultiRWST r w s m a
inflateWriter :: (Monad m, ContainsType w ws, Monoid w) => WriterT w m a -> MultiRWST r ws s m a
inflateMultiWriter :: (Functor m, Monad m, Monoid (HList w)) => MultiWriterT w m a -> MultiRWST r w s m a
inflateState :: (Monad m, MonadMultiState s (t m), MonadTrans t) => StateT s m a -> t m a
inflateMultiState :: (Functor m, Monad m) => MultiStateT s m a -> MultiRWST r w s m a
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'
mGetRawR :: Monad m => MultiRWST r w s m (HList r)
mGetRawW :: Monad m => MultiRWST r w s m (HList w)
mGetRawS :: Monad m => MultiRWST r w s m (HList s)
mPutRawR :: Monad m => HList r -> MultiRWST r w s m ()
mPutRawW :: Monad m => HList w -> MultiRWST r w s m ()
mPutRawS :: Monad m => HList s -> MultiRWST r w s m ()


-- | The multi-valued version of mtl's State / StateT / MonadState
module Control.Monad.Trans.MultiState

-- | A State transformer monad patameterized by:
--   
--   <ul>
--   <li>x - The list of types constituting the state,</li>
--   <li>m - The inner monad.</li>
--   </ul>
--   
--   <a>MultiStateT</a> corresponds to mtl's <a>StateT</a>, but can contain
--   a heterogenous list of types.
--   
--   This heterogenous list is represented using Types.Data.List, i.e:
--   
--   <ul>
--   <li><tt>'[]</tt> - The empty list,</li>
--   <li><tt>a ': b</tt> - A list where <tt><i>a</i></tt> is an arbitrary
--   type and <tt><i>b</i></tt> is the rest list.</li>
--   </ul>
--   
--   For example,
--   
--   <pre>
--   MultiStateT '[Int, Bool] :: (* -&gt; *) -&gt; (* -&gt; *)
--   </pre>
--   
--   is a State wrapper containing the types [Int, Bool].
newtype MultiStateT x m a
MultiStateT :: StateT (HList x) m a -> MultiStateT x m a
[runMultiStateTRaw] :: MultiStateT x m a -> StateT (HList x) m a

-- | A MultiState transformer carrying an empty state.
type MultiStateTNull = MultiStateT '[]

-- | A state monad parameterized by the list of types x of the state to
--   carry.
--   
--   Similar to <tt>State s = StateT s Identity</tt>
type MultiState x = MultiStateT x Identity

-- | In contrast to MonadMultiReader, MonadMultiGet is defined for State
--   too, so it corresponds to read-access of any kind.
--   
--   Note however that for MultiRWS, only the values from the
--   <tt>state</tt> part can be accessed via <tt>MonadMultiGet</tt>, due to
--   limitations of the design of <tt>MultiRWS</tt> and of the type system.
--   This is issue is resolved in the <tt>MultiGST</tt> type.
class (Monad m) => MonadMultiGet a m
mGet :: MonadMultiGet a m => m a
class (MonadMultiGet a m) => MonadMultiState a m
mSet :: MonadMultiState a m => a -> m ()
runMultiStateT :: Functor m => HList s -> MultiStateT s m a -> m (a, HList s)
runMultiStateTAS :: Functor m => HList s -> MultiStateT s m a -> m (a, HList s)
runMultiStateTSA :: Monad m => HList s -> MultiStateT s m a -> m (HList s, a)
runMultiStateTA :: Monad m => HList s -> MultiStateT s m a -> m a
runMultiStateTS :: Monad m => HList s -> MultiStateT s m a -> m (HList s)
runMultiStateT_ :: Functor m => HList s -> MultiStateT s m a -> m ()
runMultiStateTNil :: Monad m => MultiStateT '[] m a -> m a
runMultiStateTNil_ :: Functor m => MultiStateT '[] m a -> m ()
withMultiState :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m (a, s)
withMultiStateAS :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m (a, s)
withMultiStateSA :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m (s, a)
withMultiStateA :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m a
withMultiStateS :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m s
withMultiState_ :: (Functor m, Monad m) => s -> MultiStateT (s : ss) m a -> MultiStateT ss m ()
withMultiStates :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)
withMultiStatesAS :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)
withMultiStatesSA :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1, a)
withMultiStatesA :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m a
withMultiStatesS :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1)
withMultiStates_ :: (Functor m, Monad m) => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m ()
withoutMultiState :: (Functor m, Monad m) => MultiStateT ss m a -> MultiStateT (s : ss) m a
inflateState :: (Monad m, ContainsType s ss) => StateT s m a -> MultiStateT ss m a
inflateReader :: (Monad m, ContainsType r ss) => ReaderT r m a -> MultiStateT ss m a
inflateWriter :: (Monad m, ContainsType w ss, Monoid w) => WriterT w m a -> MultiStateT ss m a

-- | Map both the return value and the state of a computation using the
--   given function.
mapMultiStateT :: (m (a, HList w) -> m' (a', HList w)) -> MultiStateT w m a -> MultiStateT w m' a'

-- | A raw extractor of the contained HList (i.e. the complete state).
mGetRaw :: Monad m => MultiStateT a m (HList a)
mPutRaw :: Monad m => HList s -> MultiStateT s m ()


-- | The multi-valued version of mtl's State / StateT
module Control.Monad.Trans.MultiState.Strict

-- | A State transformer monad patameterized by:
--   
--   <ul>
--   <li>x - The list of types constituting the state,</li>
--   <li>m - The inner monad.</li>
--   </ul>
--   
--   <a>MultiStateT</a> corresponds to mtl's <a>StateT</a>, but can contain
--   a heterogenous list of types.
--   
--   This heterogenous list is represented using Types.Data.List, i.e:
--   
--   <ul>
--   <li><tt>'[]</tt> - The empty list,</li>
--   <li><tt>a ': b</tt> - A list where <tt><i>a</i></tt> is an arbitrary
--   type and <tt><i>b</i></tt> is the rest list.</li>
--   </ul>
--   
--   For example,
--   
--   <pre>
--   MultiStateT '[Int, Bool] :: (* -&gt; *) -&gt; (* -&gt; *)
--   </pre>
--   
--   is a State wrapper containing the types [Int, Bool].
newtype MultiStateT x m a
MultiStateT :: StateT (HList x) m a -> MultiStateT x m a
[runMultiStateTRaw] :: MultiStateT x m a -> StateT (HList x) m a

-- | A MultiState transformer carrying an empty state.
type MultiStateTNull = MultiStateT '[]

-- | A state monad parameterized by the list of types x of the state to
--   carry.
--   
--   Similar to <tt>State s = StateT s Identity</tt>
type MultiState x = MultiStateT x Identity

-- | In contrast to MonadMultiReader, MonadMultiGet is defined for State
--   too, so it corresponds to read-access of any kind.
--   
--   Note however that for MultiRWS, only the values from the
--   <tt>state</tt> part can be accessed via <tt>MonadMultiGet</tt>, due to
--   limitations of the design of <tt>MultiRWS</tt> and of the type system.
--   This is issue is resolved in the <tt>MultiGST</tt> type.
class (Monad m) => MonadMultiGet a m
mGet :: MonadMultiGet a m => m a
class (MonadMultiGet a m) => MonadMultiState a m
mSet :: MonadMultiState a m => a -> m ()
runMultiStateT :: Functor m => HList s -> MultiStateT s m a -> m (a, HList s)
runMultiStateTAS :: Functor m => HList s -> MultiStateT s m a -> m (a, HList s)
runMultiStateTSA :: Monad m => HList s -> MultiStateT s m a -> m (HList s, a)
runMultiStateTA :: Monad m => HList s -> MultiStateT s m a -> m a
runMultiStateTS :: Monad m => HList s -> MultiStateT s m a -> m (HList s)
runMultiStateT_ :: Functor m => HList s -> MultiStateT s m a -> m ()
runMultiStateTNil :: Monad m => MultiStateT '[] m a -> m a
runMultiStateTNil_ :: Functor m => MultiStateT '[] m a -> m ()
withMultiState :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m (a, s)
withMultiStateAS :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m (a, s)
withMultiStateSA :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m (s, a)
withMultiStateA :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m a
withMultiStateS :: Monad m => s -> MultiStateT (s : ss) m a -> MultiStateT ss m s
withMultiState_ :: (Functor m, Monad m) => s -> MultiStateT (s : ss) m a -> MultiStateT ss m ()
withMultiStates :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)
withMultiStatesAS :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)
withMultiStatesSA :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1, a)
withMultiStatesA :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m a
withMultiStatesS :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1)
withMultiStates_ :: (Functor m, Monad m) => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m ()
withoutMultiState :: (Functor m, Monad m) => MultiStateT ss m a -> MultiStateT (s : ss) m a
inflateState :: (Monad m, ContainsType s ss) => StateT s m a -> MultiStateT ss m a
inflateReader :: (Monad m, ContainsType r ss) => ReaderT r m a -> MultiStateT ss m a
inflateWriter :: (Monad m, ContainsType w ss, Monoid w) => WriterT w m a -> MultiStateT ss m a

-- | Map both the return value and the state of a computation using the
--   given function.
mapMultiStateT :: (m (a, HList w) -> m' (a', HList w)) -> MultiStateT w m a -> MultiStateT w m' a'

-- | A raw extractor of the contained HList (i.e. the complete state).
mGetRaw :: Monad m => MultiStateT a m (HList a)
mPutRaw :: Monad m => HList s -> MultiStateT s m ()
instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiState.Strict.MultiStateT x f)
instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiState.Strict.MultiStateT x m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiState.Strict.MultiStateT x m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiState.Strict.MultiStateT x)
instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a c) => Control.Monad.Trans.MultiGet.Class.MonadMultiGet a (Control.Monad.Trans.MultiState.Strict.MultiStateT c m)
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)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiState.Strict.MultiStateT s m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.MultiState.Strict.MultiStateT c m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiState.Strict.MultiStateT c m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiState.Strict.MultiStateT c m)
instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.MultiState.Strict.MultiStateT s m)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiState.Strict.MultiStateT s m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiState.Strict.MultiStateT s m)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiState.Strict.MultiStateT s)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiState.Strict.MultiStateT s m)


-- | The multi-valued version of mtl's RWS / RWST
module Control.Monad.Trans.MultiRWS.Strict
newtype MultiRWST r w s m a
MultiRWST :: StateT (HList r, HList w, HList s) m a -> MultiRWST r w s m a
[runMultiRWSTRaw] :: MultiRWST r w s m a -> StateT (HList r, HList w, HList s) m a
type MultiRWSTNull = MultiRWST '[] '[] '[]
type MultiRWS r w s = MultiRWST r w s Identity

-- | All methods must be defined.
--   
--   The idea is: Any monad stack is instance of <tt>MonadMultiReader
--   a</tt>, iff the stack contains a <tt>MultiReaderT x</tt> with <i>a</i>
--   element of <i>x</i>.
class (Monad m) => MonadMultiReader a m
mAsk :: MonadMultiReader a m => m a
class (Monad m, Monoid a) => MonadMultiWriter a m
mTell :: MonadMultiWriter a m => a -> m ()

-- | In contrast to MonadMultiReader, MonadMultiGet is defined for State
--   too, so it corresponds to read-access of any kind.
--   
--   Note however that for MultiRWS, only the values from the
--   <tt>state</tt> part can be accessed via <tt>MonadMultiGet</tt>, due to
--   limitations of the design of <tt>MultiRWS</tt> and of the type system.
--   This is issue is resolved in the <tt>MultiGST</tt> type.
class (Monad m) => MonadMultiGet a m
mGet :: MonadMultiGet a m => m a
class (MonadMultiGet a m) => MonadMultiState a m
mSet :: MonadMultiState a m => a -> m ()
runMultiRWST :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)
runMultiRWSTASW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)
runMultiRWSTW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList w)
runMultiRWSTAW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList w)
runMultiRWSTSW :: (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList s, HList w)
runMultiRWSTNil :: (Monad m) => MultiRWST '[] '[] '[] m a -> m a
runMultiRWSTNil_ :: (Monad m, Functor m) => MultiRWST '[] '[] '[] m a -> m ()
withMultiReader :: Monad m => r -> MultiRWST (r : rs) w s m a -> MultiRWST rs w s m a
withMultiReader_ :: (Functor m, Monad m) => r -> MultiRWST (r : rs) w s m a -> MultiRWST rs w s m ()
withMultiReaders :: Monad m => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m a
withMultiReaders_ :: (Functor m, Monad m) => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m ()
withMultiWriter :: (Monoid w, Monad m) => MultiRWST r (w : ws) s m a -> MultiRWST r ws s m (a, w)
withMultiWriterAW :: (Monoid w, Monad m) => MultiRWST r (w : ws) s m a -> MultiRWST r ws s m (a, w)
withMultiWriterWA :: (Monoid w, Monad m) => MultiRWST r (w : ws) s m a -> MultiRWST r ws s m (w, a)
withMultiWriterW :: (Monoid w, Monad m) => MultiRWST r (w : ws) s m a -> MultiRWST r ws s m w
withMultiWriters :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (a, HList w1)
withMultiWritersAW :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (a, HList w1)
withMultiWritersWA :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (HList w1, a)
withMultiWritersW :: forall r w1 w2 s m a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (HList w1)
withMultiState :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m (a, s)
withMultiStateAS :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m (a, s)
withMultiStateSA :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m (s, a)
withMultiStateA :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m a
withMultiStateS :: Monad m => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m s
withMultiState_ :: (Functor m, Monad m) => s -> MultiRWST r w (s : ss) m a -> MultiRWST r w ss m ()
withMultiStates :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)
withMultiStatesAS :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)
withMultiStatesSA :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1, a)
withMultiStatesA :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m a
withMultiStatesS :: Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1)
withMultiStates_ :: (Functor m, Monad m) => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m ()
withoutMultiReader :: Monad m => MultiRWST rs w s m a -> MultiRWST (r : rs) w s m a
withoutMultiState :: Monad m => MultiRWST r w ss m a -> MultiRWST r w (s : ss) m a
inflateReader :: (Monad m, ContainsType r rs) => ReaderT r m a -> MultiRWST rs w s m a
inflateMultiReader :: Monad m => MultiReaderT r m a -> MultiRWST r w s m a
inflateWriter :: (Monad m, ContainsType w ws, Monoid w) => WriterT w m a -> MultiRWST r ws s m a
inflateMultiWriter :: (Functor m, Monad m, Monoid (HList w)) => MultiWriterT w m a -> MultiRWST r w s m a
inflateState :: (Monad m, MonadTrans t, MonadMultiState s (t m)) => StateT s m a -> t m a
inflateMultiState :: (Functor m, Monad m) => MultiStateT s m a -> MultiRWST r w s m a
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'
mGetRawR :: Monad m => MultiRWST r w s m (HList r)
mGetRawW :: Monad m => MultiRWST r w s m (HList w)
mGetRawS :: Monad m => MultiRWST r w s m (HList s)
mPutRawR :: Monad m => HList r -> MultiRWST r w s m ()
mPutRawW :: Monad m => HList w -> MultiRWST r w s m ()
mPutRawS :: Monad m => HList s -> MultiRWST r w s m ()
instance GHC.Base.Functor f => GHC.Base.Functor (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s f)
instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s)
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)
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)
instance (GHC.Base.Monad m, Data.HList.ContainsType.ContainsType a s) => Control.Monad.Trans.MultiGet.Class.MonadMultiGet a (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
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)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
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)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)


-- | Alternative multi-valued version of mtl's RWS / RWST. In contrast to
--   <tt><tt>MultiRWS</tt>(T)</tt> this version only takes a single list of
--   types as parameter, but with additional encoding of the allowed access
--   for each element. This supports the <tt><a>MonadMultiGet</a></tt>
--   notion more succinctly, i.e. to pass a "state" element to a function
--   that only requires<i>expects read</i>get access. This is not possible
--   with <tt>MultiRWS</tt>.
module Control.Monad.Trans.MultiGST.Lazy
newtype MultiGSTT ts m a
MultiGSTT :: StateT (HListM ts) m a -> MultiGSTT ts m a
[runMultiGSTTRaw] :: MultiGSTT ts m a -> StateT (HListM ts) m a
type MultiGSTTNull = MultiGSTT '[]
type MultiGST r = MultiGSTT r Identity
type ContainsReader = HListMContains GettableFlag
type ContainsState = HListMContains SettableFlag
type ContainsWriter = HListMContains TellableFlag

-- | All methods must be defined.
--   
--   The idea is: Any monad stack is instance of <tt>MonadMultiReader
--   a</tt>, iff the stack contains a <tt>MultiReaderT x</tt> with <i>a</i>
--   element of <i>x</i>.
class (Monad m) => MonadMultiReader a m
mAsk :: MonadMultiReader a m => m a
class (Monad m, Monoid a) => MonadMultiWriter a m
mTell :: MonadMultiWriter a m => a -> m ()

-- | In contrast to MonadMultiReader, MonadMultiGet is defined for State
--   too, so it corresponds to read-access of any kind.
--   
--   Note however that for MultiRWS, only the values from the
--   <tt>state</tt> part can be accessed via <tt>MonadMultiGet</tt>, due to
--   limitations of the design of <tt>MultiRWS</tt> and of the type system.
--   This is issue is resolved in the <tt>MultiGST</tt> type.
class (Monad m) => MonadMultiGet a m
mGet :: MonadMultiGet a m => m a
class (MonadMultiGet a m) => MonadMultiState a m
mSet :: MonadMultiState a m => a -> m ()
data CanReadWrite a
Gettable :: a -> CanReadWrite a
Settable :: a -> CanReadWrite a
Tellable :: a -> CanReadWrite a
runMultiGSTTNil :: Monad m => MultiGSTT '[] m a -> m a
runMultiGSTTNil_ :: Monad m => MultiGSTT '[] m a -> m ()
withReader :: Monad m => t -> MultiGSTT (Gettable t : tr) m a -> MultiGSTT tr m a
withReader_ :: Monad m => t -> MultiGSTT (Gettable t : tr) m a -> MultiGSTT tr m ()
withReaders :: Monad m => HList rs -> MultiGSTT (AppendM (HListMReaders rs) ts) m a -> MultiGSTT ts m a
withWriter :: (Monoid t, Monad m) => MultiGSTT (Tellable t : tr) m a -> MultiGSTT tr m (a, t)
withWriterAW :: (Monoid t, Monad m) => MultiGSTT (Tellable t : tr) m a -> MultiGSTT tr m (a, t)
withWriterWA :: (Monoid t, Monad m) => MultiGSTT (Tellable t : tr) m a -> MultiGSTT tr m (t, a)
withWriterW :: (Monoid t, Monad m) => MultiGSTT (Tellable t : tr) m a -> MultiGSTT tr m t
withState :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m (a, t)
withStateAS :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m (a, t)
withStateSA :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m (t, a)
withStateA :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m a
withStateS :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m t
withState_ :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m ()
without :: Monad m => MultiGSTT tr m a -> MultiGSTT (ct : tr) m a
mGetRaw :: Monad m => MultiGSTT ts m (HListM ts)
mSetRaw :: Monad m => HListM ts -> MultiGSTT ts m ()
mGetRawR :: (Monad m, HListMGettableClass ts) => MultiGSTT ts m (HList (HListMGettableOnly ts))
mapMultiGSTT :: (ts ~ HListM cts) => (m (a, ts) -> m' (a', ts)) -> MultiGSTT cts m a -> MultiGSTT cts m' a'
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT ts m)
instance GHC.Base.MonadPlus m => GHC.Base.Alternative (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT ts m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT ts m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT ts)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT ts m)
instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT ts m)
instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT ts m)
instance (GHC.Base.Monad m, Control.Monad.Trans.MultiGST.Common.HListMContains 'Control.Monad.Trans.MultiGST.Common.GettableFlag a cts) => Control.Monad.Trans.MultiGet.Class.MonadMultiGet a (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT cts m)
instance (GHC.Base.Monad m, Control.Monad.Trans.MultiGST.Common.HListMContains 'Control.Monad.Trans.MultiGST.Common.SettableFlag a cts) => Control.Monad.Trans.MultiState.Class.MonadMultiState a (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT cts m)
instance (GHC.Base.Monad m, GHC.Base.Monoid a, Control.Monad.Trans.MultiGST.Common.HListMContains 'Control.Monad.Trans.MultiGST.Common.TellableFlag a cts) => Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT cts m)


-- | Alternative multi-valued version of mtl's RWS / RWST. In contrast to
--   <tt><tt>MultiRWS</tt>(T)</tt> this version only takes a single list of
--   types as parameter, but with additional encoding of the allowed access
--   for each element. This supports the <tt><a>MonadMultiGet</a></tt>
--   notion more succinctly, i.e. to pass a "state" element to a function
--   that only requires<i>expects read</i>get access. This is not possible
--   with <tt>MultiRWS</tt>.
module Control.Monad.Trans.MultiGST.Strict
newtype MultiGSTT ts m a
MultiGSTT :: StateT (HListM ts) m a -> MultiGSTT ts m a
[runMultiGSTTRaw] :: MultiGSTT ts m a -> StateT (HListM ts) m a
type MultiGSTTNull = MultiGSTT '[]
type MultiGST r = MultiGSTT r Identity
type ContainsReader = HListMContains GettableFlag
type ContainsState = HListMContains SettableFlag
type ContainsWriter = HListMContains TellableFlag

-- | All methods must be defined.
--   
--   The idea is: Any monad stack is instance of <tt>MonadMultiReader
--   a</tt>, iff the stack contains a <tt>MultiReaderT x</tt> with <i>a</i>
--   element of <i>x</i>.
class (Monad m) => MonadMultiReader a m
mAsk :: MonadMultiReader a m => m a
class (Monad m, Monoid a) => MonadMultiWriter a m
mTell :: MonadMultiWriter a m => a -> m ()

-- | In contrast to MonadMultiReader, MonadMultiGet is defined for State
--   too, so it corresponds to read-access of any kind.
--   
--   Note however that for MultiRWS, only the values from the
--   <tt>state</tt> part can be accessed via <tt>MonadMultiGet</tt>, due to
--   limitations of the design of <tt>MultiRWS</tt> and of the type system.
--   This is issue is resolved in the <tt>MultiGST</tt> type.
class (Monad m) => MonadMultiGet a m
mGet :: MonadMultiGet a m => m a
data CanReadWrite a
Gettable :: a -> CanReadWrite a
Settable :: a -> CanReadWrite a
Tellable :: a -> CanReadWrite a
runMultiGSTTNil :: Monad m => MultiGSTT '[] m a -> m a
runMultiGSTTNil_ :: Monad m => MultiGSTT '[] m a -> m ()
withReader :: Monad m => t -> MultiGSTT (Gettable t : tr) m a -> MultiGSTT tr m a
withReader_ :: Monad m => t -> MultiGSTT (Gettable t : tr) m a -> MultiGSTT tr m ()
withWriter :: (Monoid t, Monad m) => MultiGSTT (Tellable t : tr) m a -> MultiGSTT tr m (a, t)
withWriterAW :: (Monoid t, Monad m) => MultiGSTT (Tellable t : tr) m a -> MultiGSTT tr m (a, t)
withWriterWA :: (Monoid t, Monad m) => MultiGSTT (Tellable t : tr) m a -> MultiGSTT tr m (t, a)
withWriterW :: (Monoid t, Monad m) => MultiGSTT (Tellable t : tr) m a -> MultiGSTT tr m t
withState :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m (a, t)
withStateAS :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m (a, t)
withStateSA :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m (t, a)
withStateA :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m a
withStateS :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m t
withState_ :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m ()
without :: Monad m => MultiGSTT tr m a -> MultiGSTT (ct : tr) m a
mGetRaw :: Monad m => MultiGSTT ts m (HListM ts)
mSetRaw :: Monad m => HListM ts -> MultiGSTT ts m ()
mapMultiGSTT :: (ts ~ HListM cts) => (m (a, ts) -> m' (a', ts)) -> MultiGSTT cts m a -> MultiGSTT cts m' a'
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiGST.Strict.MultiGSTT ts)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.MultiGST.Strict.MultiGSTT ts m)
instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Monad.Trans.MultiGST.Strict.MultiGSTT ts m)
instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.MultiGST.Strict.MultiGSTT ts m)
instance (GHC.Base.Monad m, Control.Monad.Trans.MultiGST.Common.HListMContains 'Control.Monad.Trans.MultiGST.Common.GettableFlag a cts) => Control.Monad.Trans.MultiGet.Class.MonadMultiGet a (Control.Monad.Trans.MultiGST.Strict.MultiGSTT cts m)
instance (GHC.Base.Monad m, Control.Monad.Trans.MultiGST.Common.HListMContains 'Control.Monad.Trans.MultiGST.Common.SettableFlag a cts) => Control.Monad.Trans.MultiState.Class.MonadMultiState a (Control.Monad.Trans.MultiGST.Strict.MultiGSTT cts m)
instance (GHC.Base.Monad m, GHC.Base.Monoid a, Control.Monad.Trans.MultiGST.Common.HListMContains 'Control.Monad.Trans.MultiGST.Common.TellableFlag a cts) => Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a (Control.Monad.Trans.MultiGST.Strict.MultiGSTT cts m)


-- | The multi-valued version of mtl's RWS / RWST
module Control.Monad.Trans.MultiGST
newtype MultiGSTT ts m a
MultiGSTT :: StateT (HListM ts) m a -> MultiGSTT ts m a
[runMultiGSTTRaw] :: MultiGSTT ts m a -> StateT (HListM ts) m a
type MultiGSTTNull = MultiGSTT '[]
type MultiGST r = MultiGSTT r Identity
type ContainsReader = HListMContains GettableFlag
type ContainsState = HListMContains SettableFlag
type ContainsWriter = HListMContains TellableFlag

-- | All methods must be defined.
--   
--   The idea is: Any monad stack is instance of <tt>MonadMultiReader
--   a</tt>, iff the stack contains a <tt>MultiReaderT x</tt> with <i>a</i>
--   element of <i>x</i>.
class (Monad m) => MonadMultiReader a m
mAsk :: MonadMultiReader a m => m a
class (Monad m, Monoid a) => MonadMultiWriter a m
mTell :: MonadMultiWriter a m => a -> m ()

-- | In contrast to MonadMultiReader, MonadMultiGet is defined for State
--   too, so it corresponds to read-access of any kind.
--   
--   Note however that for MultiRWS, only the values from the
--   <tt>state</tt> part can be accessed via <tt>MonadMultiGet</tt>, due to
--   limitations of the design of <tt>MultiRWS</tt> and of the type system.
--   This is issue is resolved in the <tt>MultiGST</tt> type.
class (Monad m) => MonadMultiGet a m
mGet :: MonadMultiGet a m => m a
data CanReadWrite a
Gettable :: a -> CanReadWrite a
Settable :: a -> CanReadWrite a
Tellable :: a -> CanReadWrite a
runMultiGSTTNil :: Monad m => MultiGSTT '[] m a -> m a
runMultiGSTTNil_ :: Monad m => MultiGSTT '[] m a -> m ()
withReader :: Monad m => t -> MultiGSTT (Gettable t : tr) m a -> MultiGSTT tr m a
withReader_ :: Monad m => t -> MultiGSTT (Gettable t : tr) m a -> MultiGSTT tr m ()
withReaders :: Monad m => HList rs -> MultiGSTT (AppendM (HListMReaders rs) ts) m a -> MultiGSTT ts m a
withWriter :: (Monoid t, Monad m) => MultiGSTT (Tellable t : tr) m a -> MultiGSTT tr m (a, t)
withWriterAW :: (Monoid t, Monad m) => MultiGSTT (Tellable t : tr) m a -> MultiGSTT tr m (a, t)
withWriterWA :: (Monoid t, Monad m) => MultiGSTT (Tellable t : tr) m a -> MultiGSTT tr m (t, a)
withWriterW :: (Monoid t, Monad m) => MultiGSTT (Tellable t : tr) m a -> MultiGSTT tr m t
withState :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m (a, t)
withStateAS :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m (a, t)
withStateSA :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m (t, a)
withStateA :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m a
withStateS :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m t
withState_ :: Monad m => t -> MultiGSTT (Settable t : tr) m a -> MultiGSTT tr m ()
without :: Monad m => MultiGSTT tr m a -> MultiGSTT (ct : tr) m a
mapMultiGSTT :: (ts ~ HListM cts) => (m (a, ts) -> m' (a', ts)) -> MultiGSTT cts m a -> MultiGSTT cts m' a'
mGetRawR :: (Monad m, HListMGettableClass ts) => MultiGSTT ts m (HList (HListMGettableOnly ts))
mSetRaw :: Monad m => HListM ts -> MultiGSTT ts m ()
mGetRaw :: Monad m => MultiGSTT ts m (HListM ts)