Trait Foldable 

pub trait Foldable: Kind_c3c3610c70409ee6 {
    // Provided methods
    fn fold_right<'a, A: 'a + Clone, B: 'a, F>(
        f: F,
        init: B,
        fa: <Self as Kind_c3c3610c70409ee6>::Of<'a, A>,
    ) -> B
       where F: Fn(A, B) -> B + 'a { ... }
    fn fold_left<'a, A: 'a + Clone, B: 'a, F>(
        f: F,
        init: B,
        fa: <Self as Kind_c3c3610c70409ee6>::Of<'a, A>,
    ) -> B
       where F: Fn(B, A) -> B + 'a { ... }
    fn fold_map<'a, A: 'a + Clone, M, F>(
        f: F,
        fa: <Self as Kind_c3c3610c70409ee6>::Of<'a, A>,
    ) -> M
       where M: Monoid + 'a,
             F: Fn(A) -> M + '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, A: 'a + Clone, B: 'a, F>( f: F, init: B, fa: <Self as Kind_c3c3610c70409ee6>::Of<'a, A>, ) -> B

where F: Fn(A, B) -> B + 'a,

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

Type Signature

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

Parameters

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

Returns

The final accumulator value.

Examples

use fp_library::classes::foldable::Foldable;
use fp_library::brands::OptionBrand;

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

fn fold_left<'a, A: 'a + Clone, B: 'a, F>( f: F, init: B, fa: <Self as Kind_c3c3610c70409ee6>::Of<'a, A>, ) -> B

where F: Fn(B, A) -> B + 'a,

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

Type Signature

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

Parameters

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

Returns

The final accumulator value.

Examples

use fp_library::classes::foldable::Foldable;
use fp_library::brands::OptionBrand;

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

fn fold_map<'a, A: 'a + Clone, M, F>( f: F, fa: <Self as Kind_c3c3610c70409ee6>::Of<'a, A>, ) -> M

where M: Monoid + 'a, F: Fn(A) -> M + 'a,

Maps values to a monoid and combines them.

Type Signature

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

Parameters

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

Returns

The combined monoid value.

Examples

use fp_library::classes::foldable::Foldable;
use fp_library::brands::OptionBrand;
use fp_library::types::string; // Import Monoid impl for String

let x = Some(5);
let y = OptionBrand::fold_map(|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>