Struct Map

pub struct Map<'a, Op, D> { /* private fields */ }

A representation of an arbitrary Functor mapping.

This struct is what facilitates lazy evaluation of Functor mappings, allowing them to be chained together and evaluated in a single pass.

Where a Functor defines the semantics of a mapping over a type, Map represents an instance of a mapping over that type. In other words, Map is simply a pairing of a Functor with the Operation that will be mapped over it.

A subtle implementation detail is that we do not actually embed a Functor, but rather a Directive that outputs a Functor. This is what allows us to chain Directives together, as the output of one Directive is the input to the next.

Trait Implementations

impl<'a, Op: Operation, F: Functor<'a, Op::Output, A = Op::Input> + Send, D: Directive<Output = F> + Send> Directive for Map<'a, Op, D>

Directive implementation for Map.

The implementation drives the evaluation of the input Directive, returning the input Functor, and then mapping the given Operation over it.

type Input = F

type Output = <F as HKT<<Op as Operation>::Output>>::Target

fn run<'life0, 'async_trait>( self, runtime: &'life0 Runtime, ) -> Pin<Box<dyn Future<Output = Result<Self::Output>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Run this Directive on the given Runtime.

fn map<'a, Op, F>(self, op: &'a Op) -> Map<'a, Op, Self>

where Op: Operation, F: Functor<'a, Op::Output, A = Op::Input>, Self: Sized + Directive<Output = F>,

Map this Directive’s output over the given Operation.

fn fold<'a, M, F>(self, m: &'a M) -> Fold<'a, M, Self>

where M: Monoid, F: Foldable<'a, M::Elem, A = M::Elem>, Self: Sized + Directive<Output = F>,

Fold this Directive over the given Monoid until a single value is produced.