FP.Monads

Documentation

newtype ID a

Constructors

ID

Fields

runID :: a

Instances

Monad ID

Bind ID

Applicative ID

Product ID

FunctorM ID

Functor ID

Unit ID

Inject ID

Commute ID ListSet

MonadStep ID ID

Functorial * JoinLattice ID

Functorial * Monoid ID

Functorial * Pretty ID

Isomorphism2 * (PSΣ val lτ dτ ψ) (PSΣ' val lτ dτ ψ)

Isomorphism2 * (FIΣ val lτ dτ ψ) (FIΣ' val lτ dτ ψ)

Isomorphism2 * (FSΣ val lτ dτ ψ) (FSΣ' val lτ dτ ψ)

Morphism2 * (PSΣ val lτ dτ ψ) (PSΣ' val lτ dτ ψ)

Morphism2 * (PSΣ' val lτ dτ ψ) (PSΣ val lτ dτ ψ)

Morphism2 * (FIΣ val lτ dτ ψ) (FIΣ' val lτ dτ ψ)

Morphism2 * (FIΣ' val lτ dτ ψ) (FIΣ val lτ dτ ψ)

Morphism2 * (FSΣ val lτ dτ ψ) (FSΣ' val lτ dτ ψ)

Morphism2 * (FSΣ' val lτ dτ ψ) (FSΣ val lτ dτ ψ)

Eq a => Eq (ID a)

Ord a => Ord (ID a)

JoinLattice a => JoinLattice (ID a)

Monoid a => Monoid (ID a)

PartialOrder a => PartialOrder (ID a)

Pretty a => Pretty (ID a)

newtype IDT m a

Constructors

IDT

Fields

runIDT :: m a

maybeCommute :: Functor m => MaybeT (MaybeT m) ~> MaybeT (MaybeT m)

mapError :: Functor m => (e1 -> e2) -> ErrorT e1 m a -> ErrorT e2 m a

errorCommute :: Functor m => ErrorT e (ErrorT e m) ~> ErrorT e (ErrorT e m)

type Reader r = ReaderT r ID

runReader :: r -> Reader r a -> a

readerCommute :: ReaderT r1 (ReaderT r2 m) ~> ReaderT r2 (ReaderT r1 m)

execWriterT :: Functor m => WriterT o m a -> m o

mapOutput :: Functor m => (o1 -> o2) -> WriterT o1 m a -> WriterT o2 m a

writerCommute :: Functor m => WriterT o1 (WriterT o2 m) ~> WriterT o2 (WriterT o1 m)

runStateT :: s -> StateT s m a -> m (a, s)

evalStateT :: Functor m => s -> StateT s m a -> m a

execStateT :: Functor m => s -> StateT s m a -> m s

mapStateT :: Functor m => (s1 -> s2) -> (s2 -> s1) -> StateT s1 m a -> StateT s2 m a

type State s = StateT s ID

runState :: s -> State s a -> (a, s)

evalState :: s -> State s a -> a

execState :: s -> State s a -> s

stateCommute :: Functor m => StateT s1 (StateT s2 m) ~> StateT s2 (StateT s1 m)

stateLens :: Monad m => Lens s1 s2 -> StateT s2 m ~> StateT s1 m

stateLensE :: (MonadStateE s1 m, Monad m) => Lens s1 s2 -> StateT s2 m ~> m

newtype AddStateT s12 s1 m a

Constructors

AddStateT

Fields

runAddStateT :: StateT s1 m a

Instances

(Functor m, MonadState s2 m, Isomorphism s12 (s1, s2)) => MonadState s12 (AddStateT * s12 s1 m)

(Functor m, MonadStateE s2 m, Isomorphism s12 (s1, s2)) => MonadStateE s12 (AddStateT * s12 s1 m)

(Functor m, MonadStateI s2 m, Isomorphism s12 (s1, s2)) => MonadStateI s12 (AddStateT * s12 s1 m)

(MonadWriter o m, Monoid o) => MonadWriter o (AddStateT k s12 s1 m)

(MonadWriter o m, Monoid o) => MonadWriterE o (AddStateT k s12 s1 m)

(MonadWriter o m, Monoid o) => MonadWriterI o (AddStateT k s12 s1 m)

MonadReader r m => MonadReader r (AddStateT k s12 s1 m)

MonadReaderE r m => MonadReaderE r (AddStateT k s12 s1 m)

MonadReaderI r m => MonadReaderI r (AddStateT k s12 s1 m)

MonadPlus m => MonadPlus (AddStateT k s12 s1 m)

MonadConcat m => MonadConcat (AddStateT k s12 s1 m)

MonadZero m => MonadZero (AddStateT k s12 s1 m)

Monad m => Monad (AddStateT k s12 s1 m)

Bind m => Bind (AddStateT k s12 s1 m)

Monad m => Applicative (AddStateT k s12 s1 m)

Monad m => Product (AddStateT k s12 s1 m)

Functor m => Functor (AddStateT k s12 s1 m)

Unit m => Unit (AddStateT k s12 s1 m)

(MonadStep ς m, Functor m) => MonadStep ((:.:) * * ς ((,) 𝓈1)) (AddStateT k 𝓈12 𝓈1 m)

mergeState :: Functor m => StateT s1 (StateT s2 m) a -> StateT (s1, s2) m a

splitState :: Functor m => StateT (s1, s2) m a -> StateT s1 (StateT s2 m) a

runRWST :: Functor m => r -> s -> RWST r o s m a -> m (a, o, s)

rwsCommute :: (Monad m, Monoid o1, Monoid o2) => RWST r1 o1 s1 (RWST r2 o2 s2 m) ~> RWST r2 o2 s2 (RWST r1 o1 s1 m)

listCommute :: Functor m => ListT (ListT m) ~> ListT (ListT m)

maybeToList :: Functor m => MaybeT m a -> ListT m a

listSetCommute :: Functor m => ListSetT (ListSetT m) ~> ListSetT (ListSetT m)

PROOF of: left unit := return x >>= k = k x {{{

PROOF of: right unit := aM >>= return = aM {{{

PROOF of: associativity := (aM >>= k1) >>= k2 = { x aM ; k1 x>= k2 } {{{

setCommute :: Functor m => SetT (SetT m) ~> SetT (SetT m)

evalKonT :: Unit m => KonT r m r -> m r

type Kon r = KonT r ID

runKon :: Kon r a -> (a -> r) -> r

evalKon :: Kon r r -> r

runOpaqueKonTWith :: k r m a -> OpaqueKonT k r m a -> m r

makeMetaKonT :: Morphism3 (k r) (KFun r) => ((a -> m r) -> m r) -> OpaqueKonT k r m a

runMetaKonT :: Morphism3 (KFun r) (k r) => OpaqueKonT k r m a -> (a -> m r) -> m r

runMetaKonTWith :: Morphism3 (KFun r) (k r) => (a -> m r) -> OpaqueKonT k r m a -> m r

evalOpaqueKonT :: (Unit m, Morphism3 (KFun r) (k r)) => OpaqueKonT k r m r -> m r

type OpaqueKon k r = OpaqueKonT k r ID

makeOpaqueKon :: (k r ID a -> r) -> OpaqueKon k r a

makeMetaKon :: Morphism3 (k r) (KFun r) => ((a -> r) -> r) -> OpaqueKon k r a

runOpaqueKon :: OpaqueKon k r a -> k r ID a -> r

runMetaKon :: Morphism3 (KFun r) (k r) => OpaqueKon k r a -> (a -> r) -> r

evalOpaqueKon :: Morphism3 (KFun r) (k r) => OpaqueKon k r r -> r

metaKonT :: Morphism3 (KFun r) (k r) => OpaqueKonT k r m ~> KonT r m

opaqueKonT :: Morphism3 (k r) (KFun r) => KonT r m ~> OpaqueKonT k r m

class Balloon k r | k -> r where

Methods

inflate :: Monad m => k r m ~> k r (OpaqueKonT k r m)

deflate :: Monad m => k r (OpaqueKonT k r m) ~> k r m

Instances

Balloon CPSKon SGCall

maybeReaderCommute :: Monad m => MaybeT (ReaderT r m) ~> ReaderT r (MaybeT m)

readerMaybeCommute :: Monad m => ReaderT r (MaybeT m) ~> MaybeT (ReaderT r m)

writerMaybeCommute :: (Monoid w, Monad m) => WriterT w (MaybeT m) ~> MaybeT (WriterT w m)

maybeWriterCommute :: Monad m => MaybeT (WriterT w m) ~> WriterT w (MaybeT m)

maybeStateCommute :: Functor m => MaybeT (StateT s m) ~> StateT s (MaybeT m)

stateMaybeCommute :: Functor m => StateT s (MaybeT m) ~> MaybeT (StateT s m)

errorReaderCommute :: Monad m => ErrorT e (ReaderT r m) ~> ReaderT r (ErrorT e m)

readerErrorCommute :: Monad m => ReaderT r (ErrorT e m) ~> ErrorT e (ReaderT r m)

errorStateCommute :: Functor m => ErrorT e (StateT s m) ~> StateT s (ErrorT e m)

stateErrorCommute :: Functor m => StateT s (ErrorT e m) ~> ErrorT e (StateT s m)

readerWriterCommute :: ReaderT r (WriterT w m) ~> WriterT w (ReaderT r m)

writerReaderCommute :: WriterT w (ReaderT r m) ~> ReaderT r (WriterT w m)

readerStateCommute :: Functor m => ReaderT r (StateT s m) ~> StateT s (ReaderT r m)

stateReaderCommute :: Functor m => StateT s (ReaderT r m) ~> ReaderT r (StateT s m)

readerRWSCommute :: (Monad m, Monoid o) => ReaderT r1 (RWST r2 o s m) ~> RWST r2 o s (ReaderT r1 m)

rwsReaderCommute :: (Monad m, Monoid o) => RWST r1 o s (ReaderT r2 m) ~> ReaderT r2 (RWST r1 o s m)

writerStateCommute :: Functor m => WriterT w (StateT s m) ~> StateT s (WriterT w m)

stateWriterCommute :: Functor m => StateT s (WriterT w m) ~> WriterT w (StateT s m)

writerRWSCommute :: (Monad m, Monoid o1, Monoid o2) => WriterT o1 (RWST r o2 s m) ~> RWST r o2 s (WriterT o1 m)

rwsWriterCommute :: (Monad m, Monoid o1, Monoid o2) => RWST r o1 s (WriterT o2 m) ~> WriterT o2 (RWST r o1 s m)

stateRWSCommute :: (Monad m, Monoid o) => StateT s1 (RWST r o s2 m) ~> RWST r o s2 (StateT s1 m)

rwsStateCommute :: (Monad m, Monoid o) => RWST r o s1 (StateT s2 m) ~> StateT s2 (RWST r o s1 m)

stateListCommute :: (Functor m, Monoid s) => StateT s (ListT m) ~> ListT (StateT s m)

listStateCommute :: Functor m => ListT (StateT s m) ~> StateT s (ListT m)

stateListSetCommute :: (Functor m, JoinLattice s) => StateT s (ListSetT m) ~> ListSetT (StateT s m)

listSetStateCommute :: Functor m => ListSetT (StateT s m) ~> StateT s (ListSetT m)

stateKonCommute :: StateT s (KonT (r, s) m) ~> KonT r (StateT s m)

konStateCommute :: KonT r (StateT s m) ~> StateT s (KonT (r, s) m)