FP.Prelude.Effects

Documentation

class MonadMonoid m where

Methods

mnull :: m a

(<⧺>) :: m a -> m a -> m a infixr 4

Instances

MonadMonoid (Parser t)

class MonadBot m where

Methods

mbot :: m a

Instances

MonadBot (PathSensitiveM val)

Join val => MonadBot (FlowInsensitiveM val)

Join val => MonadBot (FlowSensitiveM val)

MonadBot m => MonadBot (PolyStateT s m)

class MonadJoin m where

Methods

(<⊔>) :: m a -> m a -> m a infixr 4

Instances

MonadJoin (PathSensitiveM val)

Join val => MonadJoin (FlowInsensitiveM val)

Join val => MonadJoin (FlowSensitiveM val)

MonadJoin m => MonadJoin (PolyStateT s m)

class MonadTop m where

Methods

mtop :: m a

class MonadMeet m where

Methods

(<⊓>) :: m a -> m a -> m a infixr 5

class (MonadBot m, MonadJoin m) => MonadJoinLattice m

Instances

MonadJoinLattice (PathSensitiveM val)

Join val => MonadJoinLattice (FlowInsensitiveM val)

Join val => MonadJoinLattice (FlowSensitiveM val)

MonadJoinLattice m => MonadJoinLattice (PolyStateT s m)

mnullMaybe :: (Monad m, MonadMonoid m) => Maybe a -> m a

mbotMaybe :: (Monad m, MonadBot m) => Maybe a -> m a

mconcat :: (MonadMonoid m, ToFold (m a) t) => t -> m a

mlist :: (Monad m, MonadMonoid m, ToFold a t) => t -> m a

msum :: (MonadJoinLattice m, ToFold (m a) t) => t -> m a

mset :: (Monad m, MonadJoinLattice m, ToFold a t) => t -> m a

type MonadRWS r o s m = (MonadReader r m, MonadWriter o m, MonadState s m)

newtype FailureT m a

Constructors

FailureT

Fields

runFailureT :: m (Maybe a)

Instances

FunctorFunctor FailureT

FunctorDiscard FailureT

FunctorUnit FailureT

class MonadFailure m where

Methods

failureE :: FailureT m ↝ m

failureI :: m ↝ FailureT m

Instances

MonadFailure PrettyM

MonadFailure (GreedyParser t)

(Functor m, Monoid o, MonadFailure m) => MonadFailure (RWST r o s m)

effMaybe :: MonadFailure m => m (Maybe a) -> m a

abort :: (Monad m, MonadFailure m) => m a

abortMaybe :: (Monad m, MonadFailure m) => Maybe a -> m a

obsMaybe :: MonadFailure m => m a -> m (Maybe a)

(<|>) :: (Monad m, MonadFailure m) => m a -> m a -> m a

tries :: (Monad m, MonadFailure m) => [m a] -> m a

newtype ErrorT e m a

Constructors

ErrorT

Fields

runErrorT :: m (e ⨄ a)

Instances

FunctorFunctor (ErrorT e)

FunctorDiscard (ErrorT e)

FunctorUnit (ErrorT e)

class MonadError e m | m -> e where

Methods

errorE :: ErrorT e m ↝ m

errorI :: m ↝ ErrorT e m

Instances

MonadError Doc StampM

(Functor m, Monoid o, MonadError e m) => MonadError e (RWST r o s m)

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

effError :: MonadError e m => m (e ⨄ a) -> m a

throw :: (Monad m, MonadError e m) => e -> m a

throwSum :: (Monad m, MonadError e m) => (e ⨄ a) -> m a

throwMaybe :: (Monad m, MonadError e m) => e -> Maybe a -> m a

obsError :: MonadError e m => m a -> m (e ⨄ a)

catch :: (Monad m, MonadError e m) => m a -> (e -> m a) -> m a

newtype ReaderT r m a

Constructors

ReaderT

Fields

runReaderT :: r -> m a

Instances

FunctorFunctor (ReaderT * r)

FunctorDiscard (ReaderT * r)

FunctorUnit (ReaderT * r)

class MonadReader r m | m -> r where

Methods

readerE :: ReaderT r m ↝ m

readerI :: m ↝ ReaderT r m

Instances

MonadReader PrettyEnv PrettyM

MonadReader StampEnv StampM

Functor m => MonadReader r (RWST r o s m)

MonadReader (ParserEnv * t) (Parser t)

MonadReader (ParserEnv * t) (GreedyParser t)

runReaderTWith :: r -> ReaderT r m a -> m a

effReader :: MonadReader r m => (r -> m a) -> m a

ask :: (Monad m, MonadReader r m) => m r

askL :: (Monad m, MonadReader r m) => Lens r a -> m a

obsReader :: MonadReader r m => m a -> r -> m a

local :: MonadReader r m => (r -> r) -> m a -> m a

localOn :: MonadReader r m => m a -> (r -> r) -> m a

newtype WriterT o m a

Constructors

WriterT

Fields

runWriterT :: m (a, o)

Instances

FunctorFunctor (WriterT o)

FunctorDiscard (WriterT o)

Monoid o => FunctorUnit (WriterT o)

class MonadWriter o m | m -> o where

Methods

writerE :: WriterT o m ↝ m

writerI :: m ↝ WriterT o m

Instances

MonadWriter PrettyOut PrettyM

(Functor m, Monoid o) => MonadWriter o (RWST r o s m)

MonadWriter (ParserOut t) (Parser t)

MonadWriter (ParserOut t) (GreedyParser t)

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

mapOutput :: Functor m => (o₁ -> o₂) -> WriterT o₁ m a -> WriterT o₂ m a

effWriter :: MonadWriter o m => m (a, o) -> m a

tell :: (Monad m, MonadWriter o m) => o -> m ()

obsWriter :: MonadWriter o m => m a -> m (a, o)

hijack :: MonadWriter o m => m a -> m (a, o)

newtype StateT s m a

Constructors

StateT

Fields

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

Instances

FunctorFunctor (StateT s)

FunctorDiscard (StateT s)

FunctorUnit (StateT s)

GaloisTransformer ς m => GaloisTransformer (StateΠ s ς) (StateT s m)

class MonadState s m | m -> s where

Methods

stateE :: StateT s m ↝ m

stateI :: m ↝ StateT s m

Instances

MonadState PrettyState PrettyM

MonadState StampState StampM

Functor m => MonadState s (PolyStateT s m)

Functor m => MonadState s (RWST r o s m)

MonadState (ParserState t) (Parser t)

MonadState (ParserState t) (GreedyParser t)

MonadState (LamIfState val) (PathSensitiveM val)

Join val => MonadState (LamIfState val) (FlowInsensitiveM val)

Join val => MonadState (LamIfState val) (FlowSensitiveM val)

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

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

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

stateLens :: Functor m => Lens s₁ s₂ -> StateT s₂ m ↝ StateT s₁ m

effState :: MonadState s m => (s -> m (a, s)) -> m a

get :: (Monad m, MonadState s m) => m s

getL :: (Monad m, MonadState s m) => Lens s a -> m a

put :: (Monad m, MonadState s m) => s -> m ()

putL :: (Monad m, MonadState s m) => Lens s a -> a -> m ()

modifyM :: (Monad m, MonadState s m) => (s -> m s) -> m ()

modifyLM :: (Monad m, MonadState s m) => Lens s a -> (a -> m a) -> m ()

modify :: (Monad m, MonadState s m) => (s -> s) -> m ()

modifyL :: (Monad m, MonadState s m) => Lens s a -> (a -> a) -> m ()

getAndPut :: (Monad m, MonadState s m) => s -> m s

getAndPutL :: (Monad m, MonadState s m) => Lens s a -> a -> m a

next :: (Monad m, MonadState s m, Peano s) => m s

nextL :: (Monad m, MonadState s m, Peano a) => Lens s a -> m a

bump :: (Monad m, MonadState s m, Peano s) => m ()

bumpL :: (Monad m, MonadState s m, Peano a) => Lens s a -> m ()

obsState :: MonadState s m => m a -> s -> m (a, s)

localize :: (Monad m, MonadState s m) => m a -> m (a, s)

newtype NondetAppendT m a

Constructors

NondetAppendT

Fields

runNondetAppendT :: m [a]

Instances

FunctorFunctor NondetAppendT

FunctorDiscard NondetAppendT

FunctorUnit NondetAppendT

class MonadNondetAppend m where

Methods

nondetAppendE :: NondetAppendT m ↝ m

nondetAppendI :: m ↝ NondetAppendT m

newtype NondetJoinT m a

Constructors

NondetJoinT

Fields

runNondetJoinT :: m (𝒫ᵇ a)

Instances

FunctorFunctor NondetJoinT

FunctorDiscard NondetJoinT

FunctorUnit NondetJoinT

(GaloisTransformer ς m, Functorial * JoinLattice m) => GaloisTransformer (NondetJoinΠ ς) (NondetJoinT m)

class MonadNondetJoin m where

Methods

nondetJoinE :: NondetJoinT m ↝ m

nondetJoinI :: m ↝ NondetJoinT m

newtype FlowAppendT s m a

Constructors

FlowAppendT

Fields

runFlowAppendT :: s -> m (a ⇰♭⧺ s)

Instances

FunctorFunctor (FlowAppendT s)

Monoid s => FunctorDiscard (FlowAppendT s)

FunctorUnit (FlowAppendT s)

class MonadFlowAppend s m | m -> s where

Methods

flowAppendE :: FlowAppendT s m ↝ m

flowAppendI :: m ↝ FlowAppendT s m

newtype FlowJoinT s m a

Constructors

FlowJoinT

Fields

runFlowJoinT :: s -> m (a ⇰♭⊔ s)

Instances

FunctorFunctor (FlowJoinT s)

JoinLattice s => FunctorDiscard (FlowJoinT s)

FunctorUnit (FlowJoinT s)

(GaloisTransformer ς m, Functorial * JoinLattice m, JoinLattice s) => GaloisTransformer (FlowJoinΠ s ς) (FlowJoinT s m)

class MonadFlowJoin s m | m -> s where

Methods

flowJoinE :: FlowJoinT s m ↝ m

flowJoinI :: m ↝ FlowJoinT s m

newtype ContT r m a

Constructors

ContT

Fields

runContT :: (a -> m r) -> m r

Instances

FunctorIsoFunctor (ContT * r)

class MonadCont r m | m -> r where

Methods

contE :: ContT r m ↝ m

contI :: m ↝ ContT r m

evalContT :: Monad m => ContT r m r -> m r

effCont :: MonadCont r m => ((a -> m r) -> m r) -> m a

callCC :: MonadCont r m => ((a -> m r) -> m r) -> m a

obsCont :: MonadCont r m => m a -> (a -> m r) -> m r

withC :: MonadCont r m => (a -> m r) -> m a -> m r

reset :: (Monad m, MonadCont r m) => m r -> m r

modifyC :: (Monad m, MonadCont r m) => (r -> m r) -> m a -> m a

newtype OpaqueContT k r m a

Constructors

OpaqueContT

Fields

runOpaqueContT :: k r m a -> m r

Instances

Isomorphic3 * (* -> *) (ContFun * r) (k r) => FunctorIsoFunctor (OpaqueContT * * k r)

class MonadOpaqueCont k r m | m -> k, m -> r where

Methods

opaqueContE :: OpaqueContT k r m ↝ m

opaqueContI :: m ↝ OpaqueContT k r m

newtype ContFun r m a

Constructors

ContFun

Fields

runContFun :: a -> m r

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

evalOpaqueContT :: (Monad m, Isomorphic3 (ContFun r) (k r)) => OpaqueContT k r m r -> m r

runMetaContT :: Isomorphic3 (ContFun r) (k r) => OpaqueContT k r m a -> (a -> m r) -> m r

runMetaContTWith :: Isomorphic3 (ContFun r) (k r) => (a -> m r) -> OpaqueContT k r m a -> m r

metaContT :: Isomorphic3 (ContFun r) (k r) => ((a -> m r) -> m r) -> OpaqueContT k r m a

meta :: Isomorphic3 (ContFun r) (k r) => OpaqueContT k r m ↝ ContT r m

opaque :: Isomorphic3 (ContFun r) (k r) => ContT r m ↝ OpaqueContT k r m

effOpaqueCont :: MonadOpaqueCont k r m => (k r m a -> m r) -> m a

callCCOpaque :: MonadOpaqueCont k r m => (k r m a -> m r) -> m a

obsOpaqueCont :: MonadOpaqueCont k r m => m a -> k r m a -> m r

withCOpaque :: MonadOpaqueCont k r m => k r m a -> m a -> m r