Struct ReaderF 

pub struct ReaderF<E>(/* private fields */);

Type constructor for the Reader functor: Of<T> = Box<dyn Fn(E) -> T>.

Isomorphic to TracedF<E> in representation, but serves a different semantic role: ReaderF<E> is the right adjoint of EnvF<E> in the product/exponential adjunction (EnvF<E> ⊣ ReaderF<E>).

ReaderF<E> cannot implement the generic Functor trait because Box<dyn Fn> requires 'static bounds that the trait signature doesn’t allow. Following the Lan pattern, inherent methods with 'static bounds on the impl block provide the same functionality.

Implementations

impl<E> ReaderF<E>

where E: Clone + 'static,

pub fn fmap<A, B>( fa: Box<dyn Fn(E) -> A>, f: impl Fn(A) -> B + 'static, ) -> Box<dyn Fn(E) -> B>

where A: 'static, B: 'static,

Functor fmap for Reader: post-compose a function.

fmap(f, reader) = |e| f(reader(e))

pub fn pure<A>(a: A) -> Box<dyn Fn(E) -> A>

where A: Clone + 'static,

Applicative pure for Reader: ignore the environment, return a constant.

pure(a) = |_e| a

pub fn chain<A, B>( fa: Box<dyn Fn(E) -> A>, f: impl Fn(A) -> Box<dyn Fn(E) -> B> + 'static, ) -> Box<dyn Fn(E) -> B>

where A: 'static, B: 'static,

Monadic chain (bind) for Reader: Kleisli composition.

chain(reader, f) = |e| f(reader(e))(e)

pub fn ask() -> Box<dyn Fn(E) -> E>

Reader-specific: access the environment directly.

ask() = |e| e

pub fn local<A>( f: impl Fn(E) -> E + 'static, reader: Box<dyn Fn(E) -> A>, ) -> Box<dyn Fn(E) -> A>

where A: 'static,

Reader-specific: modify the environment before running a reader.

local(f, reader) = |e| reader(f(e))

Trait Implementations

impl<E> Adjunction<EnvF<E>, ReaderF<E>> for CurryAdj<E>

where E: Clone + 'static,

Available on crate features alloc or std only.

fn unit<A>(a: A) -> Box<dyn Fn(E) -> (E, A)>

where A: Clone + 'static,

unit: A -> U(F(A))

fn counit<B>(fub: (E, Box<dyn Fn(E) -> B>)) -> B

where B: 'static,

counit: F(U(B)) -> B

impl<E> HKT for ReaderF<E>

where E: 'static,

Available on crate features alloc or std only.

type Of<T> = Box<dyn Fn(E) -> T>