Traversable

fp_library::classes::traversable

Trait Traversable 

Source 
pub trait Traversable: Functor + Foldable {
    // Provided methods
    fn traverse<'a, F: Applicative, Func, A: 'a + Clone, B: 'a + Clone>(
        func: Func,
        ta: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>,
    ) -> <F as Kind_cdc7cd43dac7585f>::Of<'a, <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>>
       where Func: Fn(A) -> <F as Kind_cdc7cd43dac7585f>::Of<'a, B> + 'a,
             <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>: Clone,
             <F as Kind_cdc7cd43dac7585f>::Of<'a, B>: Clone { ... }
    fn sequence<'a, F: Applicative, A: 'a + Clone>(
        ta: <Self as Kind_cdc7cd43dac7585f>::Of<'a, <F as Kind_cdc7cd43dac7585f>::Of<'a, A>>,
    ) -> <F as Kind_cdc7cd43dac7585f>::Of<'a, <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>>
       where <F as Kind_cdc7cd43dac7585f>::Of<'a, A>: Clone,
             <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>: Clone { ... }
}
Expand description

A type class for traversable functors.

Traversable functors can be traversed, which accumulates results and effects in some Applicative context.

Provided Methods§

Source

fn traverse<'a, F: Applicative, Func, A: 'a + Clone, B: 'a + Clone>( func: Func, ta: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> <F as Kind_cdc7cd43dac7585f>::Of<'a, <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>>
where Func: Fn(A) -> <F as Kind_cdc7cd43dac7585f>::Of<'a, B> + 'a, <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>: Clone, <F as Kind_cdc7cd43dac7585f>::Of<'a, B>: Clone,

Map each element of the Traversable structure to a computation, evaluate those computations and combine the results into an Applicative context.

The default implementation is defined in terms of sequence and Functor::map.

Note: This default implementation may be less efficient than a direct implementation because it performs two passes: first mapping the function to create an intermediate structure of computations, and then sequencing that structure. A direct implementation can often perform the traversal in a single pass without allocating an intermediate container. Types should provide their own implementation if possible.

§Type Signature

forall a b f. (Traversable t, Applicative f) => (a -> f b, t a) -> f (t b)

§Type Parameters
  • F: The applicative context.
  • Func: The type of the function to apply.
  • A: The type of the elements in the traversable structure.
  • B: The type of the elements in the resulting traversable structure.
§Parameters
  • func: The function to apply to each element, returning a value in an applicative context.
  • ta: The traversable structure.
§Returns

The traversable structure wrapped in the applicative context.

§Examples
use fp_library::classes::traversable::Traversable;
use fp_library::brands::OptionBrand;

let x = Some(5);
let y = OptionBrand::traverse::<OptionBrand, _, _, _>(|a| Some(a * 2), x);
assert_eq!(y, Some(Some(10)));
Source

fn sequence<'a, F: Applicative, A: 'a + Clone>( ta: <Self as Kind_cdc7cd43dac7585f>::Of<'a, <F as Kind_cdc7cd43dac7585f>::Of<'a, A>>, ) -> <F as Kind_cdc7cd43dac7585f>::Of<'a, <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>>
where <F as Kind_cdc7cd43dac7585f>::Of<'a, A>: Clone, <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>: Clone,

Evaluate each computation in a Traversable structure and accumulate the results into an Applicative context.

The default implementation is defined in terms of traverse and identity.

§Type Signature

forall a f. (Traversable t, Applicative f) => (t (f a)) -> f (t a)

§Type Parameters
  • F: The applicative context.
  • A: The type of the elements in the traversable structure.
§Parameters
  • ta: The traversable structure containing values in an applicative context.
§Returns

The traversable structure wrapped in the applicative context.

§Examples
use fp_library::classes::traversable::Traversable;
use fp_library::brands::OptionBrand;

let x = Some(Some(5));
let y = OptionBrand::sequence::<OptionBrand, _>(x);
assert_eq!(y, Some(Some(5)));

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§