Control.Monad.ReaderSoup

API for running a ReaderSoup

newtype ReaderSoup_ (record :: ((Symbol, *) -> *) -> [(Symbol, *)] -> *) ctxs a

Represents a set of Reader-like monads as a one-layer Reader that can grow and host more Readers, in a way that's more generic than creating you own application stack of Reader and implementing a host of MonadXXX classes, because each of these MonadXXX classes can be implemented once and for all for the ReaderSoup type.

Constructors

ReaderSoup

Fields

• unReaderSoup :: ReaderT (record ElField ctxs) IO a

Instances

MonadBase IO (ReaderSoup_ record ctxs)

Defined in Control.Monad.ReaderSoup

Methods

liftBase :: IO α -> ReaderSoup_ record ctxs α

MonadBaseControl IO (ReaderSoup_ record ctxs)

Defined in Control.Monad.ReaderSoup

Associated Types

type StM (ReaderSoup_ record ctxs) a :: Type

Methods

liftBaseWith :: (RunInBase (ReaderSoup_ record ctxs) IO -> IO a) -> ReaderSoup_ record ctxs a

restoreM :: StM (ReaderSoup_ record ctxs) a -> ReaderSoup_ record ctxs a

Monad (ReaderSoup_ record ctxs)

Defined in Control.Monad.ReaderSoup

Methods

(>>=) :: ReaderSoup_ record ctxs a -> (a -> ReaderSoup_ record ctxs b) -> ReaderSoup_ record ctxs b

(>>) :: ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs b -> ReaderSoup_ record ctxs b

return :: a -> ReaderSoup_ record ctxs a

fail :: String -> ReaderSoup_ record ctxs a

Functor (ReaderSoup_ record ctxs)

Defined in Control.Monad.ReaderSoup

Methods

fmap :: (a -> b) -> ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs b

(<$) :: a -> ReaderSoup_ record ctxs b -> ReaderSoup_ record ctxs a

MonadFail (ReaderSoup_ record ctxs)

Defined in Control.Monad.ReaderSoup

Methods

fail :: String -> ReaderSoup_ record ctxs a

Applicative (ReaderSoup_ record ctxs)

Defined in Control.Monad.ReaderSoup

Methods

pure :: a -> ReaderSoup_ record ctxs a

(<*>) :: ReaderSoup_ record ctxs (a -> b) -> ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs b

liftA2 :: (a -> b -> c) -> ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs b -> ReaderSoup_ record ctxs c

(*>) :: ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs b -> ReaderSoup_ record ctxs b

(<*) :: ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs b -> ReaderSoup_ record ctxs a

Alternative (ReaderSoup_ record ctxs)

Defined in Control.Monad.ReaderSoup

Methods

empty :: ReaderSoup_ record ctxs a

(<|>) :: ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs a

some :: ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs [a]

many :: ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs [a]

MonadPlus (ReaderSoup_ record ctxs)

Defined in Control.Monad.ReaderSoup

Methods

mzero :: ReaderSoup_ record ctxs a

mplus :: ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs a

MonadIO (ReaderSoup_ record ctxs)

Defined in Control.Monad.ReaderSoup

Methods

liftIO :: IO a -> ReaderSoup_ record ctxs a

MonadThrow (ReaderSoup_ record ctxs)

Defined in Control.Monad.ReaderSoup

Methods

throwM :: Exception e => e -> ReaderSoup_ record ctxs a

MonadCatch (ReaderSoup_ record ctxs)

Defined in Control.Monad.ReaderSoup

Methods

catch :: Exception e => ReaderSoup_ record ctxs a -> (e -> ReaderSoup_ record ctxs a) -> ReaderSoup_ record ctxs a

MonadMask (ReaderSoup_ record ctxs)

Defined in Control.Monad.ReaderSoup

Methods

mask :: ((forall a. ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs a) -> ReaderSoup_ record ctxs b) -> ReaderSoup_ record ctxs b

uninterruptibleMask :: ((forall a. ReaderSoup_ record ctxs a -> ReaderSoup_ record ctxs a) -> ReaderSoup_ record ctxs b) -> ReaderSoup_ record ctxs b

generalBracket :: ReaderSoup_ record ctxs a -> (a -> ExitCase b -> ReaderSoup_ record ctxs c) -> (a -> ReaderSoup_ record ctxs b) -> ReaderSoup_ record ctxs (b, c)

IsInSoup_ r ctxs "katip" => KatipContext (ReaderSoup_ r ctxs)

Defined in Control.Monad.ReaderSoup.Katip

Methods

getKatipContext :: ReaderSoup_ r ctxs LogContexts

localKatipContext :: (LogContexts -> LogContexts) -> ReaderSoup_ r ctxs a -> ReaderSoup_ r ctxs a

getKatipNamespace :: ReaderSoup_ r ctxs Namespace

localKatipNamespace :: (Namespace -> Namespace) -> ReaderSoup_ r ctxs a -> ReaderSoup_ r ctxs a

IsInSoup_ r ctxs "katip" => Katip (ReaderSoup_ r ctxs)

Defined in Control.Monad.ReaderSoup.Katip

Methods

getLogEnv :: ReaderSoup_ r ctxs LogEnv

localLogEnv :: (LogEnv -> LogEnv) -> ReaderSoup_ r ctxs a -> ReaderSoup_ r ctxs a

IsInSoup_ r ctxs "resource" => MonadResource (ReaderSoup_ r ctxs)

Defined in Control.Monad.ReaderSoup.Resource

Methods

liftResourceT :: ResourceT IO a -> ReaderSoup_ r ctxs a

MonadUnliftIO (ReaderSoup_ record ctxs)

Defined in Control.Monad.ReaderSoup

Methods

askUnliftIO :: ReaderSoup_ record ctxs (UnliftIO (ReaderSoup_ record ctxs))

withRunInIO :: ((forall a. ReaderSoup_ record ctxs a -> IO a) -> IO b) -> ReaderSoup_ record ctxs b

type StM (ReaderSoup_ record ctxs) a

Defined in Control.Monad.ReaderSoup

type StM (ReaderSoup_ record ctxs) a = StM (ReaderT (record ElField ctxs) IO) a

type IsInSoup_ r ctxs l = (HasField r l ctxs ctxs (ContextFromName l) (ContextFromName l), RecElemFCtx r ElField)

type IsInSoup ctxs l = IsInSoup_ ARec ctxs l

class NatToInt (RLength (ContextsFromArgs args)) => ArgsForSoupConsumption args where

Associated Types

type ContextsFromArgs args :: [(Symbol, *)]

Methods

consumeSoup_ :: Rec ElField args -> CookedReaderSoup (ContextsFromArgs args) a -> IO a

Instances

ArgsForSoupConsumption ([] :: [(Symbol, Type)])

Defined in Control.Monad.ReaderSoup

Associated Types

type ContextsFromArgs [] :: [(Symbol, Type)]

Methods

consumeSoup_ :: Rec ElField [] -> CookedReaderSoup (ContextsFromArgs []) a -> IO a

(ArgsForSoupConsumption restArgs, m ~ CookedReaderSoup (ContextsFromArgs restArgs), CanRunSoupContext l t) => ArgsForSoupConsumption ((l ::: ContextRunner t m) ': restArgs)

Defined in Control.Monad.ReaderSoup

Associated Types

type ContextsFromArgs ((l ::: ContextRunner t m) ': restArgs) :: [(Symbol, Type)]

Methods

consumeSoup_ :: Rec ElField ((l ::: ContextRunner t m) ': restArgs) -> CookedReaderSoup (ContextsFromArgs ((l ::: ContextRunner t m) ': restArgs)) a -> IO a

newtype ContextRunner t m

Knowing the prefered monad to run some context, gives you a way to override this monad's runner.

Constructors

ContextRunner

Fields

• runContext :: forall r. t m r -> m r

Instances

(ArgsForSoupConsumption restArgs, m ~ CookedReaderSoup (ContextsFromArgs restArgs), CanRunSoupContext l t) => ArgsForSoupConsumption ((l ::: ContextRunner t m) ': restArgs)

Defined in Control.Monad.ReaderSoup

Associated Types

type ContextsFromArgs ((l ::: ContextRunner t m) ': restArgs) :: [(Symbol, Type)]

Methods

consumeSoup_ :: Rec ElField ((l ::: ContextRunner t m) ': restArgs) -> CookedReaderSoup (ContextsFromArgs ((l ::: ContextRunner t m) ': restArgs)) a -> IO a

type ContextsFromArgs ((l ::: ContextRunner t m) ': restArgs)

Defined in Control.Monad.ReaderSoup

type ContextsFromArgs ((l ::: ContextRunner t m) ': restArgs) = (l ::: ContextFromName l) ': ContextsFromArgs restArgs

data Label (a :: Symbol)

Proxy for label type

Instances

s ~ s' => IsLabel s (Label s')

Defined in Data.Vinyl.Derived

Methods

fromLabel :: Label s'

Eq (Label a)

Defined in Data.Vinyl.Derived

Methods

(==) :: Label a -> Label a -> Bool

(/=) :: Label a -> Label a -> Bool

Show (Label a)

Defined in Data.Vinyl.Derived

Methods

showsPrec :: Int -> Label a -> ShowS

show :: Label a -> String

showList :: [Label a] -> ShowS

(=:) :: KnownSymbol l => Label l -> v -> ElField (l ::: v) infix 8

Operator for creating an ElField. With the -XOverloadedLabels extension, this permits usage such as, #foo =: 23 to produce a value of type ElField ("foo" ::: Int).

type (:::) (a :: k) (b :: k1) = (,) a b

Alias for Field spec

data Rec (a :: u -> Type) (b :: [u]) :: forall u. (u -> Type) -> [u] -> Type where

A record is parameterized by a universe u, an interpretation f and a list of rows rs. The labels or indices of the record are given by inhabitants of the kind u; the type of values at any label r :: u is given by its interpretation f r :: *.

Constructors

RNil :: forall u (a :: u -> Type) (b :: [u]). Rec a ([] :: [u])

(:&) :: forall u (a :: u -> Type) (b :: [u]) (r :: u) (rs :: [u]). !(a r) -> !(Rec a rs) -> Rec a (r ': rs) infixr 7

Instances

RecSubset (Rec :: (k -> Type) -> [k] -> Type) ([] :: [k]) (ss :: [k]) ([] :: [Nat])

Defined in Data.Vinyl.Lens

Associated Types

type RecSubsetFCtx Rec f :: Constraint

Methods

rsubsetC :: (Functor g, RecSubsetFCtx Rec f) => (Rec f [] -> g (Rec f [])) -> Rec f ss -> g (Rec f ss)

rcastC :: RecSubsetFCtx Rec f => Rec f ss -> Rec f []

rreplaceC :: RecSubsetFCtx Rec f => Rec f [] -> Rec f ss -> Rec f ss

(RElem r ss i, RSubset rs ss is) => RecSubset (Rec :: (k -> Type) -> [k] -> Type) (r ': rs :: [k]) (ss :: [k]) (i ': is)

Defined in Data.Vinyl.Lens

Associated Types

type RecSubsetFCtx Rec f :: Constraint

Methods

rsubsetC :: (Functor g, RecSubsetFCtx Rec f) => (Rec f (r ': rs) -> g (Rec f (r ': rs))) -> Rec f ss -> g (Rec f ss)

rcastC :: RecSubsetFCtx Rec f => Rec f ss -> Rec f (r ': rs)

rreplaceC :: RecSubsetFCtx Rec f => Rec f (r ': rs) -> Rec f ss -> Rec f ss

RecElem (Rec :: (a -> Type) -> [a] -> Type) (r :: a) (r' :: a) (r ': rs :: [a]) (r' ': rs :: [a]) Z

Defined in Data.Vinyl.Lens

Associated Types

type RecElemFCtx Rec f :: Constraint

Methods

rlensC :: (Functor g, RecElemFCtx Rec f) => (f r -> g (f r')) -> Rec f (r ': rs) -> g (Rec f (r' ': rs))

rgetC :: (RecElemFCtx Rec f, r ~ r') => Rec f (r ': rs) -> f r

rputC :: RecElemFCtx Rec f => f r' -> Rec f (r ': rs) -> Rec f (r' ': rs)

(RIndex r (s ': rs) ~ S i, RecElem (Rec :: (a -> Type) -> [a] -> Type) r r' rs rs' i) => RecElem (Rec :: (a -> Type) -> [a] -> Type) (r :: a) (r' :: a) (s ': rs :: [a]) (s ': rs' :: [a]) (S i)

Defined in Data.Vinyl.Lens

Associated Types

type RecElemFCtx Rec f :: Constraint

Methods

rlensC :: (Functor g, RecElemFCtx Rec f) => (f r -> g (f r')) -> Rec f (s ': rs) -> g (Rec f (s ': rs'))

rgetC :: (RecElemFCtx Rec f, r ~ r') => Rec f (s ': rs) -> f r

rputC :: RecElemFCtx Rec f => f r' -> Rec f (s ': rs) -> Rec f (s ': rs')

TestCoercion f => TestCoercion (Rec f :: [u] -> Type)

Defined in Data.Vinyl.Core

Methods

testCoercion :: Rec f a -> Rec f b -> Maybe (Coercion a b)

TestEquality f => TestEquality (Rec f :: [u] -> Type)

Defined in Data.Vinyl.Core

Methods

testEquality :: Rec f a -> Rec f b -> Maybe (a :~: b)

Eq (Rec f ([] :: [u]))

Defined in Data.Vinyl.Core

Methods

(==) :: Rec f [] -> Rec f [] -> Bool

(/=) :: Rec f [] -> Rec f [] -> Bool

(Eq (f r), Eq (Rec f rs)) => Eq (Rec f (r ': rs))

Defined in Data.Vinyl.Core

Methods

(==) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool

(/=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool

Ord (Rec f ([] :: [u]))

Defined in Data.Vinyl.Core

Methods

compare :: Rec f [] -> Rec f [] -> Ordering

(<) :: Rec f [] -> Rec f [] -> Bool

(<=) :: Rec f [] -> Rec f [] -> Bool

(>) :: Rec f [] -> Rec f [] -> Bool

(>=) :: Rec f [] -> Rec f [] -> Bool

max :: Rec f [] -> Rec f [] -> Rec f []

min :: Rec f [] -> Rec f [] -> Rec f []

(Ord (f r), Ord (Rec f rs)) => Ord (Rec f (r ': rs))

Defined in Data.Vinyl.Core

Methods

compare :: Rec f (r ': rs) -> Rec f (r ': rs) -> Ordering

(<) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool

(<=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool

(>) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool

(>=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool

max :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs)

min :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs)

(RMap rs, ReifyConstraint Show f rs, RecordToList rs) => Show (Rec f rs)

Records may be shown insofar as their points may be shown. reifyConstraint is used to great effect here.

Defined in Data.Vinyl.Core

Methods

showsPrec :: Int -> Rec f rs -> ShowS

show :: Rec f rs -> String

showList :: [Rec f rs] -> ShowS

Generic (Rec f ([] :: [u]))

Defined in Data.Vinyl.Core

Associated Types

type Rep (Rec f []) :: Type -> Type

Methods

from :: Rec f [] -> Rep (Rec f []) x

to :: Rep (Rec f []) x -> Rec f []

Generic (Rec f rs) => Generic (Rec f (r ': rs))

Defined in Data.Vinyl.Core

Associated Types

type Rep (Rec f (r ': rs)) :: Type -> Type

Methods

from :: Rec f (r ': rs) -> Rep (Rec f (r ': rs)) x

to :: Rep (Rec f (r ': rs)) x -> Rec f (r ': rs)

Semigroup (Rec f ([] :: [u]))

Defined in Data.Vinyl.Core

Methods

(<>) :: Rec f [] -> Rec f [] -> Rec f []

sconcat :: NonEmpty (Rec f []) -> Rec f []

stimes :: Integral b => b -> Rec f [] -> Rec f []

(Semigroup (f r), Semigroup (Rec f rs)) => Semigroup (Rec f (r ': rs))

Defined in Data.Vinyl.Core

Methods

(<>) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs)

sconcat :: NonEmpty (Rec f (r ': rs)) -> Rec f (r ': rs)

stimes :: Integral b => b -> Rec f (r ': rs) -> Rec f (r ': rs)

Monoid (Rec f ([] :: [u]))

Defined in Data.Vinyl.Core

Methods

mempty :: Rec f []

mappend :: Rec f [] -> Rec f [] -> Rec f []

mconcat :: [Rec f []] -> Rec f []

(Monoid (f r), Monoid (Rec f rs)) => Monoid (Rec f (r ': rs))

Defined in Data.Vinyl.Core

Methods

mempty :: Rec f (r ': rs)

mappend :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs)

mconcat :: [Rec f (r ': rs)] -> Rec f (r ': rs)

Storable (Rec f ([] :: [u]))

Defined in Data.Vinyl.Core

Methods

sizeOf :: Rec f [] -> Int

alignment :: Rec f [] -> Int

peekElemOff :: Ptr (Rec f []) -> Int -> IO (Rec f [])

pokeElemOff :: Ptr (Rec f []) -> Int -> Rec f [] -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Rec f [])

pokeByteOff :: Ptr b -> Int -> Rec f [] -> IO ()

peek :: Ptr (Rec f []) -> IO (Rec f [])

poke :: Ptr (Rec f []) -> Rec f [] -> IO ()

(Storable (f r), Storable (Rec f rs)) => Storable (Rec f (r ': rs))

Defined in Data.Vinyl.Core

Methods

sizeOf :: Rec f (r ': rs) -> Int

alignment :: Rec f (r ': rs) -> Int

peekElemOff :: Ptr (Rec f (r ': rs)) -> Int -> IO (Rec f (r ': rs))

pokeElemOff :: Ptr (Rec f (r ': rs)) -> Int -> Rec f (r ': rs) -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Rec f (r ': rs))

pokeByteOff :: Ptr b -> Int -> Rec f (r ': rs) -> IO ()

peek :: Ptr (Rec f (r ': rs)) -> IO (Rec f (r ': rs))

poke :: Ptr (Rec f (r ': rs)) -> Rec f (r ': rs) -> IO ()

type RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) (f :: k -> Type)

Defined in Data.Vinyl.Lens

type RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) (f :: k -> Type) = ()

type RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) (f :: k -> Type)

Defined in Data.Vinyl.Lens

type RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) (f :: k -> Type) = ()

type RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) (f :: a -> Type)

Defined in Data.Vinyl.Lens

type RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) (f :: a -> Type) = ()

type RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) (f :: a -> Type)

Defined in Data.Vinyl.Lens

type RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) (f :: a -> Type) = ()

type Rep (Rec f (r ': rs))

Defined in Data.Vinyl.Core

type Rep (Rec f (r ': rs)) = C1 (MetaCons ":&" (InfixI RightAssociative 7) False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (f r)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rep (Rec f rs)))

type Rep (Rec f ([] :: [u]))

Defined in Data.Vinyl.Core

type Rep (Rec f ([] :: [u])) = C1 (MetaCons "RNil" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (U1 :: Type -> Type))

consumeSoup :: ArgsForSoupConsumption args => Rec ElField args -> ReaderSoup (ContextsFromArgs args) a -> IO a

From the list of the arguments to initialize the contexts, runs the whole ReaderSoup_

API for working in a ReaderSoup and creating instances of SoupContext

type Reader r = ReaderT 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.

newtype ReaderT r (m :: k -> Type) (a :: k) :: forall k. Type -> (k -> Type) -> k -> Type

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.

Constructors

ReaderT

Fields

• runReaderT :: r -> m a

Instances

Monad m => MonadReader r (ReaderT r m)

Defined in Control.Monad.Reader.Class

Methods

ask :: ReaderT r m r

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

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

MonadBase b m => MonadBase b (ReaderT r m)

Defined in Control.Monad.Base

Methods

liftBase :: b α -> ReaderT r m α

MonadBaseControl b m => MonadBaseControl b (ReaderT r m)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (ReaderT r m) a :: Type

Methods

liftBaseWith :: (RunInBase (ReaderT r m) b -> b a) -> ReaderT r m a

restoreM :: StM (ReaderT r m) a -> ReaderT r m a

MFunctor (ReaderT r :: (Type -> Type) -> Type -> Type)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> ReaderT r m b -> ReaderT r n b

MMonad (ReaderT r :: (Type -> Type) -> Type -> Type)

Defined in Control.Monad.Morph

Methods

embed :: Monad n => (forall a. m a -> ReaderT r n a) -> ReaderT r m b -> ReaderT r n b

MonadTrans (ReaderT r :: (Type -> Type) -> Type -> Type)

Defined in Control.Monad.Trans.Reader

Methods

lift :: Monad m => m a -> ReaderT r m a

MonadTransControl (ReaderT r :: (Type -> Type) -> Type -> Type)

Defined in Control.Monad.Trans.Control

Associated Types

type StT (ReaderT r) a :: Type

Methods

liftWith :: Monad m => (Run (ReaderT r) -> m a) -> ReaderT r m a

restoreT :: Monad m => m (StT (ReaderT r) a) -> ReaderT r m a

Monad m => Monad (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

(>>=) :: ReaderT r m a -> (a -> ReaderT r m b) -> ReaderT r m b

(>>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b

return :: a -> ReaderT r m a

fail :: String -> ReaderT r m a

Functor m => Functor (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

fmap :: (a -> b) -> ReaderT r m a -> ReaderT r m b

(<$) :: a -> ReaderT r m b -> ReaderT r m a

MonadFix m => MonadFix (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

mfix :: (a -> ReaderT r m a) -> ReaderT r m a

MonadFail m => MonadFail (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

fail :: String -> ReaderT r m a

Applicative m => Applicative (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

pure :: a -> ReaderT r m a

(<*>) :: ReaderT r m (a -> b) -> ReaderT r m a -> ReaderT r m b

liftA2 :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c

(*>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b

(<*) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a

Contravariant m => Contravariant (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

contramap :: (a -> b) -> ReaderT r m b -> ReaderT r m a

(>$) :: b -> ReaderT r m b -> ReaderT r m a

Representable m => Representable (ReaderT e m)

Defined in Data.Functor.Rep

Associated Types

type Rep (ReaderT e m) :: Type

Methods

tabulate :: (Rep (ReaderT e m) -> a) -> ReaderT e m a

index :: ReaderT e m a -> Rep (ReaderT e m) -> a

Alternative m => Alternative (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

empty :: ReaderT r m a

(<|>) :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a

some :: ReaderT r m a -> ReaderT r m [a]

many :: ReaderT r m a -> ReaderT r m [a]

MonadPlus m => MonadPlus (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

mzero :: ReaderT r m a

mplus :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a

MonadZip m => MonadZip (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

mzip :: ReaderT r m a -> ReaderT r m b -> ReaderT r m (a, b)

mzipWith :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c

munzip :: ReaderT r m (a, b) -> (ReaderT r m a, ReaderT r m b)

MonadIO m => MonadIO (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

liftIO :: IO a -> ReaderT r m a

MonadThrow m => MonadThrow (ReaderT r m)

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> ReaderT r m a

MonadCatch m => MonadCatch (ReaderT r m)

Defined in Control.Monad.Catch

Methods

catch :: Exception e => ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a

MonadMask m => MonadMask (ReaderT r m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b

uninterruptibleMask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b

generalBracket :: ReaderT r m a -> (a -> ExitCase b -> ReaderT r m c) -> (a -> ReaderT r m b) -> ReaderT r m (b, c)

(KatipContext m, Katip (ReaderT r m)) => KatipContext (ReaderT r m)

Defined in Katip.Monadic

Methods

getKatipContext :: ReaderT r m LogContexts

localKatipContext :: (LogContexts -> LogContexts) -> ReaderT r m a -> ReaderT r m a

getKatipNamespace :: ReaderT r m Namespace

localKatipNamespace :: (Namespace -> Namespace) -> ReaderT r m a -> ReaderT r m a

Katip m => Katip (ReaderT s m)

Defined in Katip.Core

Methods

getLogEnv :: ReaderT s m LogEnv

localLogEnv :: (LogEnv -> LogEnv) -> ReaderT s m a -> ReaderT s m a

PrimMonad m => PrimMonad (ReaderT r m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (ReaderT r m) :: Type

Methods

primitive :: (State# (PrimState (ReaderT r m)) -> (#State# (PrimState (ReaderT r m)), a#)) -> ReaderT r m a

MonadResource m => MonadResource (ReaderT r m)

Defined in Control.Monad.Trans.Resource.Internal

Methods

liftResourceT :: ResourceT IO a -> ReaderT r m a

MonadUnliftIO m => MonadUnliftIO (ReaderT r m)

Defined in Control.Monad.IO.Unlift

Methods

askUnliftIO :: ReaderT r m (UnliftIO (ReaderT r m))

withRunInIO :: ((forall a. ReaderT r m a -> IO a) -> IO b) -> ReaderT r m b

Zoom m n s t => Zoom (ReaderT e m) (ReaderT e n) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (ReaderT e m) c) t s -> ReaderT e m c -> ReaderT e n c

Monad m => Magnify (ReaderT b m) (ReaderT a m) b a

Defined in Control.Lens.Zoom

Methods

magnify :: (Functor (Magnified (ReaderT b m) c) -> Contravariant (Magnified (ReaderT b m) c) -> LensLike' (Magnified (ReaderT b m) c) a b) -> ReaderT b m c -> ReaderT a m c

Wrapped (ReaderT r m a)

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped (ReaderT r m a) :: Type

Methods

_Wrapped' :: Iso' (ReaderT r m a) (Unwrapped (ReaderT r m a))

t ~ ReaderT s n b => Rewrapped (ReaderT r m a) t

Defined in Control.Lens.Wrapped

type StT (ReaderT r :: (Type -> Type) -> Type -> Type) a

Defined in Control.Monad.Trans.Control

type StT (ReaderT r :: (Type -> Type) -> Type -> Type) a = a

type Rep (ReaderT e m)

Defined in Data.Functor.Rep

type Rep (ReaderT e m) = (e, Rep m)

type Zoomed (ReaderT e m)

Defined in Control.Lens.Zoom

type Zoomed (ReaderT e m) = Zoomed m

type Magnified (ReaderT b m)

Defined in Control.Lens.Zoom

type Magnified (ReaderT b m) = Effect m

type PrimState (ReaderT r m)

Defined in Control.Monad.Primitive

type PrimState (ReaderT r m) = PrimState m

type StM (ReaderT r m) a

Defined in Control.Monad.Trans.Control

type StM (ReaderT r m) a = ComposeSt (ReaderT r :: (Type -> Type) -> Type -> Type) m a

type Unwrapped (ReaderT r m a)

Defined in Control.Lens.Wrapped

type Unwrapped (ReaderT r m a) = r -> m a

runReader

Arguments

:: Reader r a

A Reader to run.

-> r

An initial environment.

-> a

Runs a Reader and extracts the final value from it. (The inverse of reader.)

mapReader :: (a -> b) -> Reader r a -> Reader r b

Transform the value returned by a Reader.

• runReader (mapReader f m) = f . runReader m

withReader

Arguments

:: (r' -> r)

The function to modify the environment.

-> Reader r a

Computation to run in the modified environment.

-> Reader r' a

Execute a computation in a modified environment (a specialization of withReaderT).

• runReader (withReader f m) = runReader m . f

mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b

Transform the computation inside a ReaderT.

• runReaderT (mapReaderT f m) = f . runReaderT m

withReaderT

Arguments

:: (r' -> r)

The function to modify the environment.

-> ReaderT r m a

Computation to run in the modified environment.

-> ReaderT r' m a

Execute a computation in a modified environment (a more general version of local).

• runReaderT (withReaderT f m) = runReaderT m . f

liftCatch :: Catch e m a -> Catch e (ReaderT r m) a

Lift a catchE operation to the new monad.

liftCallCC :: CallCC m a b -> CallCC (ReaderT r m) a b

Lift a callCC operation to the new monad.

asks

Arguments

:: Monad m

=> (r -> a)

The selector function to apply to the environment.

-> ReaderT r m a

Retrieve a function of the current environment.

• asks f = liftM f ask

hoist :: (MFunctor t, Monad m) => (forall a. m a -> n a) -> t m b -> t n b

Lift a monad morphism from m to n into a monad morphism from (t m) to (t n)

The first argument to hoist must be a monad morphism, even though the type system does not enforce this

class Monad m => MonadReader r (m :: Type -> Type) | m -> r where

See examples in Control.Monad.Reader. Note, the partially applied function type (->) r is a simple reader monad. See the instance declaration below.

Minimal complete definition

(ask | reader), local

Methods

ask :: m r

Retrieves the monad environment.

local

Arguments

:: (r -> r)

The function to modify the environment.

-> m a

Reader to run in the modified environment.

-> m a

Executes a computation in a modified environment.

reader

Arguments

:: (r -> a)

The selector function to apply to the environment.

-> m a

Retrieves a function of the current environment.

Instances

MonadReader r m => MonadReader r (ResourceT m)

Defined in Control.Monad.Trans.Resource.Internal

Methods

ask :: ResourceT m r

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

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

MonadReader r m => MonadReader r (KatipContextT m)

Defined in Katip.Monadic

Methods

ask :: KatipContextT m r

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

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

MonadReader r m => MonadReader r (NoLoggingT m)

Defined in Katip.Monadic

Methods

ask :: NoLoggingT m r

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

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

MonadReader s (ReifiedGetter s)

Defined in Control.Lens.Reified

Methods

ask :: ReifiedGetter s s

local :: (s -> s) -> ReifiedGetter s a -> ReifiedGetter s a

reader :: (s -> a) -> ReifiedGetter s a

MonadReader s (ReifiedFold s)

Defined in Control.Lens.Reified

Methods

ask :: ReifiedFold s s

local :: (s -> s) -> ReifiedFold s a -> ReifiedFold s a

reader :: (s -> a) -> ReifiedFold s a

(Functor m, MonadReader e m) => MonadReader e (Free m)

Defined in Control.Monad.Free

Methods

ask :: Free m e

local :: (e -> e) -> Free m a -> Free m a

reader :: (e -> a) -> Free m a

(Representable f, Rep f ~ a) => MonadReader a (Co f)

Defined in Data.Functor.Rep

Methods

ask :: Co f a

local :: (a -> a) -> Co f a0 -> Co f a0

reader :: (a -> a0) -> Co f a0

MonadReader r m => MonadReader r (MaybeT m)

Defined in Control.Monad.Reader.Class

Methods

ask :: MaybeT m r

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

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

MonadReader r m => MonadReader r (ListT m)

Defined in Control.Monad.Reader.Class

Methods

ask :: ListT m r

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

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

(Functor f, MonadReader r m) => MonadReader r (FreeT f m)

Defined in Control.Monad.Trans.Free

Methods

ask :: FreeT f m r

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

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

(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)

Defined in Control.Monad.Reader.Class

Methods

ask :: WriterT w m r

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

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

(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)

Defined in Control.Monad.Reader.Class

Methods

ask :: WriterT w m r

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

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

MonadReader r m => MonadReader r (StateT s m)

Defined in Control.Monad.Reader.Class

Methods

ask :: StateT s m r

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

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

MonadReader r m => MonadReader r (StateT s m)

Defined in Control.Monad.Reader.Class

Methods

ask :: StateT s m r

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

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

MonadReader r m => MonadReader r (IdentityT m)

Defined in Control.Monad.Reader.Class

Methods

ask :: IdentityT m r

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

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

MonadReader r m => MonadReader r (ExceptT e m)

Since: mtl-2.2

Defined in Control.Monad.Reader.Class

Methods

ask :: ExceptT e m r

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

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

(Error e, MonadReader r m) => MonadReader r (ErrorT e m)

Defined in Control.Monad.Reader.Class

Methods

ask :: ErrorT e m r

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

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

Monad m => MonadReader r (ReaderT r m)

Defined in Control.Monad.Reader.Class

Methods

ask :: ReaderT r m r

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

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

MonadReader r ((->) r :: Type -> Type)

Defined in Control.Monad.Reader.Class

Methods

ask :: r -> r

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

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

MonadReader r' m => MonadReader r' (ContT r m)

Defined in Control.Monad.Reader.Class

Methods

ask :: ContT r m r'

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

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

(Monad m, Monoid w) => MonadReader r (RWST r w s m)

Defined in Control.Monad.Reader.Class

Methods

ask :: RWST r w s m r

local :: (r -> r) -> RWST r w s m a -> RWST r w s m a

reader :: (r -> a) -> RWST r w s m a

(Monad m, Monoid w) => MonadReader r (RWST r w s m)

Defined in Control.Monad.Reader.Class

Methods

ask :: RWST r w s m r

local :: (r -> r) -> RWST r w s m a -> RWST r w s m a

reader :: (r -> a) -> RWST r w s m a

type ReaderSoup = ReaderSoup_ ARec

The type of ReaderSoup_ your application will eat

type family ContextFromName (l :: Symbol) :: *

Associates the type-level label to the reader context

Instances

type ContextFromName "katip"

Defined in Control.Monad.ReaderSoup.Katip

type ContextFromName "katip" = KatipContextTState

type ContextFromName "resource"

Defined in Control.Monad.ReaderSoup.Resource

type ContextFromName "resource" = InternalState

class SoupContext c t | c -> t where

A class for the contexts that have an associated monad transformer that can be turned into a ReaderT of this context, and the type of monad over which they can run.

Methods

toReaderT :: Monad m => t m a -> ReaderT c m a

Turn this monad trans into an actual ReaderT

fromReaderT :: Monad m => ReaderT c m a -> t m a

Reconstruct this monad trans from an actual ReaderT

Instances

SoupContext KatipContextTState KatipContextT

Defined in Control.Monad.ReaderSoup.Katip

Methods

toReaderT :: Monad m => KatipContextT m a -> ReaderT KatipContextTState m a

fromReaderT :: Monad m => ReaderT KatipContextTState m a -> KatipContextT m a

SoupContext InternalState ResourceT

Defined in Control.Monad.ReaderSoup.Resource

Methods

toReaderT :: Monad m => ResourceT m a -> ReaderT InternalState m a

fromReaderT :: Monad m => ReaderT InternalState m a -> ResourceT m a

type CanBeScoopedIn_ r t ctxs l = (IsInSoup_ r ctxs l, KnownSymbol l, SoupContext (ContextFromName l) t)

type CanBeScoopedIn t ctxs l = CanBeScoopedIn_ ARec t ctxs l

type CanRunSoupContext l t = SoupContext (ContextFromName l) t

askSoup :: IsInSoup_ r ctxs l => Label l -> ReaderSoup_ r ctxs (ContextFromName l)

filtering :: RecSubset ARec ctxs' ctxs (RImage ctxs' ctxs) => ReaderSoup ctxs' a -> ReaderSoup ctxs a

Permits to select only a part of the whole contexts, to locally decide which part of the ReaderSoup will be exposed, and remove ambiguity.

picking :: CanBeScoopedIn_ r t ctxs l => Label l -> t IO a -> ReaderSoup_ r ctxs a

Like dipping, but instead of Spoon_ runs some preferential Reader-like monad. That permits to reuse some already existing monad from an existing library (ResourceT, KatipContextT, etc.) if you cannot just use a MonadReader instance.

scooping :: CanBeScoopedIn_ r t ctxs l => Label l -> t (ReaderSoup_ r ctxs) a -> ReaderSoup_ r ctxs a

Like picking, but gives you more context: instead of just running over IO, it makes the monad run over the whole soup (so instances of MonadXXX classes defined over the whole soup can still be used).

pouring :: forall l ctxs t a r. CanBeScoopedIn_ r t ctxs l => Label l -> ReaderSoup_ r ctxs a -> t (ReaderSoup_ r ctxs) a

The opposite of scooping.

Low-level API

data ElField (field :: (Symbol, Type)) where

A value with a phantom Symbol label. It is not a Haskell Functor, but it is used in many of the same places a Functor is used in vinyl.

Constructors

Field :: forall (field :: (Symbol, Type)) (s :: Symbol) t. KnownSymbol s => !t -> ElField ((,) s t)

Instances

Eq t => Eq (ElField ((,) s t))

Defined in Data.Vinyl.Functor

Methods

(==) :: ElField (s, t) -> ElField (s, t) -> Bool

(/=) :: ElField (s, t) -> ElField (s, t) -> Bool

(Floating t, KnownSymbol s) => Floating (ElField ((,) s t))

Defined in Data.Vinyl.Functor

Methods

pi :: ElField (s, t)

exp :: ElField (s, t) -> ElField (s, t)

log :: ElField (s, t) -> ElField (s, t)

sqrt :: ElField (s, t) -> ElField (s, t)

(**) :: ElField (s, t) -> ElField (s, t) -> ElField (s, t)

logBase :: ElField (s, t) -> ElField (s, t) -> ElField (s, t)

sin :: ElField (s, t) -> ElField (s, t)

cos :: ElField (s, t) -> ElField (s, t)

tan :: ElField (s, t) -> ElField (s, t)

asin :: ElField (s, t) -> ElField (s, t)

acos :: ElField (s, t) -> ElField (s, t)

atan :: ElField (s, t) -> ElField (s, t)

sinh :: ElField (s, t) -> ElField (s, t)

cosh :: ElField (s, t) -> ElField (s, t)

tanh :: ElField (s, t) -> ElField (s, t)

asinh :: ElField (s, t) -> ElField (s, t)

acosh :: ElField (s, t) -> ElField (s, t)

atanh :: ElField (s, t) -> ElField (s, t)

log1p :: ElField (s, t) -> ElField (s, t)

expm1 :: ElField (s, t) -> ElField (s, t)

log1pexp :: ElField (s, t) -> ElField (s, t)

log1mexp :: ElField (s, t) -> ElField (s, t)

(Fractional t, KnownSymbol s) => Fractional (ElField ((,) s t))

Defined in Data.Vinyl.Functor

Methods

(/) :: ElField (s, t) -> ElField (s, t) -> ElField (s, t)

recip :: ElField (s, t) -> ElField (s, t)

fromRational :: Rational -> ElField (s, t)

(Num t, KnownSymbol s) => Num (ElField ((,) s t))

Defined in Data.Vinyl.Functor

Methods

(+) :: ElField (s, t) -> ElField (s, t) -> ElField (s, t)

(-) :: ElField (s, t) -> ElField (s, t) -> ElField (s, t)

(*) :: ElField (s, t) -> ElField (s, t) -> ElField (s, t)

negate :: ElField (s, t) -> ElField (s, t)

abs :: ElField (s, t) -> ElField (s, t)

signum :: ElField (s, t) -> ElField (s, t)

fromInteger :: Integer -> ElField (s, t)

Ord t => Ord (ElField ((,) s t))

Defined in Data.Vinyl.Functor

Methods

compare :: ElField (s, t) -> ElField (s, t) -> Ordering

(<) :: ElField (s, t) -> ElField (s, t) -> Bool

(<=) :: ElField (s, t) -> ElField (s, t) -> Bool

(>) :: ElField (s, t) -> ElField (s, t) -> Bool

(>=) :: ElField (s, t) -> ElField (s, t) -> Bool

max :: ElField (s, t) -> ElField (s, t) -> ElField (s, t)

min :: ElField (s, t) -> ElField (s, t) -> ElField (s, t)

(Real t, KnownSymbol s) => Real (ElField ((,) s t))

Defined in Data.Vinyl.Functor

Methods

toRational :: ElField (s, t) -> Rational

(RealFrac t, KnownSymbol s) => RealFrac (ElField ((,) s t))

Defined in Data.Vinyl.Functor

Methods

properFraction :: Integral b => ElField (s, t) -> (b, ElField (s, t))

truncate :: Integral b => ElField (s, t) -> b

round :: Integral b => ElField (s, t) -> b

ceiling :: Integral b => ElField (s, t) -> b

floor :: Integral b => ElField (s, t) -> b

(Show t, KnownSymbol s) => Show (ElField ((,) s t))

Defined in Data.Vinyl.Functor

Methods

showsPrec :: Int -> ElField (s, t) -> ShowS

show :: ElField (s, t) -> String

showList :: [ElField (s, t)] -> ShowS

KnownSymbol s => Generic (ElField ((,) s a))

Defined in Data.Vinyl.Functor

Associated Types

type Rep (ElField (s, a)) :: Type -> Type

Methods

from :: ElField (s, a) -> Rep (ElField (s, a)) x

to :: Rep (ElField (s, a)) x -> ElField (s, a)

Semigroup t => Semigroup (ElField ((,) s t))

Defined in Data.Vinyl.Functor

Methods

(<>) :: ElField (s, t) -> ElField (s, t) -> ElField (s, t)

sconcat :: NonEmpty (ElField (s, t)) -> ElField (s, t)

stimes :: Integral b => b -> ElField (s, t) -> ElField (s, t)

(KnownSymbol s, Monoid t) => Monoid (ElField ((,) s t))

Defined in Data.Vinyl.Functor

Methods

mempty :: ElField (s, t)

mappend :: ElField (s, t) -> ElField (s, t) -> ElField (s, t)

mconcat :: [ElField (s, t)] -> ElField (s, t)

(KnownSymbol s, Storable t) => Storable (ElField ((,) s t))

Defined in Data.Vinyl.Functor

Methods

sizeOf :: ElField (s, t) -> Int

alignment :: ElField (s, t) -> Int

peekElemOff :: Ptr (ElField (s, t)) -> Int -> IO (ElField (s, t))

pokeElemOff :: Ptr (ElField (s, t)) -> Int -> ElField (s, t) -> IO ()

peekByteOff :: Ptr b -> Int -> IO (ElField (s, t))

pokeByteOff :: Ptr b -> Int -> ElField (s, t) -> IO ()

peek :: Ptr (ElField (s, t)) -> IO (ElField (s, t))

poke :: Ptr (ElField (s, t)) -> ElField (s, t) -> IO ()

KnownSymbol s => IsoHKD ElField ((,) s a :: (Symbol, Type))

Work with values of type ElField '(s,a) as if they were of type a.

Defined in Data.Vinyl.XRec

Associated Types

type HKD ElField (s, a) :: Type

Methods

unHKD :: HKD ElField (s, a) -> ElField (s, a)

toHKD :: ElField (s, a) -> HKD ElField (s, a)

(i ~ RIndex t ts, NatToInt i, FieldOffset ElField ts t, Storable (Rec ElField ts), AllConstrained (FieldOffset ElField ts) ts) => RecElem (SRec2 ElField) (t :: (Symbol, Type)) (t :: (Symbol, Type)) (ts :: [(Symbol, Type)]) (ts :: [(Symbol, Type)]) i

Field accessors for SRec2 specialized to ElField as the functor.

Defined in Data.Vinyl.SRec

Associated Types

type RecElemFCtx (SRec2 ElField) f :: Constraint

Methods

rlensC :: (Functor g, RecElemFCtx (SRec2 ElField) f) => (f t -> g (f t)) -> SRec2 ElField f ts -> g (SRec2 ElField f ts)

rgetC :: (RecElemFCtx (SRec2 ElField) f, t ~ t) => SRec2 ElField f ts -> f t

rputC :: RecElemFCtx (SRec2 ElField) f => f t -> SRec2 ElField f ts -> SRec2 ElField f ts

(is ~ RImage rs ss, RecSubset (Rec :: ((Symbol, Type) -> Type) -> [(Symbol, Type)] -> Type) rs ss is, Storable (Rec ElField rs), Storable (Rec ElField ss), RPureConstrained (FieldOffset ElField ss) rs, RPureConstrained (FieldOffset ElField rs) rs, RFoldMap rs, RMap rs, RApply rs) => RecSubset (SRec2 ElField) (rs :: [(Symbol, Type)]) (ss :: [(Symbol, Type)]) is

Defined in Data.Vinyl.SRec

Associated Types

type RecSubsetFCtx (SRec2 ElField) f :: Constraint

Methods

rsubsetC :: (Functor g, RecSubsetFCtx (SRec2 ElField) f) => (SRec2 ElField f rs -> g (SRec2 ElField f rs)) -> SRec2 ElField f ss -> g (SRec2 ElField f ss)

rcastC :: RecSubsetFCtx (SRec2 ElField) f => SRec2 ElField f ss -> SRec2 ElField f rs

rreplaceC :: RecSubsetFCtx (SRec2 ElField) f => SRec2 ElField f rs -> SRec2 ElField f ss -> SRec2 ElField f ss

type Rep (ElField ((,) s a))

Defined in Data.Vinyl.Functor

type Rep (ElField ((,) s a)) = C1 (MetaCons s PrefixI False) (Rec0 a)

type HKD ElField ((,) s a :: (Symbol, Type))

Defined in Data.Vinyl.XRec

type HKD ElField ((,) s a :: (Symbol, Type)) = a

type RecElemFCtx (SRec2 ElField) (f :: (Symbol, Type) -> Type)

Defined in Data.Vinyl.SRec

type RecElemFCtx (SRec2 ElField) (f :: (Symbol, Type) -> Type) = f ~ ElField

type RecSubsetFCtx (SRec2 ElField) (f :: (Symbol, Type) -> Type)

Defined in Data.Vinyl.SRec

type RecSubsetFCtx (SRec2 ElField) (f :: (Symbol, Type) -> Type) = f ~ ElField

type Spoon = Spoon_ ARec

type CookedReaderSoup = ReaderSoup_ Rec

A ReaderSoup_ ready to be eaten

cookReaderSoup :: NatToInt (RLength ctxs) => ReaderSoup ctxs a -> CookedReaderSoup ctxs a

Turns a ReaderSoup_ into something than is ready to be eaten

pickTopping :: KnownSymbol l => CookedReaderSoup ((l ::: c) ': ctxs) a -> ReaderT c (CookedReaderSoup ctxs) a

Extracts a ReaderT of the first context so it can be eaten

eatTopping :: KnownSymbol l => CookedReaderSoup ((l ::: c) ': ctxs) a -> c -> CookedReaderSoup ctxs a

Consumes the first context in the record

finishBroth :: CookedReaderSoup '[] a -> IO a

Once all contexts have been eaten, leaves only the base monad

rioToSpoon :: forall l ctxs a r. IsInSoup_ r ctxs l => ReaderT (ContextFromName l) IO a -> Spoon_ r ctxs l a

If you have a code that cannot cope with any MonadReader but explicitly wants a ReaderT

spoonToReaderT :: forall l ctxs a r. (IsInSoup_ r ctxs l, KnownSymbol l) => Spoon_ r ctxs l a -> ReaderT (ContextFromName l) (ReaderSoup_ r ctxs) a

Converting Spoon back to a ReaderT has to happen in the ReaderSoup because we need the global context

dipping :: Label l -> Spoon_ r ctxs l a -> ReaderSoup_ r ctxs a

Brings forth one context of the whole soup, giving a MonadReader instance of just this context. This makes it possible that the same context type occurs several times in the broth, because the Label will disambiguate them.

withSpoon :: forall l ctxs t a r. CanBeScoopedIn_ r t ctxs l => t (ReaderSoup_ r ctxs) a -> Spoon_ r ctxs l a

Converts an action in some ReaderT-like monad to Spoon_, this monad being determined by c. This is for code that cannot cope with any MonadReader and want some specific monad.

fromLabel :: IsLabel x a => a