Skip to main content

SendRefFoldable

fp_library::classes::send_ref_foldable

Trait SendRefFoldable 

Source 
pub trait SendRefFoldable: Kind_cdc7cd43dac7585f {
    // Provided methods
    fn send_ref_fold_map<'a, FnBrand, A: Send + Sync + 'a + Clone, M>(
        func: impl Fn(&A) -> M + Send + Sync + 'a,
        fa: &<Self as Kind_cdc7cd43dac7585f>::Of<'a, A>,
    ) -> M
       where FnBrand: SendLiftFn + 'a,
             M: Monoid + Send + Sync + 'a { ... }
    fn send_ref_fold_right<'a, FnBrand, A: Send + Sync + 'a + Clone, B: Send + Sync + 'a>(
        func: impl Fn(&A, B) -> B + Send + Sync + 'a,
        initial: B,
        fa: &<Self as Kind_cdc7cd43dac7585f>::Of<'a, A>,
    ) -> B
       where FnBrand: SendLiftFn + 'a { ... }
    fn send_ref_fold_left<'a, FnBrand, A: Send + Sync + 'a + Clone, B: Send + Sync + 'a>(
        func: impl Fn(B, &A) -> B + Send + Sync + 'a,
        initial: B,
        fa: &<Self as Kind_cdc7cd43dac7585f>::Of<'a, A>,
    ) -> B
       where FnBrand: SendLiftFn + 'a { ... }
}
Expand description

Thread-safe by-reference folding over a structure.

Similar to RefFoldable, but closures and elements must be Send + Sync. Unlike ParRefFunctor (which requires RefFunctor as a supertrait), SendRefFoldable does not require RefFoldable. This is because the SendRef monadic traits (functor, pointed, lift, applicative) construct new containers internally, and ArcLazy::new requires Send on closures, which Ref trait signatures do not guarantee. The SendRef and Ref hierarchies are therefore independent.

All three methods (send_ref_fold_map, send_ref_fold_right, send_ref_fold_left) have default implementations in terms of each other, so implementors only need to provide one.

Provided Methods§

Source

fn send_ref_fold_map<'a, FnBrand, A: Send + Sync + 'a + Clone, M>( func: impl Fn(&A) -> M + Send + Sync + 'a, fa: &<Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> M
where FnBrand: SendLiftFn + 'a, M: Monoid + Send + Sync + 'a,

Maps values to a monoid by reference and combines them (thread-safe).

§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.
  • M: The monoid type.
§Parameters
  • func: The function to map each element reference to a monoid. Must be Send + Sync.
  • fa: The structure to fold.
§Returns

The combined monoid value.

§Examples
use fp_library::{
	brands::*,
	classes::send_ref_foldable::*,
	types::*,
};

let lazy = ArcLazy::new(|| 5);
let result = send_ref_fold_map::<ArcFnBrand, LazyBrand<ArcLazyConfig>, _, _>(
	|a: &i32| a.to_string(),
	&lazy,
);
assert_eq!(result, "5");
Source

fn send_ref_fold_right<'a, FnBrand, A: Send + Sync + 'a + Clone, B: Send + Sync + 'a>( func: impl Fn(&A, B) -> B + Send + Sync + 'a, initial: B, fa: &<Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> B
where FnBrand: SendLiftFn + 'a,

Folds the structure from the right by reference (thread-safe).

§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.
  • B: The type of the accumulator.
§Parameters
  • func: The function to apply to each element reference and accumulator. Must be Send + Sync.
  • initial: The initial value of the accumulator.
  • fa: The structure to fold.
§Returns

The final accumulator value.

§Examples
use fp_library::{
	brands::*,
	classes::send_ref_foldable::SendRefFoldable,
	types::*,
};

let lazy = ArcLazy::new(|| 10);
let result = <LazyBrand<ArcLazyConfig> as SendRefFoldable>::send_ref_fold_right::<
	ArcFnBrand,
	_,
	_,
>(|a: &i32, acc: i32| acc + *a, 0, &lazy);
assert_eq!(result, 10);
Source

fn send_ref_fold_left<'a, FnBrand, A: Send + Sync + 'a + Clone, B: Send + Sync + 'a>( func: impl Fn(B, &A) -> B + Send + Sync + 'a, initial: B, fa: &<Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> B
where FnBrand: SendLiftFn + 'a,

Folds the structure from the left by reference (thread-safe).

§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.
  • B: The type of the accumulator.
§Parameters
  • func: The function to apply to the accumulator and each element reference. Must be Send + Sync.
  • initial: The initial value of the accumulator.
  • fa: The structure to fold.
§Returns

The final accumulator value.

§Examples
use fp_library::{
	brands::*,
	classes::send_ref_foldable::SendRefFoldable,
	types::*,
};

let lazy = ArcLazy::new(|| 10);
let result = <LazyBrand<ArcLazyConfig> as SendRefFoldable>::send_ref_fold_left::<
	ArcFnBrand,
	_,
	_,
>(|acc: i32, a: &i32| acc + *a, 0, &lazy);
assert_eq!(result, 10);

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§