Trait Foldable 

pub trait Foldable: Kind_cdc7cd43dac7585f {
    // Provided methods
    fn fold_right<'a, FnBrand, A: 'a + Clone, B: 'a, 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, A: 'a + Clone, B: 'a, 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, A: 'a + Clone, M, 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, A: 'a + Clone, B: 'a, 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 A B. ((A, B) -> B, B, Self A) -> B

Type Parameters

• 'a: The lifetime of the elements.
• FnBrand: The brand of the cloneable function to use.
• A: The type of the elements in the structure.
• B: The type of the accumulator.
• 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, A: 'a + Clone, B: 'a, 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 A B. ((B, A) -> B, B, Self A) -> B

Type Parameters

• 'a: The lifetime of the elements.
• FnBrand: The brand of the cloneable function to use.
• A: The type of the elements in the structure.
• B: The type of the accumulator.
• 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, A: 'a + Clone, M, 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 A M. Monoid M => (A -> M, Self A) -> M

Type Parameters

• 'a: The lifetime of the elements.
• FnBrand: The brand of the cloneable function to use.
• A: The type of the elements in the structure.
• M: The type of the monoid.
• 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 CatListBrand

impl Foldable for IdentityBrand

impl Foldable for OptionBrand

impl Foldable for ThunkBrand

impl Foldable for Tuple1Brand

impl Foldable for VecBrand

impl<A: 'static> Foldable for TryThunkWithOkBrand<A>

Type Parameters

• A: The success type.

impl<DoneType: 'static> Foldable for StepWithDoneBrand<DoneType>

Type Parameters

• DoneType: The done type.

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

Type Parameters

• E: The error type.

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

Type Parameters

• E: The error type.

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

Type Parameters

• First: The type of the first value in the pair.

Type Parameters

• First: The type of the first value in the pair.

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

Type Parameters

• First: The type of the first value in the tuple.

impl<LoopType: 'static> Foldable for StepWithLoopBrand<LoopType>

Type Parameters

• LoopType: The loop type.

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

Type Parameters

• Second: The type of the second value in the pair.

Type Parameters

• Second: The type of the second value in the pair.

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

Type Parameters

• Second: The type of the second value in the tuple.

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

Type Parameters

• T: The success type.