Struct Tuple2WithSecondBrand 

pub struct Tuple2WithSecondBrand<Second>(/* private fields */);

Brand for (First, Second), with Second filled in (Functor over First).

Trait Implementations

impl<Second: Clone + Semigroup + 'static> ApplyFirst for Tuple2WithSecondBrand<Second>

Type Parameters

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

fn apply_first<'a, A: 'a + Clone, B: 'a + Clone>( fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, fb: <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>

Combines two contexts, keeping the value from the first context.

impl<Second: Clone + Semigroup + 'static> ApplySecond for Tuple2WithSecondBrand<Second>

Type Parameters

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

fn apply_second<'a, A: 'a + Clone, B: 'a + Clone>( fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, fb: <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>

Combines two contexts, keeping the value from the second context.

impl<Second: Clone> Clone for Tuple2WithSecondBrand<Second>

fn clone(&self) -> Tuple2WithSecondBrand<Second>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Second: Debug> Debug for Tuple2WithSecondBrand<Second>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Second: Default> Default for Tuple2WithSecondBrand<Second>

fn default() -> Tuple2WithSecondBrand<Second>

Returns the “default value” for a type.

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

Type Parameters

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

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

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

Folds the tuple from the right (over first).

This method performs a right-associative fold of the tuple (over first).

Type Signature

forall Second A B. ((A, B) -> B, B, Tuple2WithSecond Second A) -> B

Type Parameters

• 'a: The lifetime of the values.
• FnBrand: The brand of the cloneable function to use.
• A: The type of the elements in the structure.
• B: The type of the accumulator.
• F: The type of the folding function.

Parameters

• func: The folding function.
• initial: The initial value.
• fa: The tuple to fold.

Returns

func(a, initial).

Examples

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

assert_eq!(fold_right::<RcFnBrand, Tuple2WithSecondBrand<()>, _, _, _>(|x, acc| x + acc, 0, (5, ())), 5);

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

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

Folds the tuple from the left (over first).

This method performs a left-associative fold of the tuple (over first).

Type Signature

forall Second A B. ((B, A) -> B, B, Tuple2WithSecond Second A) -> B

Type Parameters

• 'a: The lifetime of the values.
• FnBrand: The brand of the cloneable function to use.
• A: The type of the elements in the structure.
• B: The type of the accumulator.
• F: The type of the folding function.

Parameters

• func: The folding function.
• initial: The initial value.
• fa: The tuple to fold.

Returns

func(initial, a).

Examples

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

assert_eq!(fold_left::<RcFnBrand, Tuple2WithSecondBrand<()>, _, _, _>(|acc, x| acc + x, 0, (5, ())), 5);

fn fold_map<'a, FnBrand, A: 'a, 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 the value to a monoid and returns it (over first).

This method maps the element of the tuple to a monoid and then returns it (over first).

Type Signature

forall Second A M. Monoid M => (A -> M, Tuple2WithSecond Second A) -> M

Type Parameters

• 'a: The lifetime of the values.
• 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 mapping function.
• fa: The tuple to fold.

Returns

func(a).

Examples

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

assert_eq!(
    fold_map::<RcFnBrand, Tuple2WithSecondBrand<()>, _, _, _>(|x: i32| x.to_string(), (5, ())),
    "5".to_string()
);

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

Type Parameters

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

fn map<'a, A: 'a, B: 'a, Func>( func: Func, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>

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

Maps a function over the first value in the tuple.

This method applies a function to the first value inside the tuple, producing a new tuple with the transformed first value. The second value remains unchanged.

Type Signature

forall Second A B. (A -> B, Tuple2WithSecond Second A) -> Tuple2WithSecond Second B

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the first value.
• B: The type of the result of applying the function.
• Func: The type of the function to apply.

Parameters

• func: The function to apply to the first value.
• fa: The tuple to map over.

Returns

A new tuple containing the result of applying the function to the first value.

Examples

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

assert_eq!(map::<Tuple2WithSecondBrand<_>, _, _, _>(|x: i32| x * 2, (5, 1)), (10, 1));

impl<Second: Hash> Hash for Tuple2WithSecondBrand<Second>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

Generated implementation of Kind_cdc7cd43dac7585f for Tuple2WithSecondBrand < Second >.

type Of<'a, A: 'a> = (A, Second)

The applied type.

impl<Second> Lift for Tuple2WithSecondBrand<Second>

where Second: Semigroup + Clone + 'static,

Type Parameters

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

fn lift2<'a, A, B, C, Func>( func: Func, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, fb: <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, C>

where Func: Fn(A, B) -> C + 'a, A: Clone + 'a, B: Clone + 'a, C: 'a,

Lifts a binary function into the tuple context (over first).

This method lifts a binary function to operate on the first values within the tuple context. The second values are combined using their Semigroup implementation.

Type Signature

forall Second A B C. Semigroup Second => ((A, B) -> C, Tuple2WithSecond Second A, Tuple2WithSecond Second B) -> Tuple2WithSecond Second C

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the first first value.
• B: The type of the second first value.
• C: The type of the result first value.
• Func: The type of the binary function.

Parameters

• func: The binary function to apply to the first values.
• fa: The first tuple.
• fb: The second tuple.

Returns

A new tuple where the first values are combined using f and the second values are combined using Semigroup::append.

Examples

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

assert_eq!(
    lift2::<Tuple2WithSecondBrand<String>, _, _, _, _>(|x, y| x + y, (1, "a".to_string()), (2, "b".to_string())),
    (3, "ab".to_string())
);

impl<Second: Ord> Ord for Tuple2WithSecondBrand<Second>

fn cmp(&self, other: &Tuple2WithSecondBrand<Second>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

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

Type Parameters

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

fn par_fold_map<'a, FnBrand, A, M>( func: <FnBrand as SendCloneableFn>::SendOf<'a, A, M>, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> M

where FnBrand: 'a + SendCloneableFn, A: 'a + Clone + Send + Sync, M: Monoid + Send + Sync + 'a,

Maps the value to a monoid and returns it in parallel (over first).

This method maps the element of the tuple to a monoid and then returns it (over first). The mapping operation may be executed in parallel.

Type Signature

forall Second A M. Monoid M => (A -> M, Tuple2WithSecond Second A) -> M

Type Parameters

• 'a: The lifetime of the values.
• FnBrand: The brand of the cloneable function wrapper.
• A: The element type.
• M: The monoid type.

Parameters

• func: The thread-safe function to map each element to a monoid.
• fa: The tuple to fold.

Returns

The combined monoid value.

Examples

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

let x = (1, "a".to_string());
let f = send_cloneable_fn_new::<ArcFnBrand, _, _>(|x: i32| x.to_string());
assert_eq!(
    par_fold_map::<ArcFnBrand, Tuple2WithSecondBrand<String>, _, _>(f, x),
    "1".to_string()
);

fn par_fold_right<'a, FnBrand, A, B>( func: <FnBrand as SendCloneableFn>::SendOf<'a, (A, B), B>, initial: B, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> B

where FnBrand: 'a + SendCloneableFn, A: 'a + Clone + Send + Sync, B: Send + Sync + 'a,

Folds the tuple from the right in parallel (over first).

This method folds the tuple by applying a function from right to left, potentially in parallel (over first).

Type Signature

forall Second A B. ((A, B) -> B, B, Tuple2WithSecond Second A) -> B

Type Parameters

• 'a: The lifetime of the values.
• FnBrand: The brand of the cloneable function wrapper.
• A: The element type.
• B: The accumulator type.

Parameters

• func: The thread-safe function to apply to each element and the accumulator.
• initial: The initial value.
• fa: The tuple to fold.

Returns

The final accumulator value.

Examples

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

let x = (1, "a".to_string());
let f = send_cloneable_fn_new::<ArcFnBrand, _, _>(|(a, b): (i32, i32)| a + b);
assert_eq!(par_fold_right::<ArcFnBrand, Tuple2WithSecondBrand<String>, _, _>(f, 10, x), 11);

impl<Second: PartialEq> PartialEq for Tuple2WithSecondBrand<Second>

fn eq(&self, other: &Tuple2WithSecondBrand<Second>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Second: PartialOrd> PartialOrd for Tuple2WithSecondBrand<Second>

fn partial_cmp(&self, other: &Tuple2WithSecondBrand<Second>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Second> Pointed for Tuple2WithSecondBrand<Second>

where Second: Monoid + Clone + 'static,

Type Parameters

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

fn pure<'a, A: 'a>(a: A) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>

Wraps a value in a tuple (with empty second).

This method wraps a value in a tuple, using the Monoid::empty() value for the second element.

Type Signature

forall Second A. Monoid Second => A -> Tuple2WithSecond Second A

Type Parameters

• 'a: The lifetime of the value.
• A: The type of the value to wrap.

Parameters

• a: The value to wrap.

Returns

A tuple containing a and the empty value of the second type.

Examples

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

assert_eq!(pure::<Tuple2WithSecondBrand<String>, _>(5), (5, "".to_string()));

impl<Second> Semiapplicative for Tuple2WithSecondBrand<Second>

where Second: Semigroup + Clone + 'static,

Type Parameters

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

fn apply<'a, FnBrand: 'a + CloneableFn, A: 'a + Clone, B: 'a>( ff: <Self as Kind_cdc7cd43dac7585f>::Of<'a, <FnBrand as CloneableFn>::Of<'a, A, B>>, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>

Applies a wrapped function to a wrapped value (over first).

This method applies a function wrapped in a tuple to a value wrapped in a tuple. The second values are combined using their Semigroup implementation.

Type Signature

forall Second A B. Semigroup Second => (Tuple2WithSecond Second (A -> B), Tuple2WithSecond Second A) -> Tuple2WithSecond Second B

Type Parameters

• 'a: The lifetime of the values.
• FnBrand: The brand of the cloneable function wrapper.
• A: The type of the input value.
• B: The type of the output value.

Parameters

• ff: The tuple containing the function.
• fa: The tuple containing the value.

Returns

A new tuple where the function is applied to the first value and the second values are combined.

Examples

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

let f = (cloneable_fn_new::<RcFnBrand, _, _>(|x: i32| x * 2), "a".to_string());
assert_eq!(apply::<RcFnBrand, Tuple2WithSecondBrand<String>, _, _>(f, (5, "b".to_string())), (10, "ab".to_string()));

impl<Second> Semimonad for Tuple2WithSecondBrand<Second>

where Second: Semigroup + Clone + 'static,

Type Parameters

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

fn bind<'a, A: 'a, B: 'a, Func>( ma: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, func: Func, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>

where Func: Fn(A) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B> + 'a,

Chains tuple computations (over first).

This method chains two computations, where the second computation depends on the result of the first. The second values are combined using their Semigroup implementation.

Type Signature

forall Second A B. Semigroup Second => (Tuple2WithSecond Second A, A -> Tuple2WithSecond Second B) -> Tuple2WithSecond Second B

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the result of the first computation.
• B: The type of the result of the second computation.
• Func: The type of the function to apply.

Parameters

• ma: The first tuple.
• func: The function to apply to the first value.

Returns

A new tuple where the second values are combined.

Examples

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

assert_eq!(
    bind::<Tuple2WithSecondBrand<String>, _, _, _>((5, "a".to_string()), |x| (x * 2, "b".to_string())),
    (10, "ab".to_string())
);

impl<Second: Clone + 'static> Traversable for Tuple2WithSecondBrand<Second>

Type Parameters

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

fn traverse<'a, A: 'a + Clone, B: 'a + Clone, F: Applicative, Func>( 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,

Traverses the tuple with an applicative function (over first).

This method maps the element of the tuple to a computation, evaluates it, and combines the result into an applicative context (over first).

Type Signature

forall Second A B F. Applicative F => (A -> F B, Tuple2WithSecond Second A) -> F (Tuple2WithSecond Second B)

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the elements in the traversable structure.
• B: The type of the elements in the resulting traversable structure.
• F: The applicative context.
• Func: The type of the function to apply.

Parameters

• func: The function to apply.
• ta: The tuple to traverse.

Returns

The tuple wrapped in the applicative context.

Examples

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

assert_eq!(
    traverse::<Tuple2WithSecondBrand<()>, _, _, OptionBrand, _>(|x| Some(x * 2), (5, ())),
    Some((10, ()))
);

fn sequence<'a, A: 'a + Clone, F: Applicative>( 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,

Sequences a tuple of applicative (over first).

This method evaluates the computation inside the tuple and accumulates the result into an applicative context (over first).

Type Signature

forall Second A F. Applicative F => Tuple2WithSecond Second (F A) -> F (Tuple2WithSecond Second A)

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the elements in the traversable structure.
• F: The applicative context.

Parameters

• ta: The tuple containing the applicative value.

Returns

The tuple wrapped in the applicative context.

Examples

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

assert_eq!(
    sequence::<Tuple2WithSecondBrand<()>, _, OptionBrand>((Some(5), ())),
    Some((5, ()))
);

impl<Second: Copy> Copy for Tuple2WithSecondBrand<Second>

impl<Second: Eq> Eq for Tuple2WithSecondBrand<Second>

impl<Second> StructuralPartialEq for Tuple2WithSecondBrand<Second>