Parameterized.Control.Monad.Trans.State.Strict

Documentation

newtype ManyState m s a

Given a ManyState that modifies Many a, and another ManyState that modifes Many b make a State that accepts Many (AppendUnique a b) with the compile time constraint that all the types in (AppendUnique a b) are distinct.

Constructors

ManyState

Fields

• runManyState :: StateT s m a

Instances

Alternative m => PEmpty * (ManyState m) (Many ([] Type))

Methods

pempty :: PUnary (ManyState m) (Many [Type]) id a

Monad m => PPointed * (ManyState m) (Many ([] Type))

Methods

ppure :: a -> PUnary (ManyState m) (Many [Type]) id a

(Monad m, Alternative m, Select a c, Select b c, Amend' a c, Amend' b c, (~) [Type] c (AppendUnique Type a b)) => PAlternative * (ManyState m) (Many a) (Many b) (Many c)

Methods

pappend :: PUnary (ManyState m) (Many a) (Many b) a -> PUnary (ManyState m) (Many a) (Many c) a -> PUnary (ManyState m) (Many a) v a

(Monad m, Select a c, Select b c, Amend' a c, Amend' b c, (~) [Type] c (AppendUnique Type a b)) => PApplicative * (ManyState m) (Many a) (Many b) (Many c)

Methods

papply :: PUnary (ManyState m) (Many a) (Many b) (a -> b) -> PUnary (ManyState m) (Many a) (Many c) a -> PUnary (ManyState m) (Many a) v b

(Monad m, Select a c, Select b c, Amend' a c, Amend' b c, (~) [Type] c (AppendUnique Type a b)) => PMonad * (ManyState m) (Many a) (Many b) (Many c)

Methods

pbind :: PUnary (ManyState m) (Many a) (Many b) a -> (a -> PUnary (ManyState m) (Many a) (Many c) b) -> PUnary (ManyState m) (Many a) v b

Monad m => Monad (ManyState m s)

Methods

(>>=) :: ManyState m s a -> (a -> ManyState m s b) -> ManyState m s b

(>>) :: ManyState m s a -> ManyState m s b -> ManyState m s b

return :: a -> ManyState m s a

fail :: String -> ManyState m s a

Functor m => Functor (ManyState m s)

Methods

fmap :: (a -> b) -> ManyState m s a -> ManyState m s b

(<$) :: a -> ManyState m s b -> ManyState m s a

MonadFix m => MonadFix (ManyState m s)

Methods

mfix :: (a -> ManyState m s a) -> ManyState m s a

MonadFail m => MonadFail (ManyState m s)

Methods

fail :: String -> ManyState m s a

Monad m => Applicative (ManyState m s)

Methods

pure :: a -> ManyState m s a

(<*>) :: ManyState m s (a -> b) -> ManyState m s a -> ManyState m s b

(*>) :: ManyState m s a -> ManyState m s b -> ManyState m s b

(<*) :: ManyState m s a -> ManyState m s b -> ManyState m s a

MonadIO m => MonadIO (ManyState m s)

Methods

liftIO :: IO a -> ManyState m s a

MonadPlus m => Alternative (ManyState m s)

Methods

empty :: ManyState m s a

(<|>) :: ManyState m s a -> ManyState m s a -> ManyState m s a

some :: ManyState m s a -> ManyState m s [a]

many :: ManyState m s a -> ManyState m s [a]

MonadPlus m => MonadPlus (ManyState m s)

Methods

mzero :: ManyState m s a

mplus :: ManyState m s a -> ManyState m s a -> ManyState m s a

Generic (ManyState m s a)

Associated Types

type Rep (ManyState m s a) :: * -> *

Methods

from :: ManyState m s a -> Rep (ManyState m s a) x

to :: Rep (ManyState m s a) x -> ManyState m s a

type PUnary * (ManyState m) s

type PUnary * (ManyState m) s = ManyState m s

type Rep (ManyState m s a)

type Rep (ManyState m s a) = D1 (MetaData "ManyState" "Parameterized.Control.Monad.Trans.State.Strict" "parameterized-0.5.0.0-EMeutE5jJ2JEdVqeGBcPpd" True) (C1 (MetaCons "ManyState" PrefixI True) (S1 (MetaSel (Just Symbol "runManyState") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (StateT s m a))))

newtype ChangingState m st a

Given a ChangingState that changes state from s to t, and another ChangingState that changes state from t to u make a State that changes from s to u with the compile time constraint that all the types in (AppendUnique a b) are distinct. NB. The state is in the snd position to be consistent with StateT.

Constructors

ChangingState

Fields

• runChangingState :: At0 st -> m (a, At1 st)

Instances

Applicative m => PPointed * (ChangingState m) (s, s)

Methods

ppure :: a -> PUnary (ChangingState m) (s, s) id a

Monad m => PApplicative * (ChangingState m) (s, t) (t, u) (s, u)

Methods

papply :: PUnary (ChangingState m) (s, t) (t, u) (a -> b) -> PUnary (ChangingState m) (s, t) (s, u) a -> PUnary (ChangingState m) (s, t) v b

Monad m => PMonad * (ChangingState m) (s, t) (t, u) (s, u)

Methods

pbind :: PUnary (ChangingState m) (s, t) (t, u) a -> (a -> PUnary (ChangingState m) (s, t) (s, u) b) -> PUnary (ChangingState m) (s, t) v b

Functor m => Functor (ChangingState m st)

Methods

fmap :: (a -> b) -> ChangingState m st a -> ChangingState m st b

(<$) :: a -> ChangingState m st b -> ChangingState m st a

Generic (ChangingState m st a)

Associated Types

type Rep (ChangingState m st a) :: * -> *

Methods

from :: ChangingState m st a -> Rep (ChangingState m st a) x

to :: Rep (ChangingState m st a) x -> ChangingState m st a

type PUnary * (ChangingState m) st

type PUnary * (ChangingState m) st = ChangingState m st

type Rep (ChangingState m st a)

type Rep (ChangingState m st a) = D1 (MetaData "ChangingState" "Parameterized.Control.Monad.Trans.State.Strict" "parameterized-0.5.0.0-EMeutE5jJ2JEdVqeGBcPpd" True) (C1 (MetaCons "ChangingState" PrefixI True) (S1 (MetaSel (Just Symbol "runChangingState") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (At0 st -> m (a, At1 st)))))

changingState :: (s -> m (a, t)) -> ChangingState m (s, t) a

Prefer this to using ChangingState to construct as it results in better type inference as it avoids ambiguous type variable st