Control.Monad.Trans.StateBag.Pure

State bag monad transformer which runs on any monad stack.

Documentation

data StateBaggerT bag m a

Monad transformer for building state bags.

Instances

MonadTrans (StateBaggerT bag)

Methods

lift :: Monad m => m a -> StateBaggerT bag m a

Monad m => Monad (StateBaggerT bag m)

Methods

(>>=) :: StateBaggerT bag m a -> (a -> StateBaggerT bag m b) -> StateBaggerT bag m b

(>>) :: StateBaggerT bag m a -> StateBaggerT bag m b -> StateBaggerT bag m b

return :: a -> StateBaggerT bag m a

fail :: String -> StateBaggerT bag m a

Functor m => Functor (StateBaggerT bag m)

Methods

fmap :: (a -> b) -> StateBaggerT bag m a -> StateBaggerT bag m b

(<$) :: a -> StateBaggerT bag m b -> StateBaggerT bag m a

Monad m => Applicative (StateBaggerT bag m)

Methods

pure :: a -> StateBaggerT bag m a

(<*>) :: StateBaggerT bag m (a -> b) -> StateBaggerT bag m a -> StateBaggerT bag m b

(*>) :: StateBaggerT bag m a -> StateBaggerT bag m b -> StateBaggerT bag m b

(<*) :: StateBaggerT bag m a -> StateBaggerT bag m b -> StateBaggerT bag m a

MonadIO m => MonadIO (StateBaggerT bag m)

Methods

liftIO :: IO a -> StateBaggerT bag m a

PrimMonad m => PrimMonad (StateBaggerT bag m)

Associated Types

type PrimState (StateBaggerT bag m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (StateBaggerT bag m)) -> (#VoidRep, PtrRepLifted, State# (PrimState (StateBaggerT bag m)), a#)) -> StateBaggerT bag m a

type PrimState (StateBaggerT bag m)

type PrimState (StateBaggerT bag m) = PrimState m

runBagger :: Monad m => StateBaggerT '[] m a -> m a

Run an empty state bagger on top of a monad stack.

addItem :: forall item bag m a. Monad m => item -> StateBaggerT (item ': bag) m a -> StateBaggerT bag m a

Run a state bagger with one additional item.

topItem :: forall item bag m. Monad m => StateBaggerT (item ': bag) m item

Get the value of the top item in a state bagger.

stackItem :: forall item bag m a. Monad m => item -> StateBaggerT (item ': bag) m a -> StateBaggerT bag m (a, item)

Run a state bagger with one additional item and capture the final value of that item on return.

data StateBagT bag m a

State bag monad transformer where the state items are represented by the type-level list bag.

Instances

MonadTrans (StateBagT bag)

Methods

lift :: Monad m => m a -> StateBagT bag m a

Monad m => Monad (StateBagT bag m)

Methods

(>>=) :: StateBagT bag m a -> (a -> StateBagT bag m b) -> StateBagT bag m b

(>>) :: StateBagT bag m a -> StateBagT bag m b -> StateBagT bag m b

return :: a -> StateBagT bag m a

fail :: String -> StateBagT bag m a

Functor m => Functor (StateBagT bag m)

Methods

fmap :: (a -> b) -> StateBagT bag m a -> StateBagT bag m b

(<$) :: a -> StateBagT bag m b -> StateBagT bag m a

Monad m => Applicative (StateBagT bag m)

Methods

pure :: a -> StateBagT bag m a

(<*>) :: StateBagT bag m (a -> b) -> StateBagT bag m a -> StateBagT bag m b

(*>) :: StateBagT bag m a -> StateBagT bag m b -> StateBagT bag m b

(<*) :: StateBagT bag m a -> StateBagT bag m b -> StateBagT bag m a

MonadIO m => MonadIO (StateBagT bag m)

Methods

liftIO :: IO a -> StateBagT bag m a

PrimMonad m => PrimMonad (StateBagT bag m)

Associated Types

type PrimState (StateBagT bag m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (StateBagT bag m)) -> (#VoidRep, PtrRepLifted, State# (PrimState (StateBagT bag m)), a#)) -> StateBagT bag m a

Monad m => StateBagMonad (StateBagT bag m)

Associated Types

type Bag (StateBagT bag m :: * -> *) :: [*]

type BagBase (StateBagT bag m :: * -> *) :: * -> *

Methods

getItem :: ElementIndex item (Bag (StateBagT bag m)) => StateBagT bag m item

putItem :: ElementIndex item (Bag (StateBagT bag m)) => item -> StateBagT bag m ()

modifyItemM :: ElementIndex item (Bag (StateBagT bag m)) => (item -> StateBagT bag m item) -> StateBagT bag m ()

type PrimState (StateBagT bag m)

type PrimState (StateBagT bag m) = PrimState m

type Bag (StateBagT bag m)

type Bag (StateBagT bag m) = bag

type BagBase (StateBagT bag m)

type BagBase (StateBagT bag m) = m

makeBag :: forall bag m a. (Monad m, ElementCount bag) => StateBagT bag m a -> StateBaggerT bag m a

Runs a state bag with the items prepared in a state bagger.

getItem :: forall m item bag. (Monad m, ElementIndex item bag) => StateBagT (bag :: [*]) m item

Gets the current value of item from the bag.

putItem :: forall m item bag. (Monad m, ElementIndex item bag) => item -> StateBagT (bag :: [*]) m ()

Stores a new value of item in the bag.

modifyItemM :: forall m item bag. (Monad m, ElementIndex item bag) => (item -> StateBagT bag m item) -> StateBagT bag m ()

Applies a monadic function to an item in the bag and stores the result.

class ElementCount a

Type-class for counting the number of elements in a type-level list.

Minimal complete definition

elemCount

Instances

ElementCount ([] *)

Methods

elemCount :: Proxy [*] [*] -> Int

ElementCount xs => ElementCount ((:) * x xs)

Methods

elemCount :: Proxy [*] ((* ': x) xs) -> Int

class ElementIndex x xs

Type-class for finding the index of an element in a type-level list.

Minimal complete definition

elemIndex

Instances

ElementIndex x xs => ElementIndex x ((:) * y xs)

Methods

elemIndex :: Proxy * x -> Proxy [*] ((* ': y) xs) -> Int

ElementIndex x ((:) * x xs)

Methods

elemIndex :: Proxy * x -> Proxy [*] ((* ': x) xs) -> Int