Ether.Reader

MonadReader class

class Monad m => MonadReader tag r m | m tag -> r where

Minimal complete definition

(ask | reader), local

Methods

ask :: m r

Retrieves the monad environment.

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

Executes a computation in a modified environment.

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

Retrieves a function of the current environment.

Instances

(LiftLocal t, Monad (t m), MonadReader k tag r m) => MonadReader k tag r (t m)

Methods

ask :: m (t m)

local :: (t m -> t m) -> m a -> m a

reader :: (t m -> a) -> m a

(Monad (trans m), MonadReader k tag r (TaggedTrans * (Type -> Type) [a] effs trans m)) => MonadReader k tag r (TaggedTrans * (Type -> Type) [a] ((:) a eff effs) trans m)

Methods

ask :: m (TaggedTrans * (Type -> Type) [a] ((a ': eff) effs) trans m)

local :: (TaggedTrans * (Type -> Type) [a] ((a ': eff) effs) trans m -> TaggedTrans * (Type -> Type) [a] ((a ': eff) effs) trans m) -> m a -> m a

reader :: (TaggedTrans * (Type -> Type) [a] ((a ': eff) effs) trans m -> a) -> m a

(MonadReader k1 tNew r m, (~) ((* -> *) -> * -> *) trans (IdentityT *)) => MonadReader k tOld r (TaggedTrans * (* -> *) * (TAG_REPLACE k1 k tOld tNew) trans m)

Methods

ask :: m (TaggedTrans * (* -> *) * (TAG_REPLACE k1 k tOld tNew) trans m)

local :: (TaggedTrans * (* -> *) * (TAG_REPLACE k1 k tOld tNew) trans m -> TaggedTrans * (* -> *) * (TAG_REPLACE k1 k tOld tNew) trans m) -> m a -> m a

reader :: (TaggedTrans * (* -> *) * (TAG_REPLACE k1 k tOld tNew) trans m -> a) -> m a

ask :: MonadReader tag r m => m r

Retrieves the monad environment.

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

Executes a computation in a modified environment.

reader :: MonadReader tag r m => (r -> a) -> m a

Retrieves a function of the current environment.

asks

Arguments

:: MonadReader tag r m

=> (r -> a)

The selector function to apply to the environment.

-> m a

Retrieves a function of the current environment.

The Reader monad

type Reader tag r = ReaderT tag r Identity

The parameterizable reader monad.

Computations are functions of a shared environment.

The return function ignores the environment, while >>= passes the inherited environment to both subcomputations.

runReader :: forall tag r a. Reader tag r a -> r -> a

Runs a ReaderT with the given environment and returns the final value.

The ReaderT monad transformer

type ReaderT tag r = TaggedTrans (TAGGED READER tag) (ReaderT r)

The reader monad transformer, which adds a read-only environment to the given monad.

The return function ignores the environment, while >>= passes the inherited environment to both subcomputations.

readerT :: forall tag r m a. (r -> m a) -> ReaderT tag r m a

Constructor for computations in the reader monad transformer.

runReaderT :: forall tag r m a. ReaderT tag r m a -> r -> m a

Runs a ReaderT with the given environment and returns the final value.

The Reader monad (flattened)

type Readers r = ReadersT r Identity

runReaders :: forall p a. Readers p a -> p -> a

The ReaderT monad transformer (flattened)

type ReadersT r = TaggedTrans (READERS (Tags r)) (ReaderT r)

runReadersT :: forall p m a. ReadersT p m a -> p -> m a

MonadReader class (implicit)

type MonadReader' r = MonadReader r r

local' :: forall r m a. MonadReader' r m => (r -> r) -> m a -> m a

ask' :: forall r m. MonadReader' r m => m r

reader' :: forall r m a. MonadReader' r m => (r -> a) -> m a

asks' :: forall r m a. MonadReader' r m => (r -> a) -> m a

The Reader monad (implicit)

type Reader' r = Reader r r

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

The ReaderT monad transformer (implicit)

type ReaderT' r = ReaderT r r

readerT' :: (r -> m a) -> ReaderT' r m a

runReaderT' :: ReaderT' r m a -> r -> m a

Internal labels

data TAGGED e t

data READER

Encode type-level information for ReaderT.

Instances

Handle * * READER r (ReaderT Type r)

Methods

handling :: Monad m => (HandleConstraint READER r (ReaderT Type r) p trans m -> r) -> r

type HandleSuper kp * READER r trans

type HandleSuper kp * READER r trans = ()

type HandleConstraint * * READER r trans m

type HandleConstraint * * READER r trans m = MonadReader r (trans m)

type family READERS (ts :: HList xs) :: [Type] where ...

Equations

READERS HNil = '[]

READERS (HCons t ts) = TAGGED READER t ': READERS ts