Struct Fold

pub struct Fold<'a, M, D> { /* private fields */ }

A representation of an arbitrary Foldable fold.

This struct is what facilitates lazy evaluation of Folds, allowing them to be chained together with other Directive, and evaluated in a single pass.

Where a Foldable defines the semantics of folding over a structure, Fold represents an instance of a fold over that type. In other words, Fold is simply a pairing of a Foldable with the Monoid that will be used to combine its values.

A subtle implementation detail is that we do not actually embed a Foldable, but rather a Directive that outputs a Foldable. 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, M: Monoid + 'static, F: Foldable<'a, M::Elem, A = M::Elem> + Send, D: Directive<Output = F> + Send> Directive for Fold<'a, M, D>

Directive implementation for Fold.

The implementation drives the evaluation of the input Directive, returning the input Foldable, and then folding the given Monoid over it.

type Input = F

type Output = <M as Monoid>::Elem

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.