-- 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.4


-- | 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 :: Type -> Type)
mGet :: MonadMultiGet a m => m a
instance (Control.Monad.Trans.Class.MonadTrans t, GHC.Internal.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 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 :: Type -> Type)
mAsk :: MonadMultiReader a m => m a
instance (Control.Monad.Trans.Class.MonadTrans t, GHC.Internal.Base.Monad (t m), Control.Monad.Trans.MultiReader.Class.MonadMultiReader a m) => Control.Monad.Trans.MultiReader.Class.MonadMultiReader 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 :: Type -> Type)
mGet :: MonadMultiGet a m => m a
class MonadMultiGet a m => MonadMultiState a (m :: Type -> Type)
mSet :: MonadMultiState a m => a -> m ()
instance (Control.Monad.Trans.Class.MonadTrans t, GHC.Internal.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 MonadWriter
module Control.Monad.Trans.MultiWriter.Class
class (Monad m, Monoid a) => MonadMultiWriter a (m :: Type -> Type)
mTell :: MonadMultiWriter a m => a -> m ()
instance (Control.Monad.Trans.Class.MonadTrans t, GHC.Internal.Base.Monad (t m), Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a m) => Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a (t m)


-- | 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 (a :: [Type])
[HNil] :: HList ('[] :: [Type])
[:+:] :: forall x (xs :: [Type]). x -> HList xs -> HList (x ': xs)
infixr 5 :+:
type family Append (l1 :: [Type]) (l2 :: [Type]) :: [Type]
hAppend :: forall (ts1 :: [Type]) (ts2 :: [Type]). HList ts1 -> HList ts2 -> HList (Append ts1 ts2)
class HInit (l1 :: [Type])
hInit :: forall (l2 :: [Type]). HInit l1 => Proxy l2 -> HList (Append l1 l2) -> HList l1
hSplit :: forall (l2 :: [Type]). HInit l1 => HList (Append l1 l2) -> (HList l1, HList l2)
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 l1 => Data.HList.HList.HInit (x : l1)
instance Data.HList.HList.HInit '[]
instance GHC.Internal.Base.Monoid (Data.HList.HList.HList '[])
instance (GHC.Internal.Base.Semigroup x, GHC.Internal.Base.Monoid x, GHC.Internal.Base.Semigroup (Data.HList.HList.HList xs), GHC.Internal.Base.Monoid (Data.HList.HList.HList xs)) => GHC.Internal.Base.Monoid (Data.HList.HList.HList (x : xs))
instance GHC.Internal.Base.Semigroup (Data.HList.HList.HList '[])
instance (GHC.Internal.Base.Semigroup x, GHC.Internal.Base.Semigroup (Data.HList.HList.HList xs)) => GHC.Internal.Base.Semigroup (Data.HList.HList.HList (x : xs))
instance GHC.Internal.Show.Show (Data.HList.HList.HList '[])
instance (GHC.Internal.Show.Show a, GHC.Internal.Show.Show (Data.HList.HList.HList b)) => GHC.Internal.Show.Show (Data.HList.HList.HList (a : b))


-- | 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 :: [Type])
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 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 :: [Type]) (m :: Type -> Type) a
MultiWriterT :: StateT (HList x) m a -> MultiWriterT (x :: [Type]) (m :: Type -> Type) a
[runMultiWriterTRaw] :: MultiWriterT (x :: [Type]) (m :: Type -> Type) a -> StateT (HList x) m a

-- | A MultiWriter transformer carrying an empty state.
type MultiWriterTNull = MultiWriterT '[] :: [Type]
type MultiWriter (x :: [Type]) a = MultiWriterT x Identity a
class (Monad m, Monoid a) => MonadMultiWriter a (m :: Type -> Type)
mTell :: MonadMultiWriter a m => a -> m ()
runMultiWriterT :: forall (w :: [Type]) m a. (Monoid (HList w), Functor m) => MultiWriterT w m a -> m (a, HList w)
runMultiWriterTAW :: forall (w :: [Type]) m a. (Monoid (HList w), Functor m) => MultiWriterT w m a -> m (a, HList w)
runMultiWriterTWA :: forall (w :: [Type]) m a. (Monoid (HList w), Monad m) => MultiWriterT w m a -> m (HList w, a)
runMultiWriterTW :: forall (w :: [Type]) m a. (Monoid (HList w), Monad m) => MultiWriterT w m a -> m (HList w)
runMultiWriterTNil :: Monad m => MultiWriterT ('[] :: [Type]) m a -> m a
runMultiWriterTNil_ :: Functor m => MultiWriterT ('[] :: [Type]) m a -> m ()
withMultiWriter :: forall w (m :: Type -> Type) (ws :: [Type]) a. (Monoid w, Monad m) => MultiWriterT (w ': ws) m a -> MultiWriterT ws m (a, w)
withMultiWriterAW :: forall w (m :: Type -> Type) (ws :: [Type]) a. (Monoid w, Monad m) => MultiWriterT (w ': ws) m a -> MultiWriterT ws m (a, w)
withMultiWriterWA :: forall w (m :: Type -> Type) (ws :: [Type]) a. (Monoid w, Monad m) => MultiWriterT (w ': ws) m a -> MultiWriterT ws m (w, a)
withMultiWriterW :: forall w (m :: Type -> Type) (ws :: [Type]) a. (Monoid w, Monad m) => MultiWriterT (w ': ws) m a -> MultiWriterT ws m w
withMultiWriters :: forall (w1 :: [Type]) (w2 :: [Type]) (m :: Type -> Type) a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (a, HList w1)
withMultiWritersAW :: forall (w1 :: [Type]) (w2 :: [Type]) (m :: Type -> Type) a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (a, HList w1)
withMultiWritersWA :: forall (w1 :: [Type]) (w2 :: [Type]) (m :: Type -> Type) a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (HList w1, a)
withMultiWritersW :: forall (w1 :: [Type]) (w2 :: [Type]) (m :: Type -> Type) a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (HList w1)
inflateWriter :: forall (m :: Type -> Type) w (ws :: [Type]) a. (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 :: forall m a (w :: [Type]) m' a'. (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 :: forall (m :: Type -> Type) (a :: [Type]). Monad m => MultiWriterT a m (HList a)
mPutRaw :: forall (m :: Type -> Type) (s :: [Type]). Monad m => HList s -> MultiWriterT s m ()
instance (GHC.Internal.Base.Functor m, GHC.Internal.Base.Applicative m, GHC.Internal.Base.MonadPlus m) => GHC.Internal.Base.Alternative (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
instance (GHC.Internal.Base.Applicative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Applicative (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT x m)
instance GHC.Internal.Base.Functor f => GHC.Internal.Base.Functor (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT x f)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (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 GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT w m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT x m)
instance (GHC.Internal.Base.Monad m, Data.HList.ContainsType.ContainsType a c, GHC.Internal.Base.Monoid a) => Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c m)
instance GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c 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.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT x)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiWriter.Strict.MultiWriterT c 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 :: [Type]) (m :: Type -> Type) a
MultiWriterT :: StateT (HList x) m a -> MultiWriterT (x :: [Type]) (m :: Type -> Type) a
[runMultiWriterTRaw] :: MultiWriterT (x :: [Type]) (m :: Type -> Type) a -> StateT (HList x) m a

-- | A MultiWriter transformer carrying an empty state.
type MultiWriterTNull = MultiWriterT '[] :: [Type]
type MultiWriter (x :: [Type]) a = MultiWriterT x Identity a
class (Monad m, Monoid a) => MonadMultiWriter a (m :: Type -> Type)
mTell :: MonadMultiWriter a m => a -> m ()
runMultiWriterT :: forall (w :: [Type]) m a. (Monoid (HList w), Functor m) => MultiWriterT w m a -> m (a, HList w)
runMultiWriterTAW :: forall (w :: [Type]) m a. (Monoid (HList w), Functor m) => MultiWriterT w m a -> m (a, HList w)
runMultiWriterTWA :: forall (w :: [Type]) m a. (Monoid (HList w), Monad m) => MultiWriterT w m a -> m (HList w, a)
runMultiWriterTW :: forall (w :: [Type]) m a. (Monoid (HList w), Monad m) => MultiWriterT w m a -> m (HList w)
runMultiWriterTNil :: Monad m => MultiWriterT ('[] :: [Type]) m a -> m a
runMultiWriterTNil_ :: Functor m => MultiWriterT ('[] :: [Type]) m a -> m ()
withMultiWriter :: forall w (m :: Type -> Type) (ws :: [Type]) a. (Monoid w, Monad m) => MultiWriterT (w ': ws) m a -> MultiWriterT ws m (a, w)
withMultiWriterAW :: forall w (m :: Type -> Type) (ws :: [Type]) a. (Monoid w, Monad m) => MultiWriterT (w ': ws) m a -> MultiWriterT ws m (a, w)
withMultiWriterWA :: forall w (m :: Type -> Type) (ws :: [Type]) a. (Monoid w, Monad m) => MultiWriterT (w ': ws) m a -> MultiWriterT ws m (w, a)
withMultiWriterW :: forall w (m :: Type -> Type) (ws :: [Type]) a. (Monoid w, Monad m) => MultiWriterT (w ': ws) m a -> MultiWriterT ws m w
withMultiWriters :: forall (w1 :: [Type]) (w2 :: [Type]) (m :: Type -> Type) a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (a, HList w1)
withMultiWritersAW :: forall (w1 :: [Type]) (w2 :: [Type]) (m :: Type -> Type) a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (a, HList w1)
withMultiWritersWA :: forall (w1 :: [Type]) (w2 :: [Type]) (m :: Type -> Type) a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (HList w1, a)
withMultiWritersW :: forall (w1 :: [Type]) (w2 :: [Type]) (m :: Type -> Type) a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (HList w1)
inflateWriter :: forall (m :: Type -> Type) w (ws :: [Type]) a. (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 :: forall m a (w :: [Type]) m' a'. (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 :: forall (m :: Type -> Type) (a :: [Type]). Monad m => MultiWriterT a m (HList a)
mPutRaw :: forall (m :: Type -> Type) (s :: [Type]). Monad m => HList s -> MultiWriterT s m ()
instance (GHC.Internal.Base.Functor m, GHC.Internal.Base.Applicative m, GHC.Internal.Base.MonadPlus m) => GHC.Internal.Base.Alternative (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
instance (GHC.Internal.Base.Applicative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Applicative (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT x m)
instance GHC.Internal.Base.Functor f => GHC.Internal.Base.Functor (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT x f)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (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 GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT w m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT x m)
instance (GHC.Internal.Base.Monad m, Data.HList.ContainsType.ContainsType a c, GHC.Internal.Base.Monoid a) => Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c m)
instance GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c 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.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT c)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiWriter.Lazy.MultiWriterT x)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiWriter.Lazy.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 :: [Type]) (m :: Type -> Type) a
MultiWriterT :: StateT (HList x) m a -> MultiWriterT (x :: [Type]) (m :: Type -> Type) a
[runMultiWriterTRaw] :: MultiWriterT (x :: [Type]) (m :: Type -> Type) a -> StateT (HList x) m a

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

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

-- | 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 :: [Type]) = 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 :: Type -> Type)
mGet :: MonadMultiGet a m => m a
class MonadMultiGet a m => MonadMultiState a (m :: Type -> Type)
mSet :: MonadMultiState a m => a -> m ()
runMultiStateT :: forall m (s :: [Type]) a. Functor m => HList s -> MultiStateT s m a -> m (a, HList s)
runMultiStateTAS :: forall m (s :: [Type]) a. Functor m => HList s -> MultiStateT s m a -> m (a, HList s)
runMultiStateTSA :: forall m (s :: [Type]) a. Monad m => HList s -> MultiStateT s m a -> m (HList s, a)
runMultiStateTA :: forall m (s :: [Type]) a. Monad m => HList s -> MultiStateT s m a -> m a
runMultiStateTS :: forall m (s :: [Type]) a. Monad m => HList s -> MultiStateT s m a -> m (HList s)
runMultiStateT_ :: forall m (s :: [Type]) a. Functor m => HList s -> MultiStateT s m a -> m ()
runMultiStateTNil :: Monad m => MultiStateT ('[] :: [Type]) m a -> m a
runMultiStateTNil_ :: Functor m => MultiStateT ('[] :: [Type]) m a -> m ()
withMultiState :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m (a, s)
withMultiStateAS :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m (a, s)
withMultiStateSA :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m (s, a)
withMultiStateA :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m a
withMultiStateS :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m s
withMultiState_ :: forall (m :: Type -> Type) s (ss :: [Type]) a. (Functor m, Monad m) => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m ()
withMultiStates :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)
withMultiStatesAS :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)
withMultiStatesSA :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1, a)
withMultiStatesA :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m a
withMultiStatesS :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1)
withMultiStates_ :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. (Functor m, Monad m) => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m ()
withoutMultiState :: forall (m :: Type -> Type) (ss :: [Type]) a s. (Functor m, Monad m) => MultiStateT ss m a -> MultiStateT (s ': ss) m a
inflateState :: forall (m :: Type -> Type) s (ss :: [Type]) a. (Monad m, ContainsType s ss) => StateT s m a -> MultiStateT ss m a
inflateReader :: forall (m :: Type -> Type) r (ss :: [Type]) a. (Monad m, ContainsType r ss) => ReaderT r m a -> MultiStateT ss m a
inflateWriter :: forall (m :: Type -> Type) w (ss :: [Type]) a. (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 :: forall m a (w :: [Type]) m' a'. (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 :: forall (m :: Type -> Type) (a :: [Type]). Monad m => MultiStateT a m (HList a)
mPutRaw :: forall (m :: Type -> Type) (s :: [Type]). Monad m => HList s -> MultiStateT s m ()
instance (GHC.Internal.Base.Functor m, GHC.Internal.Base.Applicative m, GHC.Internal.Base.MonadPlus m) => GHC.Internal.Base.Alternative (Control.Monad.Trans.MultiState.Strict.MultiStateT s m)
instance (GHC.Internal.Base.Applicative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Applicative (Control.Monad.Trans.MultiState.Strict.MultiStateT x m)
instance GHC.Internal.Base.Functor f => GHC.Internal.Base.Functor (Control.Monad.Trans.MultiState.Strict.MultiStateT x f)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (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 GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiState.Strict.MultiStateT s m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiState.Strict.MultiStateT c m)
instance (GHC.Internal.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.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Monad.Trans.MultiState.Strict.MultiStateT x m)
instance (GHC.Internal.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 GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (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.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiState.Strict.MultiStateT s)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiState.Strict.MultiStateT x)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiState.Strict.MultiStateT c 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 :: [Type]) (m :: Type -> Type) a
MultiStateT :: StateT (HList x) m a -> MultiStateT (x :: [Type]) (m :: Type -> Type) a
[runMultiStateTRaw] :: MultiStateT (x :: [Type]) (m :: Type -> Type) a -> StateT (HList x) m a

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

-- | 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 :: [Type]) = 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 :: Type -> Type)
mGet :: MonadMultiGet a m => m a
class MonadMultiGet a m => MonadMultiState a (m :: Type -> Type)
mSet :: MonadMultiState a m => a -> m ()
runMultiStateT :: forall m (s :: [Type]) a. Functor m => HList s -> MultiStateT s m a -> m (a, HList s)
runMultiStateTAS :: forall m (s :: [Type]) a. Functor m => HList s -> MultiStateT s m a -> m (a, HList s)
runMultiStateTSA :: forall m (s :: [Type]) a. Monad m => HList s -> MultiStateT s m a -> m (HList s, a)
runMultiStateTA :: forall m (s :: [Type]) a. Monad m => HList s -> MultiStateT s m a -> m a
runMultiStateTS :: forall m (s :: [Type]) a. Monad m => HList s -> MultiStateT s m a -> m (HList s)
runMultiStateT_ :: forall m (s :: [Type]) a. Functor m => HList s -> MultiStateT s m a -> m ()
runMultiStateTNil :: Monad m => MultiStateT ('[] :: [Type]) m a -> m a
runMultiStateTNil_ :: Functor m => MultiStateT ('[] :: [Type]) m a -> m ()
withMultiState :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m (a, s)
withMultiStateAS :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m (a, s)
withMultiStateSA :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m (s, a)
withMultiStateA :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m a
withMultiStateS :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m s
withMultiState_ :: forall (m :: Type -> Type) s (ss :: [Type]) a. (Functor m, Monad m) => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m ()
withMultiStates :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)
withMultiStatesAS :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)
withMultiStatesSA :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1, a)
withMultiStatesA :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m a
withMultiStatesS :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1)
withMultiStates_ :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. (Functor m, Monad m) => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m ()
withoutMultiState :: forall (m :: Type -> Type) (ss :: [Type]) a s. (Functor m, Monad m) => MultiStateT ss m a -> MultiStateT (s ': ss) m a
inflateState :: forall (m :: Type -> Type) s (ss :: [Type]) a. (Monad m, ContainsType s ss) => StateT s m a -> MultiStateT ss m a
inflateReader :: forall (m :: Type -> Type) r (ss :: [Type]) a. (Monad m, ContainsType r ss) => ReaderT r m a -> MultiStateT ss m a
inflateWriter :: forall (m :: Type -> Type) w (ss :: [Type]) a. (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 :: forall m a (w :: [Type]) m' a'. (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 :: forall (m :: Type -> Type) (a :: [Type]). Monad m => MultiStateT a m (HList a)
mPutRaw :: forall (m :: Type -> Type) (s :: [Type]). Monad m => HList s -> MultiStateT s m ()
instance (GHC.Internal.Base.Functor m, GHC.Internal.Base.Applicative m, GHC.Internal.Base.MonadPlus m) => GHC.Internal.Base.Alternative (Control.Monad.Trans.MultiState.Lazy.MultiStateT s m)
instance (GHC.Internal.Base.Applicative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Applicative (Control.Monad.Trans.MultiState.Lazy.MultiStateT x m)
instance GHC.Internal.Base.Functor f => GHC.Internal.Base.Functor (Control.Monad.Trans.MultiState.Lazy.MultiStateT x f)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (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 GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiState.Lazy.MultiStateT s m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiState.Lazy.MultiStateT c m)
instance (GHC.Internal.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.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Monad.Trans.MultiState.Lazy.MultiStateT x m)
instance (GHC.Internal.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 GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (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.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiState.Lazy.MultiStateT s)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiState.Lazy.MultiStateT x)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiState.Lazy.MultiStateT c 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 :: [Type]) (m :: Type -> Type) a
MultiStateT :: StateT (HList x) m a -> MultiStateT (x :: [Type]) (m :: Type -> Type) a
[runMultiStateTRaw] :: MultiStateT (x :: [Type]) (m :: Type -> Type) a -> StateT (HList x) m a

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

-- | 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 :: [Type]) = 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 :: Type -> Type)
mGet :: MonadMultiGet a m => m a
class MonadMultiGet a m => MonadMultiState a (m :: Type -> Type)
mSet :: MonadMultiState a m => a -> m ()
runMultiStateT :: forall m (s :: [Type]) a. Functor m => HList s -> MultiStateT s m a -> m (a, HList s)
runMultiStateTAS :: forall m (s :: [Type]) a. Functor m => HList s -> MultiStateT s m a -> m (a, HList s)
runMultiStateTSA :: forall m (s :: [Type]) a. Monad m => HList s -> MultiStateT s m a -> m (HList s, a)
runMultiStateTA :: forall m (s :: [Type]) a. Monad m => HList s -> MultiStateT s m a -> m a
runMultiStateTS :: forall m (s :: [Type]) a. Monad m => HList s -> MultiStateT s m a -> m (HList s)
runMultiStateT_ :: forall m (s :: [Type]) a. Functor m => HList s -> MultiStateT s m a -> m ()
runMultiStateTNil :: Monad m => MultiStateT ('[] :: [Type]) m a -> m a
runMultiStateTNil_ :: Functor m => MultiStateT ('[] :: [Type]) m a -> m ()
withMultiState :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m (a, s)
withMultiStateAS :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m (a, s)
withMultiStateSA :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m (s, a)
withMultiStateA :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m a
withMultiStateS :: forall (m :: Type -> Type) s (ss :: [Type]) a. Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m s
withMultiState_ :: forall (m :: Type -> Type) s (ss :: [Type]) a. (Functor m, Monad m) => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m ()
withMultiStates :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)
withMultiStatesAS :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)
withMultiStatesSA :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1, a)
withMultiStatesA :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m a
withMultiStatesS :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1)
withMultiStates_ :: forall (m :: Type -> Type) (s1 :: [Type]) (s2 :: [Type]) a. (Functor m, Monad m) => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m ()
withoutMultiState :: forall (m :: Type -> Type) (ss :: [Type]) a s. (Functor m, Monad m) => MultiStateT ss m a -> MultiStateT (s ': ss) m a
inflateState :: forall (m :: Type -> Type) s (ss :: [Type]) a. (Monad m, ContainsType s ss) => StateT s m a -> MultiStateT ss m a
inflateReader :: forall (m :: Type -> Type) r (ss :: [Type]) a. (Monad m, ContainsType r ss) => ReaderT r m a -> MultiStateT ss m a
inflateWriter :: forall (m :: Type -> Type) w (ss :: [Type]) a. (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 :: forall m a (w :: [Type]) m' a'. (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 :: forall (m :: Type -> Type) (a :: [Type]). Monad m => MultiStateT a m (HList a)
mPutRaw :: forall (m :: Type -> Type) (s :: [Type]). Monad m => HList s -> MultiStateT 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 :: [Type]) (m :: Type -> Type) a
MultiReaderT :: StateT (HList x) m a -> MultiReaderT (x :: [Type]) (m :: Type -> Type) a
[runMultiReaderTRaw] :: MultiReaderT (x :: [Type]) (m :: Type -> Type) a -> StateT (HList x) m a

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

-- | 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 :: [Type]) = 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 :: Type -> Type)
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 :: Type -> Type)
mGet :: MonadMultiGet a m => m a
runMultiReaderT :: forall m (r :: [Type]) a. Monad m => HList r -> MultiReaderT r m a -> m a
runMultiReaderT_ :: forall m (r :: [Type]) a. Functor m => HList r -> MultiReaderT r m a -> m ()
runMultiReaderTNil :: Monad m => MultiReaderT ('[] :: [Type]) m a -> m a
runMultiReaderTNil_ :: Functor m => MultiReaderT ('[] :: [Type]) m a -> m ()
withMultiReader :: forall (m :: Type -> Type) r (rs :: [Type]) a. Monad m => r -> MultiReaderT (r ': rs) m a -> MultiReaderT rs m a
withMultiReader_ :: forall (m :: Type -> Type) r (rs :: [Type]) a. (Functor m, Monad m) => r -> MultiReaderT (r ': rs) m a -> MultiReaderT rs m ()
withMultiReaders :: forall (m :: Type -> Type) (r1 :: [Type]) (r2 :: [Type]) a. Monad m => HList r1 -> MultiReaderT (Append r1 r2) m a -> MultiReaderT r2 m a
withMultiReaders_ :: forall (m :: Type -> Type) (r1 :: [Type]) (r2 :: [Type]) a. (Functor m, Monad m) => HList r1 -> MultiReaderT (Append r1 r2) m a -> MultiReaderT r2 m ()
withoutMultiReader :: forall (m :: Type -> Type) (rs :: [Type]) a r. Monad m => MultiReaderT rs m a -> MultiReaderT (r ': rs) m a
inflateReader :: forall (m :: Type -> Type) r (rs :: [Type]) a. (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 :: forall m a (w :: [Type]) m' a'. (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 :: forall (m :: Type -> Type) (a :: [Type]). Monad m => MultiReaderT a m (HList a)
mPutRaw :: forall (m :: Type -> Type) (s :: [Type]). Monad m => HList s -> MultiReaderT s m ()
instance (GHC.Internal.Base.Functor m, GHC.Internal.Base.Applicative m, GHC.Internal.Base.MonadPlus m) => GHC.Internal.Base.Alternative (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
instance (GHC.Internal.Base.Applicative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Applicative (Control.Monad.Trans.MultiReader.Strict.MultiReaderT x m)
instance GHC.Internal.Base.Functor f => GHC.Internal.Base.Functor (Control.Monad.Trans.MultiReader.Strict.MultiReaderT x f)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiReader.Strict.MultiReaderT r m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiReader.Strict.MultiReaderT r m)
instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiReader.Strict.MultiReaderT r m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c m)
instance (GHC.Internal.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 GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Monad.Trans.MultiReader.Strict.MultiReaderT x m)
instance (GHC.Internal.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.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c 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.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiReader.Strict.MultiReaderT r)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiReader.Strict.MultiReaderT x)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiReader.Strict.MultiReaderT c 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 :: [Type]) (m :: Type -> Type) a
MultiReaderT :: StateT (HList x) m a -> MultiReaderT (x :: [Type]) (m :: Type -> Type) a
[runMultiReaderTRaw] :: MultiReaderT (x :: [Type]) (m :: Type -> Type) a -> StateT (HList x) m a

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

-- | 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 :: [Type]) = 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 :: Type -> Type)
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 :: Type -> Type)
mGet :: MonadMultiGet a m => m a
runMultiReaderT :: forall m (r :: [Type]) a. Monad m => HList r -> MultiReaderT r m a -> m a
runMultiReaderT_ :: forall m (r :: [Type]) a. Functor m => HList r -> MultiReaderT r m a -> m ()
runMultiReaderTNil :: Monad m => MultiReaderT ('[] :: [Type]) m a -> m a
runMultiReaderTNil_ :: Functor m => MultiReaderT ('[] :: [Type]) m a -> m ()
withMultiReader :: forall (m :: Type -> Type) r (rs :: [Type]) a. Monad m => r -> MultiReaderT (r ': rs) m a -> MultiReaderT rs m a
withMultiReader_ :: forall (m :: Type -> Type) r (rs :: [Type]) a. (Functor m, Monad m) => r -> MultiReaderT (r ': rs) m a -> MultiReaderT rs m ()
withMultiReaders :: forall (m :: Type -> Type) (r1 :: [Type]) (r2 :: [Type]) a. Monad m => HList r1 -> MultiReaderT (Append r1 r2) m a -> MultiReaderT r2 m a
withMultiReaders_ :: forall (m :: Type -> Type) (r1 :: [Type]) (r2 :: [Type]) a. (Functor m, Monad m) => HList r1 -> MultiReaderT (Append r1 r2) m a -> MultiReaderT r2 m ()
withoutMultiReader :: forall (m :: Type -> Type) (rs :: [Type]) a r. Monad m => MultiReaderT rs m a -> MultiReaderT (r ': rs) m a
inflateReader :: forall (m :: Type -> Type) r (rs :: [Type]) a. (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 :: forall m a (w :: [Type]) m' a'. (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 :: forall (m :: Type -> Type) (a :: [Type]). Monad m => MultiReaderT a m (HList a)
mPutRaw :: forall (m :: Type -> Type) (s :: [Type]). Monad m => HList s -> MultiReaderT s m ()
instance (GHC.Internal.Base.Functor m, GHC.Internal.Base.Applicative m, GHC.Internal.Base.MonadPlus m) => GHC.Internal.Base.Alternative (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
instance (GHC.Internal.Base.Applicative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Applicative (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT x m)
instance GHC.Internal.Base.Functor f => GHC.Internal.Base.Functor (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT x f)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT r m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT r m)
instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT r m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c m)
instance (GHC.Internal.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 GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT x m)
instance (GHC.Internal.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.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c 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.Trans.Control.MonadTransControl (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT r)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT x)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.MultiReader.Lazy.MultiReaderT c 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 :: [Type]) (m :: Type -> Type) a
MultiReaderT :: StateT (HList x) m a -> MultiReaderT (x :: [Type]) (m :: Type -> Type) a
[runMultiReaderTRaw] :: MultiReaderT (x :: [Type]) (m :: Type -> Type) a -> StateT (HList x) m a

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

-- | 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 :: [Type]) = 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 :: Type -> Type)
mAsk :: MonadMultiReader a m => m a
runMultiReaderT :: forall m (r :: [Type]) a. Monad m => HList r -> MultiReaderT r m a -> m a
runMultiReaderT_ :: forall m (r :: [Type]) a. Functor m => HList r -> MultiReaderT r m a -> m ()
runMultiReaderTNil :: Monad m => MultiReaderT ('[] :: [Type]) m a -> m a
runMultiReaderTNil_ :: Functor m => MultiReaderT ('[] :: [Type]) m a -> m ()
withMultiReader :: forall (m :: Type -> Type) r (rs :: [Type]) a. Monad m => r -> MultiReaderT (r ': rs) m a -> MultiReaderT rs m a
withMultiReader_ :: forall (m :: Type -> Type) r (rs :: [Type]) a. (Functor m, Monad m) => r -> MultiReaderT (r ': rs) m a -> MultiReaderT rs m ()
withMultiReaders :: forall (m :: Type -> Type) (r1 :: [Type]) (r2 :: [Type]) a. Monad m => HList r1 -> MultiReaderT (Append r1 r2) m a -> MultiReaderT r2 m a
withMultiReaders_ :: forall (m :: Type -> Type) (r1 :: [Type]) (r2 :: [Type]) a. (Functor m, Monad m) => HList r1 -> MultiReaderT (Append r1 r2) m a -> MultiReaderT r2 m ()
withoutMultiReader :: forall (m :: Type -> Type) (rs :: [Type]) a r. Monad m => MultiReaderT rs m a -> MultiReaderT (r ': rs) m a
inflateReader :: forall (m :: Type -> Type) r (rs :: [Type]) a. (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 :: forall m a (w :: [Type]) m' a'. (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 :: forall (m :: Type -> Type) (a :: [Type]). Monad m => MultiReaderT a m (HList a)
mPutRaw :: forall (m :: Type -> Type) (s :: [Type]). Monad m => HList s -> MultiReaderT s m ()


-- | The multi-valued version of mtl's RWS / RWST
module Control.Monad.Trans.MultiRWS.Strict
newtype MultiRWST (r :: [Type]) (w :: [Type]) (s :: [Type]) (m :: Type -> Type) a
MultiRWST :: StateT (HList r, HList w, HList s) m a -> MultiRWST (r :: [Type]) (w :: [Type]) (s :: [Type]) (m :: Type -> Type) a
[runMultiRWSTRaw] :: MultiRWST (r :: [Type]) (w :: [Type]) (s :: [Type]) (m :: Type -> Type) a -> StateT (HList r, HList w, HList s) m a
type MultiRWSTNull = MultiRWST '[] :: [Type] '[] :: [Type] '[] :: [Type]
type MultiRWS (r :: [Type]) (w :: [Type]) (s :: [Type]) = 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 :: Type -> Type)
mAsk :: MonadMultiReader a m => m a
class (Monad m, Monoid a) => MonadMultiWriter a (m :: Type -> Type)
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 :: Type -> Type)
mGet :: MonadMultiGet a m => m a
class MonadMultiGet a m => MonadMultiState a (m :: Type -> Type)
mSet :: MonadMultiState a m => a -> m ()
runMultiRWST :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)
runMultiRWSTASW :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)
runMultiRWSTW :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList w)
runMultiRWSTAW :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList w)
runMultiRWSTSW :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList s, HList w)
runMultiRWSTNil :: Monad m => MultiRWST ('[] :: [Type]) ('[] :: [Type]) ('[] :: [Type]) m a -> m a
runMultiRWSTNil_ :: (Monad m, Functor m) => MultiRWST ('[] :: [Type]) ('[] :: [Type]) ('[] :: [Type]) m a -> m ()
withMultiReader :: forall (m :: Type -> Type) r (rs :: [Type]) (w :: [Type]) (s :: [Type]) a. Monad m => r -> MultiRWST (r ': rs) w s m a -> MultiRWST rs w s m a
withMultiReader_ :: forall (m :: Type -> Type) r (rs :: [Type]) (w :: [Type]) (s :: [Type]) a. (Functor m, Monad m) => r -> MultiRWST (r ': rs) w s m a -> MultiRWST rs w s m ()
withMultiReaders :: forall (m :: Type -> Type) (r1 :: [Type]) (r2 :: [Type]) (w :: [Type]) (s :: [Type]) a. Monad m => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m a
withMultiReaders_ :: forall (m :: Type -> Type) (r1 :: [Type]) (r2 :: [Type]) (w :: [Type]) (s :: [Type]) a. (Functor m, Monad m) => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m ()
withMultiWriter :: forall w (m :: Type -> Type) (r :: [Type]) (ws :: [Type]) (s :: [Type]) a. (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m (a, w)
withMultiWriterAW :: forall w (m :: Type -> Type) (r :: [Type]) (ws :: [Type]) (s :: [Type]) a. (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m (a, w)
withMultiWriterWA :: forall w (m :: Type -> Type) (r :: [Type]) (ws :: [Type]) (s :: [Type]) a. (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m (w, a)
withMultiWriterW :: forall w (m :: Type -> Type) (r :: [Type]) (ws :: [Type]) (s :: [Type]) a. (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m w
withMultiWriters :: forall (r :: [Type]) (w1 :: [Type]) (w2 :: [Type]) (s :: [Type]) (m :: Type -> Type) 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 :: [Type]) (w1 :: [Type]) (w2 :: [Type]) (s :: [Type]) (m :: Type -> Type) 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 :: [Type]) (w1 :: [Type]) (w2 :: [Type]) (s :: [Type]) (m :: Type -> Type) 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 :: [Type]) (w1 :: [Type]) (w2 :: [Type]) (s :: [Type]) (m :: Type -> Type) a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (HList w1)
withMultiState :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m (a, s)
withMultiStateAS :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m (a, s)
withMultiStateSA :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m (s, a)
withMultiStateA :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m a
withMultiStateS :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m s
withMultiState_ :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. (Functor m, Monad m) => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m ()
withMultiStates :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)
withMultiStatesAS :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)
withMultiStatesSA :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1, a)
withMultiStatesA :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m a
withMultiStatesS :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1)
withMultiStates_ :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. (Functor m, Monad m) => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m ()
withoutMultiReader :: forall (m :: Type -> Type) (rs :: [Type]) (w :: [Type]) (s :: [Type]) a r. Monad m => MultiRWST rs w s m a -> MultiRWST (r ': rs) w s m a
withoutMultiState :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (ss :: [Type]) a s. Monad m => MultiRWST r w ss m a -> MultiRWST r w (s ': ss) m a
inflateReader :: forall (m :: Type -> Type) r (rs :: [Type]) a (w :: [Type]) (s :: [Type]). (Monad m, ContainsType r rs) => ReaderT r m a -> MultiRWST rs w s m a
inflateMultiReader :: forall (m :: Type -> Type) (r :: [Type]) a (w :: [Type]) (s :: [Type]). Monad m => MultiReaderT r m a -> MultiRWST r w s m a
inflateWriter :: forall (m :: Type -> Type) w (ws :: [Type]) a (r :: [Type]) (s :: [Type]). (Monad m, ContainsType w ws, Monoid w) => WriterT w m a -> MultiRWST r ws s m a
inflateMultiWriter :: forall (m :: Type -> Type) (w :: [Type]) a (r :: [Type]) (s :: [Type]). (Functor m, Monad m, Monoid (HList w)) => MultiWriterT w m a -> MultiRWST r w s m a
inflateState :: forall (m :: Type -> Type) t s a. (Monad m, MonadTrans t, MonadMultiState s (t m)) => StateT s m a -> t m a
inflateMultiState :: forall (m :: Type -> Type) (s :: [Type]) a (r :: [Type]) (w :: [Type]). (Functor m, Monad m) => MultiStateT s m a -> MultiRWST r w s m a
mapMultiRWST :: forall ss (r :: [Type]) (w :: [Type]) (s :: [Type]) m a m' a'. 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 :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (s :: [Type]). Monad m => MultiRWST r w s m (HList r)
mGetRawW :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (s :: [Type]). Monad m => MultiRWST r w s m (HList w)
mGetRawS :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (s :: [Type]). Monad m => MultiRWST r w s m (HList s)
mPutRawR :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (s :: [Type]). Monad m => HList r -> MultiRWST r w s m ()
mPutRawW :: forall (m :: Type -> Type) (w :: [Type]) (r :: [Type]) (s :: [Type]). Monad m => HList w -> MultiRWST r w s m ()
mPutRawS :: forall (m :: Type -> Type) (s :: [Type]) (r :: [Type]) (w :: [Type]). Monad m => HList s -> MultiRWST r w s m ()
instance (GHC.Internal.Base.Functor m, GHC.Internal.Base.Applicative m, GHC.Internal.Base.MonadPlus m) => GHC.Internal.Base.Alternative (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
instance (GHC.Internal.Base.Applicative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Applicative (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
instance GHC.Internal.Base.Functor f => GHC.Internal.Base.Functor (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s f)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (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 GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.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.Internal.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.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
instance (GHC.Internal.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.Internal.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 (GHC.Internal.Base.Monad m, Data.HList.ContainsType.ContainsType a w, GHC.Internal.Base.Monoid a) => Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s m)
instance GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (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.Class.MonadTrans (Control.Monad.Trans.MultiRWS.Strict.MultiRWST r w s)


-- | The multi-valued version of mtl's RWS / RWST
module Control.Monad.Trans.MultiRWS.Lazy
newtype MultiRWST (r :: [Type]) (w :: [Type]) (s :: [Type]) (m :: Type -> Type) a
MultiRWST :: StateT (HList r, HList w, HList s) m a -> MultiRWST (r :: [Type]) (w :: [Type]) (s :: [Type]) (m :: Type -> Type) a
[runMultiRWSTRaw] :: MultiRWST (r :: [Type]) (w :: [Type]) (s :: [Type]) (m :: Type -> Type) a -> StateT (HList r, HList w, HList s) m a
type MultiRWSTNull = MultiRWST '[] :: [Type] '[] :: [Type] '[] :: [Type]
type MultiRWS (r :: [Type]) (w :: [Type]) (s :: [Type]) = 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 :: Type -> Type)
mAsk :: MonadMultiReader a m => m a
class (Monad m, Monoid a) => MonadMultiWriter a (m :: Type -> Type)
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 :: Type -> Type)
mGet :: MonadMultiGet a m => m a
class MonadMultiGet a m => MonadMultiState a (m :: Type -> Type)
mSet :: MonadMultiState a m => a -> m ()
runMultiRWST :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)
runMultiRWSTASW :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)
runMultiRWSTW :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList w)
runMultiRWSTAW :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList w)
runMultiRWSTSW :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList s, HList w)
runMultiRWSTNil :: Monad m => MultiRWST ('[] :: [Type]) ('[] :: [Type]) ('[] :: [Type]) m a -> m a
runMultiRWSTNil_ :: (Monad m, Functor m) => MultiRWST ('[] :: [Type]) ('[] :: [Type]) ('[] :: [Type]) m a -> m ()
withMultiReader :: forall (m :: Type -> Type) r (rs :: [Type]) (w :: [Type]) (s :: [Type]) a. Monad m => r -> MultiRWST (r ': rs) w s m a -> MultiRWST rs w s m a
withMultiReader_ :: forall (m :: Type -> Type) r (rs :: [Type]) (w :: [Type]) (s :: [Type]) a. (Functor m, Monad m) => r -> MultiRWST (r ': rs) w s m a -> MultiRWST rs w s m ()
withMultiReaders :: forall (m :: Type -> Type) (r1 :: [Type]) (r2 :: [Type]) (w :: [Type]) (s :: [Type]) a. Monad m => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m a
withMultiReaders_ :: forall (m :: Type -> Type) (r1 :: [Type]) (r2 :: [Type]) (w :: [Type]) (s :: [Type]) a. (Functor m, Monad m) => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m ()
withMultiWriter :: forall w (m :: Type -> Type) (r :: [Type]) (ws :: [Type]) (s :: [Type]) a. (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m (a, w)
withMultiWriterAW :: forall w (m :: Type -> Type) (r :: [Type]) (ws :: [Type]) (s :: [Type]) a. (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m (a, w)
withMultiWriterWA :: forall w (m :: Type -> Type) (r :: [Type]) (ws :: [Type]) (s :: [Type]) a. (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m (w, a)
withMultiWriterW :: forall w (m :: Type -> Type) (r :: [Type]) (ws :: [Type]) (s :: [Type]) a. (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m w
withMultiWriters :: forall (r :: [Type]) (w1 :: [Type]) (w2 :: [Type]) (s :: [Type]) (m :: Type -> Type) 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 :: [Type]) (w1 :: [Type]) (w2 :: [Type]) (s :: [Type]) (m :: Type -> Type) 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 :: [Type]) (w1 :: [Type]) (w2 :: [Type]) (s :: [Type]) (m :: Type -> Type) 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 :: [Type]) (w1 :: [Type]) (w2 :: [Type]) (s :: [Type]) (m :: Type -> Type) a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (HList w1)
withMultiState :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m (a, s)
withMultiStateAS :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m (a, s)
withMultiStateSA :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m (s, a)
withMultiStateA :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m a
withMultiStateS :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m s
withMultiState_ :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. (Functor m, Monad m) => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m ()
withMultiStates :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)
withMultiStatesAS :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)
withMultiStatesSA :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1, a)
withMultiStatesA :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m a
withMultiStatesS :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1)
withMultiStates_ :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. (Functor m, Monad m) => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m ()
withoutMultiReader :: forall (m :: Type -> Type) (rs :: [Type]) (w :: [Type]) (s :: [Type]) a r. Monad m => MultiRWST rs w s m a -> MultiRWST (r ': rs) w s m a
withoutMultiState :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (ss :: [Type]) a s. Monad m => MultiRWST r w ss m a -> MultiRWST r w (s ': ss) m a
inflateReader :: forall (m :: Type -> Type) r (rs :: [Type]) a (w :: [Type]) (s :: [Type]). (Monad m, ContainsType r rs) => ReaderT r m a -> MultiRWST rs w s m a
inflateMultiReader :: forall (m :: Type -> Type) (r :: [Type]) a (w :: [Type]) (s :: [Type]). Monad m => MultiReaderT r m a -> MultiRWST r w s m a
inflateWriter :: forall (m :: Type -> Type) w (ws :: [Type]) a (r :: [Type]) (s :: [Type]). (Monad m, ContainsType w ws, Monoid w) => WriterT w m a -> MultiRWST r ws s m a
inflateMultiWriter :: forall (m :: Type -> Type) (w :: [Type]) a (r :: [Type]) (s :: [Type]). (Functor m, Monad m, Monoid (HList w)) => MultiWriterT w m a -> MultiRWST r w s m a
inflateState :: forall (m :: Type -> Type) s t a. (Monad m, MonadMultiState s (t m), MonadTrans t) => StateT s m a -> t m a
inflateMultiState :: forall (m :: Type -> Type) (s :: [Type]) a (r :: [Type]) (w :: [Type]). (Functor m, Monad m) => MultiStateT s m a -> MultiRWST r w s m a
mapMultiRWST :: forall ss (r :: [Type]) (w :: [Type]) (s :: [Type]) m a m' a'. 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 :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (s :: [Type]). Monad m => MultiRWST r w s m (HList r)
mGetRawW :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (s :: [Type]). Monad m => MultiRWST r w s m (HList w)
mGetRawS :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (s :: [Type]). Monad m => MultiRWST r w s m (HList s)
mPutRawR :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (s :: [Type]). Monad m => HList r -> MultiRWST r w s m ()
mPutRawW :: forall (m :: Type -> Type) (w :: [Type]) (r :: [Type]) (s :: [Type]). Monad m => HList w -> MultiRWST r w s m ()
mPutRawS :: forall (m :: Type -> Type) (s :: [Type]) (r :: [Type]) (w :: [Type]). Monad m => HList s -> MultiRWST r w s m ()
instance (GHC.Internal.Base.Functor m, GHC.Internal.Base.Applicative m, GHC.Internal.Base.MonadPlus m) => GHC.Internal.Base.Alternative (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
instance (GHC.Internal.Base.Applicative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Applicative (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
instance GHC.Internal.Base.Functor f => GHC.Internal.Base.Functor (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s f)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (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 GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.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.Internal.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.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
instance (GHC.Internal.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.Internal.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 (GHC.Internal.Base.Monad m, Data.HList.ContainsType.ContainsType a w, GHC.Internal.Base.Monoid a) => Control.Monad.Trans.MultiWriter.Class.MonadMultiWriter a (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s m)
instance GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (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.Class.MonadTrans (Control.Monad.Trans.MultiRWS.Lazy.MultiRWST r w s)


-- | The multi-valued version of mtl's RWS / RWST
module Control.Monad.Trans.MultiRWS
newtype MultiRWST (r :: [Type]) (w :: [Type]) (s :: [Type]) (m :: Type -> Type) a
MultiRWST :: StateT (HList r, HList w, HList s) m a -> MultiRWST (r :: [Type]) (w :: [Type]) (s :: [Type]) (m :: Type -> Type) a
[runMultiRWSTRaw] :: MultiRWST (r :: [Type]) (w :: [Type]) (s :: [Type]) (m :: Type -> Type) a -> StateT (HList r, HList w, HList s) m a
type MultiRWSTNull = MultiRWST '[] :: [Type] '[] :: [Type] '[] :: [Type]
type MultiRWS (r :: [Type]) (w :: [Type]) (s :: [Type]) = 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 :: Type -> Type)
mAsk :: MonadMultiReader a m => m a
class (Monad m, Monoid a) => MonadMultiWriter a (m :: Type -> Type)
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 :: Type -> Type)
mGet :: MonadMultiGet a m => m a
class MonadMultiGet a m => MonadMultiState a (m :: Type -> Type)
mSet :: MonadMultiState a m => a -> m ()
runMultiRWST :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)
runMultiRWSTASW :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList s, HList w)
runMultiRWSTW :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList w)
runMultiRWSTAW :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (a, HList w)
runMultiRWSTSW :: forall m (w :: [Type]) (r :: [Type]) (s :: [Type]) a. (Monad m, Monoid (HList w)) => HList r -> HList s -> MultiRWST r w s m a -> m (HList s, HList w)
runMultiRWSTNil :: Monad m => MultiRWST ('[] :: [Type]) ('[] :: [Type]) ('[] :: [Type]) m a -> m a
runMultiRWSTNil_ :: (Monad m, Functor m) => MultiRWST ('[] :: [Type]) ('[] :: [Type]) ('[] :: [Type]) m a -> m ()
withMultiReader :: forall (m :: Type -> Type) r (rs :: [Type]) (w :: [Type]) (s :: [Type]) a. Monad m => r -> MultiRWST (r ': rs) w s m a -> MultiRWST rs w s m a
withMultiReader_ :: forall (m :: Type -> Type) r (rs :: [Type]) (w :: [Type]) (s :: [Type]) a. (Functor m, Monad m) => r -> MultiRWST (r ': rs) w s m a -> MultiRWST rs w s m ()
withMultiReaders :: forall (m :: Type -> Type) (r1 :: [Type]) (r2 :: [Type]) (w :: [Type]) (s :: [Type]) a. Monad m => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m a
withMultiReaders_ :: forall (m :: Type -> Type) (r1 :: [Type]) (r2 :: [Type]) (w :: [Type]) (s :: [Type]) a. (Functor m, Monad m) => HList r1 -> MultiRWST (Append r1 r2) w s m a -> MultiRWST r2 w s m ()
withMultiWriter :: forall w (m :: Type -> Type) (r :: [Type]) (ws :: [Type]) (s :: [Type]) a. (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m (a, w)
withMultiWriterAW :: forall w (m :: Type -> Type) (r :: [Type]) (ws :: [Type]) (s :: [Type]) a. (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m (a, w)
withMultiWriterWA :: forall w (m :: Type -> Type) (r :: [Type]) (ws :: [Type]) (s :: [Type]) a. (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m (w, a)
withMultiWriterW :: forall w (m :: Type -> Type) (r :: [Type]) (ws :: [Type]) (s :: [Type]) a. (Monoid w, Monad m) => MultiRWST r (w ': ws) s m a -> MultiRWST r ws s m w
withMultiWriters :: forall (r :: [Type]) (w1 :: [Type]) (w2 :: [Type]) (s :: [Type]) (m :: Type -> Type) 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 :: [Type]) (w1 :: [Type]) (w2 :: [Type]) (s :: [Type]) (m :: Type -> Type) 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 :: [Type]) (w1 :: [Type]) (w2 :: [Type]) (s :: [Type]) (m :: Type -> Type) 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 :: [Type]) (w1 :: [Type]) (w2 :: [Type]) (s :: [Type]) (m :: Type -> Type) a. (Monoid (HList w1), Monad m, HInit w1) => MultiRWST r (Append w1 w2) s m a -> MultiRWST r w2 s m (HList w1)
withMultiState :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m (a, s)
withMultiStateAS :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m (a, s)
withMultiStateSA :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m (s, a)
withMultiStateA :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m a
withMultiStateS :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. Monad m => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m s
withMultiState_ :: forall (m :: Type -> Type) s (r :: [Type]) (w :: [Type]) (ss :: [Type]) a. (Functor m, Monad m) => s -> MultiRWST r w (s ': ss) m a -> MultiRWST r w ss m ()
withMultiStates :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)
withMultiStatesAS :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (a, HList s1)
withMultiStatesSA :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1, a)
withMultiStatesA :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m a
withMultiStatesS :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. Monad m => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m (HList s1)
withMultiStates_ :: forall (m :: Type -> Type) (s1 :: [Type]) (r :: [Type]) (w :: [Type]) (s2 :: [Type]) a. (Functor m, Monad m) => HList s1 -> MultiRWST r w (Append s1 s2) m a -> MultiRWST r w s2 m ()
withoutMultiReader :: forall (m :: Type -> Type) (rs :: [Type]) (w :: [Type]) (s :: [Type]) a r. Monad m => MultiRWST rs w s m a -> MultiRWST (r ': rs) w s m a
withoutMultiState :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (ss :: [Type]) a s. Monad m => MultiRWST r w ss m a -> MultiRWST r w (s ': ss) m a
inflateReader :: forall (m :: Type -> Type) r (rs :: [Type]) a (w :: [Type]) (s :: [Type]). (Monad m, ContainsType r rs) => ReaderT r m a -> MultiRWST rs w s m a
inflateMultiReader :: forall (m :: Type -> Type) (r :: [Type]) a (w :: [Type]) (s :: [Type]). Monad m => MultiReaderT r m a -> MultiRWST r w s m a
inflateWriter :: forall (m :: Type -> Type) w (ws :: [Type]) a (r :: [Type]) (s :: [Type]). (Monad m, ContainsType w ws, Monoid w) => WriterT w m a -> MultiRWST r ws s m a
inflateMultiWriter :: forall (m :: Type -> Type) (w :: [Type]) a (r :: [Type]) (s :: [Type]). (Functor m, Monad m, Monoid (HList w)) => MultiWriterT w m a -> MultiRWST r w s m a
inflateState :: forall (m :: Type -> Type) s t a. (Monad m, MonadMultiState s (t m), MonadTrans t) => StateT s m a -> t m a
inflateMultiState :: forall (m :: Type -> Type) (s :: [Type]) a (r :: [Type]) (w :: [Type]). (Functor m, Monad m) => MultiStateT s m a -> MultiRWST r w s m a
mapMultiRWST :: forall ss (r :: [Type]) (w :: [Type]) (s :: [Type]) m a m' a'. 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 :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (s :: [Type]). Monad m => MultiRWST r w s m (HList r)
mGetRawW :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (s :: [Type]). Monad m => MultiRWST r w s m (HList w)
mGetRawS :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (s :: [Type]). Monad m => MultiRWST r w s m (HList s)
mPutRawR :: forall (m :: Type -> Type) (r :: [Type]) (w :: [Type]) (s :: [Type]). Monad m => HList r -> MultiRWST r w s m ()
mPutRawW :: forall (m :: Type -> Type) (w :: [Type]) (r :: [Type]) (s :: [Type]). Monad m => HList w -> MultiRWST r w s m ()
mPutRawS :: forall (m :: Type -> Type) (s :: [Type]) (r :: [Type]) (w :: [Type]). Monad m => HList s -> 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.Strict
newtype MultiGSTT (ts :: [CanReadWrite Type]) (m :: Type -> Type) a
MultiGSTT :: StateT (HListM ts) m a -> MultiGSTT (ts :: [CanReadWrite Type]) (m :: Type -> Type) a
[runMultiGSTTRaw] :: MultiGSTT (ts :: [CanReadWrite Type]) (m :: Type -> Type) a -> StateT (HListM ts) m a
type MultiGSTTNull = MultiGSTT '[] :: [CanReadWrite Type]
type MultiGST (r :: [CanReadWrite Type]) = 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 :: Type -> Type)
mAsk :: MonadMultiReader a m => m a
class (Monad m, Monoid a) => MonadMultiWriter a (m :: Type -> Type)
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 :: Type -> Type)
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 ('[] :: [CanReadWrite Type]) m a -> m a
runMultiGSTTNil_ :: Monad m => MultiGSTT ('[] :: [CanReadWrite Type]) m a -> m ()
withReader :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Gettable t ': tr) m a -> MultiGSTT tr m a
withReader_ :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Gettable t ': tr) m a -> MultiGSTT tr m ()
withWriter :: forall t (m :: Type -> Type) (tr :: [CanReadWrite Type]) a. (Monoid t, Monad m) => MultiGSTT ('Tellable t ': tr) m a -> MultiGSTT tr m (a, t)
withWriterAW :: forall t (m :: Type -> Type) (tr :: [CanReadWrite Type]) a. (Monoid t, Monad m) => MultiGSTT ('Tellable t ': tr) m a -> MultiGSTT tr m (a, t)
withWriterWA :: forall t (m :: Type -> Type) (tr :: [CanReadWrite Type]) a. (Monoid t, Monad m) => MultiGSTT ('Tellable t ': tr) m a -> MultiGSTT tr m (t, a)
withWriterW :: forall t (m :: Type -> Type) (tr :: [CanReadWrite Type]) a. (Monoid t, Monad m) => MultiGSTT ('Tellable t ': tr) m a -> MultiGSTT tr m t
withState :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m (a, t)
withStateAS :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m (a, t)
withStateSA :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m (t, a)
withStateA :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m a
withStateS :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m t
withState_ :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m ()
without :: forall (m :: Type -> Type) (tr :: [CanReadWrite Type]) a (ct :: CanReadWrite Type). Monad m => MultiGSTT tr m a -> MultiGSTT (ct ': tr) m a
mGetRaw :: forall (m :: Type -> Type) (ts :: [CanReadWrite Type]). Monad m => MultiGSTT ts m (HListM ts)
mSetRaw :: forall (m :: Type -> Type) (ts :: [CanReadWrite Type]). Monad m => HListM ts -> MultiGSTT ts m ()
mapMultiGSTT :: forall ts (cts :: [CanReadWrite Type]) m a m' a'. ts ~ HListM cts => (m (a, ts) -> m' (a', ts)) -> MultiGSTT cts m a -> MultiGSTT cts m' a'
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Control.Monad.Trans.MultiGST.Strict.MultiGSTT ts m)
instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Monad.Trans.MultiGST.Strict.MultiGSTT ts m)
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Monad.Trans.MultiGST.Strict.MultiGSTT ts m)
instance (GHC.Internal.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.Internal.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.Internal.Base.Monad m, GHC.Internal.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)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiGST.Strict.MultiGSTT ts)


-- | 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 :: [CanReadWrite Type]) (m :: Type -> Type) a
MultiGSTT :: StateT (HListM ts) m a -> MultiGSTT (ts :: [CanReadWrite Type]) (m :: Type -> Type) a
[runMultiGSTTRaw] :: MultiGSTT (ts :: [CanReadWrite Type]) (m :: Type -> Type) a -> StateT (HListM ts) m a
type MultiGSTTNull = MultiGSTT '[] :: [CanReadWrite Type]
type MultiGST (r :: [CanReadWrite Type]) = 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 :: Type -> Type)
mAsk :: MonadMultiReader a m => m a
class (Monad m, Monoid a) => MonadMultiWriter a (m :: Type -> Type)
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 :: Type -> Type)
mGet :: MonadMultiGet a m => m a
class MonadMultiGet a m => MonadMultiState a (m :: Type -> Type)
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 ('[] :: [CanReadWrite Type]) m a -> m a
runMultiGSTTNil_ :: Monad m => MultiGSTT ('[] :: [CanReadWrite Type]) m a -> m ()
withReader :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Gettable t ': tr) m a -> MultiGSTT tr m a
withReader_ :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Gettable t ': tr) m a -> MultiGSTT tr m ()
withReaders :: forall (m :: Type -> Type) (rs :: [Type]) (ts :: [CanReadWrite Type]) a. Monad m => HList rs -> MultiGSTT (AppendM (HListMReaders rs) ts) m a -> MultiGSTT ts m a
withWriter :: forall t (m :: Type -> Type) (tr :: [CanReadWrite Type]) a. (Monoid t, Monad m) => MultiGSTT ('Tellable t ': tr) m a -> MultiGSTT tr m (a, t)
withWriterAW :: forall t (m :: Type -> Type) (tr :: [CanReadWrite Type]) a. (Monoid t, Monad m) => MultiGSTT ('Tellable t ': tr) m a -> MultiGSTT tr m (a, t)
withWriterWA :: forall t (m :: Type -> Type) (tr :: [CanReadWrite Type]) a. (Monoid t, Monad m) => MultiGSTT ('Tellable t ': tr) m a -> MultiGSTT tr m (t, a)
withWriterW :: forall t (m :: Type -> Type) (tr :: [CanReadWrite Type]) a. (Monoid t, Monad m) => MultiGSTT ('Tellable t ': tr) m a -> MultiGSTT tr m t
withState :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m (a, t)
withStateAS :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m (a, t)
withStateSA :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m (t, a)
withStateA :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m a
withStateS :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m t
withState_ :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m ()
without :: forall (m :: Type -> Type) (tr :: [CanReadWrite Type]) a (ct :: CanReadWrite Type). Monad m => MultiGSTT tr m a -> MultiGSTT (ct ': tr) m a
mGetRaw :: forall (m :: Type -> Type) (ts :: [CanReadWrite Type]). Monad m => MultiGSTT ts m (HListM ts)
mSetRaw :: forall (m :: Type -> Type) (ts :: [CanReadWrite Type]). Monad m => HListM ts -> MultiGSTT ts m ()
mGetRawR :: forall (m :: Type -> Type) (ts :: [CanReadWrite Type]). (Monad m, HListMGettableClass ts) => MultiGSTT ts m (HList (HListMGettableOnly ts))
mapMultiGSTT :: forall ts (cts :: [CanReadWrite Type]) m a m' a'. ts ~ HListM cts => (m (a, ts) -> m' (a', ts)) -> MultiGSTT cts m a -> MultiGSTT cts m' a'
instance GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.Alternative (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT ts m)
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT ts m)
instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (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 GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT ts m)
instance (GHC.Internal.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.Internal.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.Internal.Base.Monad m, GHC.Internal.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)
instance GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT ts m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.MultiGST.Lazy.MultiGSTT ts)


-- | The multi-valued version of mtl's RWS / RWST
module Control.Monad.Trans.MultiGST
newtype MultiGSTT (ts :: [CanReadWrite Type]) (m :: Type -> Type) a
MultiGSTT :: StateT (HListM ts) m a -> MultiGSTT (ts :: [CanReadWrite Type]) (m :: Type -> Type) a
[runMultiGSTTRaw] :: MultiGSTT (ts :: [CanReadWrite Type]) (m :: Type -> Type) a -> StateT (HListM ts) m a
type MultiGSTTNull = MultiGSTT '[] :: [CanReadWrite Type]
type MultiGST (r :: [CanReadWrite Type]) = 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 :: Type -> Type)
mAsk :: MonadMultiReader a m => m a
class (Monad m, Monoid a) => MonadMultiWriter a (m :: Type -> Type)
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 :: Type -> Type)
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 ('[] :: [CanReadWrite Type]) m a -> m a
runMultiGSTTNil_ :: Monad m => MultiGSTT ('[] :: [CanReadWrite Type]) m a -> m ()
withReader :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Gettable t ': tr) m a -> MultiGSTT tr m a
withReader_ :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Gettable t ': tr) m a -> MultiGSTT tr m ()
withReaders :: forall (m :: Type -> Type) (rs :: [Type]) (ts :: [CanReadWrite Type]) a. Monad m => HList rs -> MultiGSTT (AppendM (HListMReaders rs) ts) m a -> MultiGSTT ts m a
withWriter :: forall t (m :: Type -> Type) (tr :: [CanReadWrite Type]) a. (Monoid t, Monad m) => MultiGSTT ('Tellable t ': tr) m a -> MultiGSTT tr m (a, t)
withWriterAW :: forall t (m :: Type -> Type) (tr :: [CanReadWrite Type]) a. (Monoid t, Monad m) => MultiGSTT ('Tellable t ': tr) m a -> MultiGSTT tr m (a, t)
withWriterWA :: forall t (m :: Type -> Type) (tr :: [CanReadWrite Type]) a. (Monoid t, Monad m) => MultiGSTT ('Tellable t ': tr) m a -> MultiGSTT tr m (t, a)
withWriterW :: forall t (m :: Type -> Type) (tr :: [CanReadWrite Type]) a. (Monoid t, Monad m) => MultiGSTT ('Tellable t ': tr) m a -> MultiGSTT tr m t
withState :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m (a, t)
withStateAS :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m (a, t)
withStateSA :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m (t, a)
withStateA :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m a
withStateS :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m t
withState_ :: forall (m :: Type -> Type) t (tr :: [CanReadWrite Type]) a. Monad m => t -> MultiGSTT ('Settable t ': tr) m a -> MultiGSTT tr m ()
without :: forall (m :: Type -> Type) (tr :: [CanReadWrite Type]) a (ct :: CanReadWrite Type). Monad m => MultiGSTT tr m a -> MultiGSTT (ct ': tr) m a
mapMultiGSTT :: forall ts (cts :: [CanReadWrite Type]) m a m' a'. ts ~ HListM cts => (m (a, ts) -> m' (a', ts)) -> MultiGSTT cts m a -> MultiGSTT cts m' a'
mGetRawR :: forall (m :: Type -> Type) (ts :: [CanReadWrite Type]). (Monad m, HListMGettableClass ts) => MultiGSTT ts m (HList (HListMGettableOnly ts))
mSetRaw :: forall (m :: Type -> Type) (ts :: [CanReadWrite Type]). Monad m => HListM ts -> MultiGSTT ts m ()
mGetRaw :: forall (m :: Type -> Type) (ts :: [CanReadWrite Type]). Monad m => MultiGSTT ts m (HListM ts)
