Trait Foldable 

pub trait Foldable: Kind_cdc7cd43dac7585f {
    // Provided methods
    fn fold_right<'a, FnBrand, B: 'a, A: 'a + Clone, Func>(
        func: Func,
        initial: B,
        fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>,
    ) -> B
       where Func: Fn(A, B) -> B + 'a,
             FnBrand: CloneableFn + 'a { ... }
    fn fold_left<'a, FnBrand, B: 'a, A: 'a + Clone, Func>(
        func: Func,
        initial: B,
        fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>,
    ) -> B
       where Func: Fn(B, A) -> B + 'a,
             FnBrand: CloneableFn + 'a { ... }
    fn fold_map<'a, FnBrand, M, A: 'a + Clone, Func>(
        func: Func,
        fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>,
    ) -> M
       where M: Monoid + 'a,
             Func: Fn(A) -> M + 'a,
             FnBrand: CloneableFn + 'a { ... }
}

A type class for structures that can be folded to a single value.

A Foldable represents a structure that can be folded over to combine its elements into a single result.

Minimal Implementation

A minimal implementation of Foldable requires implementing either Foldable::fold_right or Foldable::fold_map.

• If Foldable::fold_right is implemented, Foldable::fold_map and Foldable::fold_left are derived from it.
• If Foldable::fold_map is implemented, Foldable::fold_right is derived from it, and Foldable::fold_left is derived from the derived Foldable::fold_right.

Note that Foldable::fold_left is not sufficient on its own because the default implementations of Foldable::fold_right and Foldable::fold_map do not depend on it.

Provided Methods

fn fold_right<'a, FnBrand, B: 'a, A: 'a + Clone, Func>( func: Func, initial: B, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> B

where Func: Fn(A, B) -> B + 'a, FnBrand: CloneableFn + 'a,

Folds the structure by applying a function from right to left.

This method performs a right-associative fold of the structure.

Type Signature

forall f b a. Foldable f => ((a, b) -> b, b, f a) -> b

Type Parameters

• FnBrand: The brand of the cloneable function to use.
• B: The type of the accumulator.
• A: The type of the elements in the structure.
• Func: The type of the folding function.

Parameters

• func: The function to apply to each element and the accumulator.
• initial: The initial value of the accumulator.
• fa: The structure to fold.

Returns

The final accumulator value.

Examples

use fp_library::{brands::*, functions::*};

let x = Some(5);
let y = fold_right::<RcFnBrand, OptionBrand, _, _, _>(|a, b| a + b, 10, x);
assert_eq!(y, 15);

fn fold_left<'a, FnBrand, B: 'a, A: 'a + Clone, Func>( func: Func, initial: B, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> B

where Func: Fn(B, A) -> B + 'a, FnBrand: CloneableFn + 'a,

Folds the structure by applying a function from left to right.

This method performs a left-associative fold of the structure.

Type Signature

forall f b a. Foldable f => ((b, a) -> b, b, f a) -> b

Type Parameters

• FnBrand: The brand of the cloneable function to use.
• B: The type of the accumulator.
• A: The type of the elements in the structure.
• Func: The type of the folding function.

Parameters

• func: The function to apply to the accumulator and each element.
• initial: The initial value of the accumulator.
• fa: The structure to fold.

Returns

The final accumulator value.

Examples

use fp_library::{brands::*, functions::*};

let x = Some(5);
let y = fold_left::<RcFnBrand, OptionBrand, _, _, _>(|b, a| b + a, 10, x);
assert_eq!(y, 15);

fn fold_map<'a, FnBrand, M, A: 'a + Clone, Func>( func: Func, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> M

where M: Monoid + 'a, Func: Fn(A) -> M + 'a, FnBrand: CloneableFn + 'a,

Maps values to a monoid and combines them.

This method maps each element of the structure to a monoid and then combines the results using the monoid’s append operation.

Type Signature

forall f m a. (Foldable f, Monoid m) => ((a) -> m, f a) -> m

Type Parameters

• FnBrand: The brand of the cloneable function to use.
• M: The type of the monoid.
• A: The type of the elements in the structure.
• Func: The type of the mapping function.

Parameters

• func: The function to map each element to a monoid.
• fa: The structure to fold.

Returns

The combined monoid value.

Examples

use fp_library::{brands::*, functions::*};

let x = Some(5);
let y = fold_map::<RcFnBrand, OptionBrand, _, _, _>(|a: i32| a.to_string(), x);
assert_eq!(y, "5".to_string());

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Foldable for IdentityBrand

impl Foldable for OptionBrand

impl Foldable for VecBrand

impl<E: 'static> Foldable for ResultWithErrBrand<E>

impl<First: 'static> Foldable for PairWithFirstBrand<First>

impl<Second: 'static> Foldable for PairWithSecondBrand<Second>

impl<T: 'static> Foldable for ResultWithOkBrand<T>