Struct Tuple2SecondAppliedBrand 

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

Brand for (First, Second), with Second applied (Functor over First).

Trait Implementations

impl<Second: Clone + Semigroup + 'static> ApplyFirst for Tuple2SecondAppliedBrand<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 Tuple2SecondAppliedBrand<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 Tuple2SecondAppliedBrand<Second>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Second: Debug> Debug for Tuple2SecondAppliedBrand<Second>

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

Formats the value using the given formatter.

impl<Second: Default> Default for Tuple2SecondAppliedBrand<Second>

fn default() -> Tuple2SecondAppliedBrand<Second>

Returns the “default value” for a type.

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

Type Parameters

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

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

where 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, Tuple2SecondApplied 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.

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, Tuple2SecondAppliedBrand<()>, _, _>(|x, acc| x + acc, 0, (5, ())),
	5
);

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

where 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, Tuple2SecondApplied 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.

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, Tuple2SecondAppliedBrand<()>, _, _>(|acc, x| acc + x, 0, (5, ())),
	5
);

fn fold_map<'a, FnBrand, A: 'a + Clone, M>( func: impl Fn(A) -> M + 'a, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> M

where M: Monoid + '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, Tuple2SecondApplied 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.

Parameters

• func: The mapping function.
• fa: The tuple to fold.

Returns

func(a).

Examples

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

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

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

Type Parameters

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

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

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, Tuple2SecondApplied Second A) -> Tuple2SecondApplied 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.

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::<Tuple2SecondAppliedBrand<_>, _, _>(|x: i32| x * 2, (5, 1)), (10, 1));

impl<Second: Hash> Hash for Tuple2SecondAppliedBrand<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 Tuple2SecondAppliedBrand<Second>

Generated implementation of Kind_cdc7cd43dac7585f for Tuple2SecondAppliedBrand < Second >.

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

The applied type.

impl<Second> Lift for Tuple2SecondAppliedBrand<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: impl Fn(A, B) -> C + 'a, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, fb: <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, C>

where 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, Tuple2SecondApplied Second A, Tuple2SecondApplied Second B) -> Tuple2SecondApplied 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.

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::<Tuple2SecondAppliedBrand<String>, _, _, _>(
		|x, y| x + y,
		(1, "a".to_string()),
		(2, "b".to_string())
	),
	(3, "ab".to_string())
);

impl<Second: Ord> Ord for Tuple2SecondAppliedBrand<Second>

fn cmp(&self, other: &Tuple2SecondAppliedBrand<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 Tuple2SecondAppliedBrand<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, Tuple2SecondApplied 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, Tuple2SecondAppliedBrand<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, Tuple2SecondApplied 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, Tuple2SecondAppliedBrand<String>, _, _>(f, 10, x), 11);

impl<Second: PartialEq> PartialEq for Tuple2SecondAppliedBrand<Second>

fn eq(&self, other: &Tuple2SecondAppliedBrand<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 Tuple2SecondAppliedBrand<Second>

fn partial_cmp( &self, other: &Tuple2SecondAppliedBrand<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 Tuple2SecondAppliedBrand<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 -> Tuple2SecondApplied 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::<Tuple2SecondAppliedBrand<String>, _>(5), (5, "".to_string()));

impl<Second> Semiapplicative for Tuple2SecondAppliedBrand<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 => (Tuple2SecondApplied Second (A -> B), Tuple2SecondApplied Second A) -> Tuple2SecondApplied 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, Tuple2SecondAppliedBrand<String>, _, _>(f, (5, "b".to_string())),
	(10, "ab".to_string())
);

impl<Second> Semimonad for Tuple2SecondAppliedBrand<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>( ma: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, func: impl Fn(A) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B> + 'a, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>

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 => (Tuple2SecondApplied Second A, A -> Tuple2SecondApplied Second B) -> Tuple2SecondApplied 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.

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::<Tuple2SecondAppliedBrand<String>, _, _>((5, "a".to_string()), |x| (
		x * 2,
		"b".to_string()
	)),
	(10, "ab".to_string())
);

impl<Second: Clone + 'static> Traversable for Tuple2SecondAppliedBrand<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: impl Fn(A) -> <F as Kind_cdc7cd43dac7585f>::Of<'a, B> + 'a, ta: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> <F as Kind_cdc7cd43dac7585f>::Of<'a, <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>>

where <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, Tuple2SecondApplied Second A) -> F (Tuple2SecondApplied 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.

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::<Tuple2SecondAppliedBrand<()>, _, _, 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 => Tuple2SecondApplied Second (F A) -> F (Tuple2SecondApplied 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::<Tuple2SecondAppliedBrand<()>, _, OptionBrand>((Some(5), ())),
	Some((5, ()))
);

impl<Second: Copy> Copy for Tuple2SecondAppliedBrand<Second>

impl<Second: Eq> Eq for Tuple2SecondAppliedBrand<Second>

impl<Second> StructuralPartialEq for Tuple2SecondAppliedBrand<Second>