runReader -package:relude

runReader :: Reader r a -> r -> a
mtl Control.Monad.Reader, transformers Control.Monad.Trans.Reader, protolude Protolude, rio RIO.Prelude, monads-tf Control.Monad.Reader, universum Universum.Monad.Reexport, rebase Rebase.Prelude, mtl-prelude MTLPrelude, dunai Control.Monad.Trans.MSF.Reader, can-i-haz Control.Monad.Reader.Has, monadology Control.Monad.Ology.Specific.ReaderT
Runs a Reader and extracts the final value from it. (The inverse of reader.)
runReader :: Reader a -> Text -> Either Text a
http-api-data Web.Internal.HttpApiData
Run Reader as HTTP API data parser.
runReader :: i -> Sem (Reader i ': r) a -> Sem r a
polysemy Polysemy.Reader
Run a Reader effect with a constant value.
runReader :: Representable f => Reader f b -> Rep f -> b
adjunctions Control.Monad.Representable.Reader
runReader :: Arrow a => ReaderArrow r a e b -> a (e, r) b
arrows Control.Arrow.Transformer.Reader
Encapsulation of a state-reading computation, taking a value for the state. Typical usage in arrow notation: 
proc p -> ...
(|runReader cmd|) env
runReader :: forall r (es :: [(Type -> Type) -> Type -> Type]) a . HasCallStack => r -> Eff (Reader r ': es) a -> Eff es a
effectful-core Effectful.Reader.Dynamic
Run the Reader effect with the given initial environment.
runReader :: forall r (es :: [(Type -> Type) -> Type -> Type]) a . HasCallStack => r -> Eff (Reader r ': es) a -> Eff es a
effectful-core Effectful.Reader.Static
Run a Reader effect with the given initial environment.
runReader :: r -> ReaderC r m a -> m a
fused-effects Control.Carrier.Reader
Run a Reader effect with the passed environment value. 
runReader a ask = pure a

runReader a (pure b) = pure b

runReader a (local f m) = runReader (f a) m
runReader :: Reader r m a -> r -> m a
basement Basement.Compat.MonadTrans
runReader :: forall i (r :: [(Type -> Type) -> Type -> Type]) a . i -> Sem (Reader i ': r) a -> Sem r a
incipit-core IncipitCore
Run a Reader effect with a constant value.
runReader :: forall r (es :: Effects) a . r -> (forall (e :: Effects) . () => Reader r e -> Eff (e :& es) a) -> Eff es a
bluefin Bluefin.Reader, bluefin-internal Bluefin.Internal
runReader :: Reader a -> String -> Either String a
opt-env-conf OptEnvConf.Reader
runReaderT :: ReaderT r m a -> r -> m a
mtl Control.Monad.Reader, transformers Control.Monad.Trans.Reader, rio RIO.Prelude, foundation Foundation.Monad.Reader
runReaderC :: Monad m => r -> ConduitT i o (ReaderT r m) res -> ConduitT i o m res
conduit Data.Conduit.Lift
Run ReaderT in the base monad Since 1.0.11
runReaderP :: Monad m => i -> Proxy a' a b' b (ReaderT i m) r -> Proxy a' a b' b m r
pipes Pipes.Lift
Run ReaderT in the base monad
runReaderT :: ReaderT r (m :: Type -> Type) a -> r -> m a
protolude Protolude, monads-tf Control.Monad.Reader, classy-prelude ClassyPrelude, universum Universum.Monad.Reexport, rebase Rebase.Prelude, mtl-prelude MTLPrelude
runReaderT :: Representable f => ReaderT f m b -> Rep f -> m b
adjunctions Control.Monad.Representable.Reader
runReaderIO :: ReaderIO e a -> e -> IO a
reflex Control.Monad.ReaderIO
runReaderT :: (IsStream t, Monad m) => m s -> t (ReaderT s m) a -> t m a
streamly Streamly.Internal.Data.Stream.IsStream Streamly.Prelude
Evaluate the inner monad of a stream as ReaderT.
runReaderM :: Monad m => e -> MachineT (ReaderT e m) k o -> MachineT m k o
machines Data.Machine.Lift
Given an environment and a MachineT that runs in ReaderT e m, produce a MachineT that runs in m.
runReaderT :: Monad m => m s -> Stream (ReaderT s m) a -> Stream m a
streamly-core Streamly.Data.Stream Streamly.Internal.Data.Stream
Evaluate the inner monad of a stream as ReaderT.
runReaderC :: forall r (m :: Type -> Type) a b . r -> Cell (ReaderT r m) a b -> Cell m a b
essence-of-live-coding LiveCoding LiveCoding.Cell.Monad.Trans
Supply a ReaderT environment before running the cell
runReaderC' :: forall (m :: Type -> Type) r a b . Monad m => Cell (ReaderT r m) a b -> Cell m (r, a) b
essence-of-live-coding LiveCoding LiveCoding.Cell.Monad.Trans
Supply a ReaderT environment live
runReaderC :: Monad m => r -> ConduitT i o ReaderT r m res -> ConduitT i o m res
classy-prelude-conduit ClassyPrelude.Conduit
Run ReaderT in the base monad Since 1.0.11
runReaderS :: Monad m => ClSF (ReaderT r m) cl a b -> ClSF m cl (a, r) b
rhine FRP.Rhine
Remove ("run") a ReaderT layer from the monad stack by making it an explicit input to the behaviour.