Struct Tuple2FirstAppliedBrand 

pub struct Tuple2FirstAppliedBrand<First>(/* private fields */);

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

Trait Implementations

impl<First: Clone + Semigroup + 'static> ApplyFirst for Tuple2FirstAppliedBrand<First>

Type Parameters

• First: The type of the first 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<First: Clone + Semigroup + 'static> ApplySecond for Tuple2FirstAppliedBrand<First>

Type Parameters

• First: The type of the first 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<First: Clone> Clone for Tuple2FirstAppliedBrand<First>

fn clone(&self) -> Tuple2FirstAppliedBrand<First>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<First: Debug> Debug for Tuple2FirstAppliedBrand<First>

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

Formats the value using the given formatter.

impl<First: Default> Default for Tuple2FirstAppliedBrand<First>

fn default() -> Tuple2FirstAppliedBrand<First>

Returns the “default value” for a type.

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

Type Parameters

• First: The type of the first 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 second).

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

Type Signature

forall First A B. ((A, B) -> B, B, Tuple2FirstApplied First 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, Tuple2FirstAppliedBrand<()>, _, _>(|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 second).

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

Type Signature

forall First A B. ((B, A) -> B, B, Tuple2FirstApplied First 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 function to apply to the accumulator and each element.
• initial: The initial value of the accumulator.
• fa: The tuple to fold.

Returns

func(initial, a).

Examples

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

assert_eq!(
	fold_left::<RcFnBrand, Tuple2FirstAppliedBrand<()>, _, _>(|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 second).

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

Type Signature

forall First A M. Monoid M => (A -> M, Tuple2FirstApplied First 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, Tuple2FirstAppliedBrand<()>, _, _>(|x: i32| x.to_string(), ((), 5)),
	"5".to_string()
);

impl<First: 'static> Functor for Tuple2FirstAppliedBrand<First>

Type Parameters

• First: The type of the first 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 second value in the tuple.

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

Type Signature

forall First A B. (A -> B, Tuple2FirstApplied First A) -> Tuple2FirstApplied First B

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the second value.
• B: The type of the result of applying the function.

Parameters

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

Returns

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

Examples

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

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

impl<First: Hash> Hash for Tuple2FirstAppliedBrand<First>

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<First: 'static> Kind_cdc7cd43dac7585f for Tuple2FirstAppliedBrand<First>

Generated implementation of Kind_cdc7cd43dac7585f for Tuple2FirstAppliedBrand < First >.

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

The applied type.

impl<First> Lift for Tuple2FirstAppliedBrand<First>

where First: Semigroup + Clone + 'static,

Type Parameters

• First: The type of the first 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 second).

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

Type Signature

forall First A B C. Semigroup First => ((A, B) -> C, Tuple2FirstApplied First A, Tuple2FirstApplied First B) -> Tuple2FirstApplied First C

Type Parameters

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

Parameters

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

Returns

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

Examples

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

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

impl<First: Ord> Ord for Tuple2FirstAppliedBrand<First>

fn cmp(&self, other: &Tuple2FirstAppliedBrand<First>) -> 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<First: 'static> ParFoldable for Tuple2FirstAppliedBrand<First>

Type Parameters

• First: The type of the first 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 second).

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

Type Signature

forall First A M. Monoid M => (A -> M, Tuple2FirstApplied First 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 = ("a".to_string(), 1);
let f = send_cloneable_fn_new::<ArcFnBrand, _, _>(|x: i32| x.to_string());
assert_eq!(
	par_fold_map::<ArcFnBrand, Tuple2FirstAppliedBrand<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 second).

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

Type Signature

forall First A B. ((A, B) -> B, B, Tuple2FirstApplied First 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 = ("a".to_string(), 1);
let f = send_cloneable_fn_new::<ArcFnBrand, _, _>(|(a, b): (i32, i32)| a + b);
assert_eq!(par_fold_right::<ArcFnBrand, Tuple2FirstAppliedBrand<String>, _, _>(f, 10, x), 11);

impl<First: PartialEq> PartialEq for Tuple2FirstAppliedBrand<First>

fn eq(&self, other: &Tuple2FirstAppliedBrand<First>) -> 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<First: PartialOrd> PartialOrd for Tuple2FirstAppliedBrand<First>

fn partial_cmp( &self, other: &Tuple2FirstAppliedBrand<First>, ) -> 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<First> Pointed for Tuple2FirstAppliedBrand<First>

where First: Monoid + Clone + 'static,

Type Parameters

• First: The type of the first 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 first).

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

Type Signature

forall First A. Monoid First => A -> Tuple2FirstApplied First 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 the empty value of the first type and a.

Examples

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

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

impl<First> Semiapplicative for Tuple2FirstAppliedBrand<First>

where First: Semigroup + Clone + 'static,

Type Parameters

• First: The type of the first 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 second).

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

Type Signature

forall First A B. Semigroup First => (Tuple2FirstApplied First (A -> B), Tuple2FirstApplied First A) -> Tuple2FirstApplied First 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 first values are combined and the function is applied to the second value.

Examples

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

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

impl<First> Semimonad for Tuple2FirstAppliedBrand<First>

where First: Semigroup + Clone + 'static,

Type Parameters

• First: The type of the first 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 second).

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

Type Signature

forall First A B. Semigroup First => (Tuple2FirstApplied First A, A -> Tuple2FirstApplied First B) -> Tuple2FirstApplied First 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 second value.

Returns

A new tuple where the first values are combined.

Examples

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

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

impl<First: Clone + 'static> Traversable for Tuple2FirstAppliedBrand<First>

Type Parameters

• First: The type of the first 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 second).

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

Type Signature

forall First A B F. Applicative F => (A -> F B, Tuple2FirstApplied First A) -> F (Tuple2FirstApplied First 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 to each element, returning a value in an applicative context.
• ta: The tuple to traverse.

Returns

The tuple wrapped in the applicative context.

Examples

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

assert_eq!(
	traverse::<Tuple2FirstAppliedBrand<()>, _, _, 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 second).

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

Type Signature

forall First A F. Applicative F => Tuple2FirstApplied First (F A) -> F (Tuple2FirstApplied First 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::<Tuple2FirstAppliedBrand<()>, _, OptionBrand>(((), Some(5))),
	Some(((), 5))
);

impl<First: Copy> Copy for Tuple2FirstAppliedBrand<First>

impl<First: Eq> Eq for Tuple2FirstAppliedBrand<First>

impl<First> StructuralPartialEq for Tuple2FirstAppliedBrand<First>