FP.Monads

Documentation

newtype ID a

Constructors

ID

Fields

unID :: a

Instances

Monad ID

Bind ID

Product ID

Applicative ID

FunctorM ID

Functor ID

Unit ID

Inject ID

Commute ID ListSet

MonadStep ID ID

Functorial * JoinLattice ID

Functorial * Top ID

Functorial * Join ID

Functorial * Bot ID

Functorial * Monoid ID

Functorial * Pretty ID

Isomorphism2 * (PSΣ ν lτ dτ) (PSΣ' ν lτ dτ)

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

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

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

Morphism2 * (PSΣ ν lτ dτ) (PSΣ' ν lτ dτ)

Morphism2 * (PSΣ' ν lτ dτ) (PSΣ ν 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τ)

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

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

Eq a => Eq (ID a)

Ord a => Ord (ID a)

JoinLattice a => JoinLattice (ID a)

Top a => Top (ID a)

Join a => Join (ID a)

Bot a => Bot (ID a)

Monoid a => Monoid (ID a)

PartialOrder a => PartialOrder (ID a)

Pretty a => Pretty (ID a)

newtype IDT m a

Constructors

IDT

Fields

unIDT :: 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 (s, a)

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 -> (s, a)

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 :: Functor m => Lens s1 s2 -> StateT s2 m ~> StateT s1 m

stateLensE :: (MonadState 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)

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

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

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

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

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

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

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

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

Monad m => Applicative (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 (s, o, a)

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)

newtype ListT m a

Constructors

ListT

Fields

unListT :: m [a]

Instances

FunctorFunctor2 ListT

FunctorJoin2 ListT

FunctorUnit2 ListT

Functorial * Monoid m => Functorial * Monoid (ListT m)

(Functor m, MonadState s m, Functorial * Monoid m, Monoid s) => MonadState s (ListT m)

Functorial * Monoid m => MonadAppend (ListT m)

Functorial * Monoid m => MonadBot (ListT m)

(Monad m, Functorial * Monoid m) => Monad (ListT m)

(Monad m, Functorial * Monoid m) => Bind (ListT m)

(Monad m, Functorial * Monoid m) => Product (ListT m)

(Monad m, Functorial * Monoid m) => Applicative (ListT m)

Functor m => Functor (ListT m)

Unit m => Unit (ListT m)

Functorial * Monoid m => Monoid (ListT m a)

(Functorial * Pretty m, Pretty a) => Pretty (ListT m a)

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

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

newtype ListSetT m a

Constructors

ListSetT

Fields

unListSetT :: m (ListSet a)

Instances

FunctorFunctor2 ListSetT

FunctorJoin2 ListSetT

FunctorUnit2 ListSetT

(Functor m, MonadState s m, Functorial * JoinLattice m, JoinLattice s) => MonadState s (ListSetT m)

Functorial * JoinLattice m => MonadPlus (ListSetT m)

Functorial * JoinLattice m => MonadBot (ListSetT m)

(Monad m, Functorial * JoinLattice m) => Monad (ListSetT m)

(Monad m, Functorial * JoinLattice m) => Bind (ListSetT m)

(Monad m, Functorial * JoinLattice m) => Product (ListSetT m)

(Monad m, Functorial * JoinLattice m) => Applicative (ListSetT m)

Functor m => Functor (ListSetT m)

Unit m => Unit (ListSetT m)

(MonadStep ς m, Functorial * JoinLattice m) => MonadStep ((:.:) * * ς ListSet) (ListSetT m)

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 } {{{

newtype ListSetWithTopT m a

Constructors

ListSetWithTopT

Fields

unListSetWithTopT :: m (ListSetWithTop a)

Instances

FunctorFunctor2 ListSetWithTopT

FunctorJoin2 ListSetWithTopT

FunctorUnit2 ListSetWithTopT

Functorial * JoinLattice m => MonadPlus (ListSetWithTopT m)

Functorial * Top m => MonadTop (ListSetWithTopT m)

Functorial * JoinLattice m => MonadBot (ListSetWithTopT m)

(Monad m, Functorial * JoinLattice m, Functorial * Top m) => Monad (ListSetWithTopT m)

(Monad m, Functorial * JoinLattice m, Functorial * Top m) => Bind (ListSetWithTopT m)

(Monad m, Functorial * JoinLattice m, Functorial * Top m) => Product (ListSetWithTopT m)

(Monad m, Functorial * JoinLattice m, Functorial * Top m) => Applicative (ListSetWithTopT m)

Functor m => Functor (ListSetWithTopT m)

Unit m => Unit (ListSetWithTopT m)

(MonadStep ς m, Functorial * JoinLattice m, Functorial * Top m) => MonadStep ((:.:) * * ς ListSetWithTop) (ListSetWithTopT m)

listSetWithTopCommute :: Functor m => ListSetWithTopT (ListSetWithTopT m) ~> ListSetWithTopT (ListSetWithTopT m)

newtype SetT m a

Constructors

SetT

Fields

unSetT :: m (Set a)

Instances

Functorial * JoinLattice m => MonadPlus (SetT m)

Functorial * JoinLattice m => MonadBot (SetT m)

(Functorial * JoinLattice m, Monad m) => Bind (SetT m)

(Functor m, Product m) => Product (SetT m)

mapSetT :: (m (Set a) -> m (Set b)) -> SetT m a -> SetT m b

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

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

type Kon r = ContT r ID

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

evalKon :: Kon r r -> r

newtype ContFun r m a

Constructors

ContFun

Fields

unContFun :: a -> m r

Instances

Morphism3 * (* -> *) (CPSKon r) (ContFun * r)

Morphism3 * (* -> *) (CPSKon r) (ContFun * r)

Isomorphism3 * (* -> *) (ContFun * r) (CPSKon r)

Isomorphism3 * (* -> *) (ContFun * r) (CPSKon r)

Morphism3 * (* -> *) (ContFun * r) (CPSKon r)

Morphism3 * (* -> *) (ContFun * r) (CPSKon r)

type OpaqueKon k r = OpaqueContT k r ID

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

makeMetaKonT :: Morphism3 (k r) (ContFun r) => ((a -> m r) -> m r) -> OpaqueContT k r m a

runMetaKonT :: Morphism3 (ContFun r) (k r) => OpaqueContT k r m a -> (a -> m r) -> m r

runMetaKonTWith :: Morphism3 (ContFun r) (k r) => (a -> m r) -> OpaqueContT k r m a -> m r

evalOpaqueKonT :: (Unit m, Morphism3 (ContFun r) (k r)) => OpaqueContT k r m r -> m r

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

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

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

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

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

metaKonT :: Morphism3 (ContFun r) (k r) => OpaqueContT k r m ~> ContT r m

opaqueContT :: Morphism3 (k r) (ContFun r) => ContT r m ~> OpaqueContT k r m

class Balloon k r | k -> r where

Methods

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

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

Instances

Balloon CPSKon Call

Balloon CPSKon Call

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

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

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

maybeWriterCommute :: Functor 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 :: ErrorT e (ReaderT r m) ~> ReaderT r (ErrorT e m)

readerErrorCommute :: 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 (ContT (s, r) m) ~> ContT r (StateT s m)

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