Control.Monad.Trans.Stack

Documentation

newtype Stack (ts :: [(* -> *) -> * -> *]) (m :: * -> *) a

A computation consisting of a stack of monad transformers and a base monad.

Constructors

Stack

Fields

• runStack :: Stack' ts m a

Instances

(forall (f' :: Type -> Type). Monad f' => Monad (t f'), MonadTrans t, forall (f' :: Type -> Type). Monad f' => Monad (Stack ts f'), MonadTrans (Stack ts)) => MonadTrans (Stack (t ': ts))

Defined in Control.Monad.Trans.Stack

Methods

lift :: Monad m => m a -> Stack (t ': ts) m a

MonadTrans (Stack ([] :: [(Type -> Type) -> Type -> Type]))

Defined in Control.Monad.Trans.Stack

Methods

lift :: Monad m => m a -> Stack [] m a

(forall (f' :: Type -> Type). Monad f' => Monad (t f'), MonadTrans t, Monad f, Monad (Stack ts f)) => Monad (Stack (t ': ts) f)

Defined in Control.Monad.Trans.Stack

Methods

(>>=) :: Stack (t ': ts) f a -> (a -> Stack (t ': ts) f b) -> Stack (t ': ts) f b

(>>) :: Stack (t ': ts) f a -> Stack (t ': ts) f b -> Stack (t ': ts) f b

return :: a -> Stack (t ': ts) f a

fail :: String -> Stack (t ': ts) f a

Monad f => Monad (Stack ([] :: [(Type -> Type) -> Type -> Type]) f)

Defined in Control.Monad.Trans.Stack

Methods

(>>=) :: Stack [] f a -> (a -> Stack [] f b) -> Stack [] f b

(>>) :: Stack [] f a -> Stack [] f b -> Stack [] f b

return :: a -> Stack [] f a

fail :: String -> Stack [] f a

(forall (f' :: Type -> Type). Monad f' => Monad (t f'), Monad f, Monad (Stack ts f)) => Functor (Stack (t ': ts) f)

Defined in Control.Monad.Trans.Stack

Methods

fmap :: (a -> b) -> Stack (t ': ts) f a -> Stack (t ': ts) f b

(<$) :: a -> Stack (t ': ts) f b -> Stack (t ': ts) f a

Functor f => Functor (Stack ([] :: [(Type -> Type) -> Type -> Type]) f)

Defined in Control.Monad.Trans.Stack

Methods

fmap :: (a -> b) -> Stack [] f a -> Stack [] f b

(<$) :: a -> Stack [] f b -> Stack [] f a

(forall (f' :: Type -> Type). Monad f' => Monad (t f'), Monad f, Monad (Stack ts f)) => Applicative (Stack (t ': ts) f)

Defined in Control.Monad.Trans.Stack

Methods

pure :: a -> Stack (t ': ts) f a

(<*>) :: Stack (t ': ts) f (a -> b) -> Stack (t ': ts) f a -> Stack (t ': ts) f b

liftA2 :: (a -> b -> c) -> Stack (t ': ts) f a -> Stack (t ': ts) f b -> Stack (t ': ts) f c

(*>) :: Stack (t ': ts) f a -> Stack (t ': ts) f b -> Stack (t ': ts) f b

(<*) :: Stack (t ': ts) f a -> Stack (t ': ts) f b -> Stack (t ': ts) f a

Applicative f => Applicative (Stack ([] :: [(Type -> Type) -> Type -> Type]) f)

Defined in Control.Monad.Trans.Stack

Methods

pure :: a -> Stack [] f a

(<*>) :: Stack [] f (a -> b) -> Stack [] f a -> Stack [] f b

liftA2 :: (a -> b -> c) -> Stack [] f a -> Stack [] f b -> Stack [] f c

(*>) :: Stack [] f a -> Stack [] f b -> Stack [] f b

(<*) :: Stack [] f a -> Stack [] f b -> Stack [] f a

type family Stack' (ts :: [(* -> *) -> * -> *]) (m :: * -> *) :: * -> * where ...

The type family which we interleave with Stack for its implementation.

Equations

Stack' (t ': ts) m = t (Stack ts m)

Stack' '[] m = m

type family Substack n ts f where ...

Computes a substack, or a suffix, of the given stack of monad transformers.

Equations

Substack Z (t ': ts) f = t (Stack ts f)

Substack (S n) (t ': ts) f = Substack n ts f

data N

Type level natural numbers.

Constructors

S N

Z

class (n :: N) > (m :: N)

Greater than constraint.

Instances

n > m => (S n) > m

Defined in Control.Monad.Trans.Stack

(S n) > Z

Defined in Control.Monad.Trans.Stack

class Uplift n ts f where

A type family used to lift substacks up into the full Stack computation.

Methods

liftSubstack :: Substack n ts f a -> Stack ts f a

Instances

Uplift Z (t ': ts) f

Defined in Control.Monad.Trans.Stack

Methods

liftSubstack :: Substack Z (t ': ts) f a -> Stack (t ': ts) f a

(MonadTrans t, MonadTrans (Stack (t ': ts)), Monad (Stack ts f), Uplift n ts f) => Uplift (S n) (t ': ts) f

Defined in Control.Monad.Trans.Stack

Methods

liftSubstack :: Substack (S n) (t ': ts) f a -> Stack (t ': ts) f a

type family IndexIn t ts where ...

Computes the index of an item in a type level list.

Equations

IndexIn t (t ': ts) = Z

IndexIn t (t' ': ts) = S (IndexIn t ts)

IndexIn t ts = TypeError (((Text "Could not find " :<>: ShowType t) :<>: Text " in list ") :<>: ShowType ts)

uplift :: forall t ts f a. Uplift (IndexIn t ts) ts f => Substack (IndexIn t ts) ts f a -> Stack ts f a

Lifts a substack, or a suffix, of the Stack all the way up into the Stack computation. Expected to be used with TypeApplications.

newtype Runner ts

A Runner for a stack of transformers in an arbitrary monad.

Constructors

Runner (forall f a. Monad f => Stack ts f a -> f a)

class WithRunner ts where

Laws: (runner >>= phi -> run phi (x >>= f)) == (runner >>= phi -> run phi x >>= run phi f)

Minimal complete definition

Nothing

Methods

runner :: (Monad f, Monad (Stack ts f)) => Stack ts f (Runner ts)

withRunner :: (Monad f, Monad (Stack ts f)) => (Runner ts -> Stack ts f a) -> Stack ts f a

Instances

WithRunner ([] :: [(Type -> Type) -> Type -> Type])

Defined in Control.Monad.Trans.Stack

Methods

runner :: (Monad f, Monad (Stack [] f)) => Stack [] f (Runner [])

withRunner :: (Monad f, Monad (Stack [] f)) => (Runner [] -> Stack [] f a) -> Stack [] f a

(Representable t, WithRunner ts, forall (f :: Type -> Type). Monad f => Monad (t f), forall (f :: Type -> Type). Monad f => Monad (Stack ts f), MonadTrans t) => WithRunner (t ': ts)

Defined in Control.Monad.Trans.Stack

Methods

runner :: (Monad f, Monad (Stack (t ': ts) f)) => Stack (t ': ts) f (Runner (t ': ts))

withRunner :: (Monad f, Monad (Stack (t ': ts) f)) => (Runner (t ': ts) -> Stack (t ': ts) f a) -> Stack (t ': ts) f a

class Representable t where

The class of Representable transformers. Basically, these can be constant size containers or functions, or arbitrary combination of the two.

Associated Types

type Rep t

Methods

tabulate :: (Rep t -> f a) -> t f a

index :: t f a -> Rep t -> f a

Instances

Representable (ReaderT r :: (k -> Type) -> k -> Type)

Defined in Control.Monad.Trans.Stack

Associated Types

type Rep (ReaderT r) :: Type

Methods

tabulate :: (Rep (ReaderT r) -> f a) -> ReaderT r f a

index :: ReaderT r f a -> Rep (ReaderT r) -> f a

run :: Monad f => Runner ts -> Stack ts f a -> f a

Run a stack with a Runner