Struct StepWithLoopBrand 

pub struct StepWithLoopBrand<A>(/* private fields */);

Brand for the partially-applied form of Step with the Loop type filled in.

Trait Implementations

impl<LoopType: Clone + 'static> ApplyFirst for StepWithLoopBrand<LoopType>

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<LoopType: Clone + 'static> ApplySecond for StepWithLoopBrand<LoopType>

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<A: Clone> Clone for StepWithLoopBrand<A>

fn clone(&self) -> StepWithLoopBrand<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for StepWithLoopBrand<A>

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

Formats the value using the given formatter.

impl<A: Default> Default for StepWithLoopBrand<A>

fn default() -> StepWithLoopBrand<A>

Returns the “default value” for a type.

impl<LoopType: 'static> Foldable for StepWithLoopBrand<LoopType>

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 step from the right.

This method performs a right-associative fold of the step.

Type Signature

forall self a b. Foldable self => ((a, b) -> b, b, self 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 step to fold.

Returns

func(a, initial) if fa is Done(a), otherwise initial.

Examples

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

assert_eq!(fold_right::<RcFnBrand, StepWithLoopBrand<()>, _, _, _>(|x, acc| x + acc, 0, Step::Done(5)), 5);
assert_eq!(fold_right::<RcFnBrand, StepWithLoopBrand<i32>, _, _, _>(|x: i32, acc| x + acc, 0, Step::Loop(1)), 0);

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 step from the left.

This method performs a left-associative fold of the step.

Type Signature

forall self a b. Foldable self => ((b, a) -> b, b, self 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 step to fold.

Returns

func(initial, a) if fa is Done(a), otherwise initial.

Examples

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

assert_eq!(fold_left::<RcFnBrand, StepWithLoopBrand<()>, _, _, _>(|acc, x| acc + x, 0, Step::Done(5)), 5);
assert_eq!(fold_left::<RcFnBrand, StepWithLoopBrand<i32>, _, _, _>(|acc, x: i32| acc + x, 0, Step::Loop(1)), 0);

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

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

Maps the value to a monoid and returns it.

This method maps the element of the step to a monoid and then returns it.

Type Signature

forall self a m. (Foldable self, Monoid m) => (a -> m, self 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.
• F: The type of the mapping function.

Parameters

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

Returns

func(a) if fa is Done(a), otherwise M::empty().

Examples

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

assert_eq!(
    fold_map::<RcFnBrand, StepWithLoopBrand<()>, _, _, _>(|x: i32| x.to_string(), Step::Done(5)),
    "5".to_string()
);
assert_eq!(
    fold_map::<RcFnBrand, StepWithLoopBrand<i32>, _, _, _>(|x: i32| x.to_string(), Step::Loop(1)),
    "".to_string()
);

impl<LoopType: 'static> Functor for StepWithLoopBrand<LoopType>

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 done value in the step.

This method applies a function to the done value inside the step, producing a new step with the transformed done value. The loop value remains unchanged.

Type Signature

forall self a b. Functor self => (a -> b, self a) -> self b

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the done 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 done value.
• fa: The step to map over.

Returns

A new step containing the result of applying the function to the done value.

Examples

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

assert_eq!(map::<StepWithLoopBrand<i32>, _, _, _>(|x: i32| x * 2, Step::<i32, i32>::Done(5)), Step::Done(10));

impl<A: Hash> Hash for StepWithLoopBrand<A>

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<LoopType: 'static> Kind_cdc7cd43dac7585f for StepWithLoopBrand<LoopType>

Generated implementation of Kind_cdc7cd43dac7585f for StepWithLoopBrand < LoopType >.

type Of<'a, B: 'a> = Step<LoopType, B>

The applied type.

impl<LoopType: Clone + 'static> Lift for StepWithLoopBrand<LoopType>

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 step context.

This method lifts a binary function to operate on values within the step context.

Type Signature

forall self a b c. Lift self => ((a, b) -> c, self a, self b) -> self c

Type Parameters

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

Parameters

• func: The binary function to apply.
• fa: The first step.
• fb: The second step.

Returns

Done(f(a, b)) if both steps are Done, otherwise the first loop encountered.

Examples

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

assert_eq!(
    lift2::<StepWithLoopBrand<()>, _, _, _, _>(|x: i32, y: i32| x + y, Step::Done(1), Step::Done(2)),
    Step::Done(3)
);
assert_eq!(
    lift2::<StepWithLoopBrand<i32>, _, _, _, _>(|x: i32, y: i32| x + y, Step::Done(1), Step::Loop(2)),
    Step::Loop(2)
);

impl<A: Ord> Ord for StepWithLoopBrand<A>

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

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, or returns empty, in parallel.

This method maps the element of the step to a monoid and then returns it. The mapping operation may be executed in parallel.

Type Signature

forall self a m. (ParFoldable self, Monoid m) => (a -> m, self 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 step to fold.

Returns

The combined monoid value.

Examples

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

let x: Step<i32, i32> = Step::Done(5);
let f = send_cloneable_fn_new::<ArcFnBrand, _, _>(|x: i32| x.to_string());
assert_eq!(par_fold_map::<ArcFnBrand, StepWithLoopBrand<i32>, _, _>(f.clone(), x), "5".to_string());

let x_loop: Step<i32, i32> = Step::Loop(1);
assert_eq!(par_fold_map::<ArcFnBrand, StepWithLoopBrand<i32>, _, _>(f, x_loop), "".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 step from the right in parallel.

This method folds the step by applying a function from right to left, potentially in parallel.

Type Signature

forall self a b. ParFoldable self => ((a, b) -> b, b, self 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 step to fold.

Returns

The final accumulator value.

Examples

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

let x: Step<i32, i32> = Step::Done(5);
let f = send_cloneable_fn_new::<ArcFnBrand, _, _>(|(a, b): (i32, i32)| a + b);
assert_eq!(par_fold_right::<ArcFnBrand, StepWithLoopBrand<i32>, _, _>(f.clone(), 10, x), 15);

let x_loop: Step<i32, i32> = Step::Loop(1);
assert_eq!(par_fold_right::<ArcFnBrand, StepWithLoopBrand<i32>, _, _>(f, 10, x_loop), 10);

impl<A: PartialEq> PartialEq for StepWithLoopBrand<A>

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

fn partial_cmp(&self, other: &StepWithLoopBrand<A>) -> 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<LoopType: 'static> Pointed for StepWithLoopBrand<LoopType>

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

Wraps a value in a step.

This method wraps a value in the Done variant of a Step.

Type Signature

forall self a. Pointed self => a -> self a

Type Parameters

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

Parameters

• a: The value to wrap.

Returns

Done(a).

Examples

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

assert_eq!(pure::<StepWithLoopBrand<()>, _>(5), Step::Done(5));

impl<LoopType: Clone + 'static> Semiapplicative for StepWithLoopBrand<LoopType>

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.

This method applies a function wrapped in a step to a value wrapped in a step.

Type Signature

forall self a b. Semiapplicative self => (self (a -> b), self a) -> self 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 step containing the function.
• fa: The step containing the value.

Returns

Done(f(a)) if both are Done, otherwise the first loop encountered.

Examples

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

let f: Step<_, _> = Step::Done(cloneable_fn_new::<RcFnBrand, _, _>(|x: i32| x * 2));
assert_eq!(apply::<RcFnBrand, StepWithLoopBrand<()>, _, _>(f, Step::Done(5)), Step::Done(10));

impl<LoopType: Clone + 'static> Semimonad for StepWithLoopBrand<LoopType>

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 step computations.

This method chains two computations, where the second computation depends on the result of the first.

Type Signature

forall self a b. Semimonad self => (self a, a -> self b) -> self 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 step.
• func: The function to apply to the value inside the step.

Returns

The result of applying f to the value if ma is Done, otherwise the original loop.

Examples

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

assert_eq!(
    bind::<StepWithLoopBrand<()>, _, _, _>(Step::Done(5), |x| Step::Done(x * 2)),
    Step::Done(10)
);

impl<LoopType: Clone + 'static> Traversable for StepWithLoopBrand<LoopType>

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 step with an applicative function.

This method maps the element of the step to a computation, evaluates it, and combines the result into an applicative context.

Type Signature

forall self a b f. (Traversable self, Applicative f) => (a -> f b, self a) -> f (self 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 step to traverse.

Returns

The step wrapped in the applicative context.

Examples

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

assert_eq!(
    traverse::<StepWithLoopBrand<()>, _, _, OptionBrand, _>(|x| Some(x * 2), Step::Done(5)),
    Some(Step::Done(10))
);
assert_eq!(
    traverse::<StepWithLoopBrand<i32>, _, _, OptionBrand, _>(|x: i32| Some(x * 2), Step::Loop(1)),
    Some(Step::Loop(1))
);

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 step of applicative.

This method evaluates the computation inside the step and accumulates the result into an applicative context.

Type Signature

forall self a f. (Traversable self, Applicative f) => self (f a) -> f (self 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 step containing the applicative value.

Returns

The step wrapped in the applicative context.

Examples

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

assert_eq!(
    sequence::<StepWithLoopBrand<()>, _, OptionBrand>(Step::Done(Some(5))),
    Some(Step::Done(5))
);
assert_eq!(
    sequence::<StepWithLoopBrand<i32>, i32, OptionBrand>(Step::Loop::<i32, Option<i32>>(1)),
    Some(Step::Loop::<i32, i32>(1))
);

impl<A: Copy> Copy for StepWithLoopBrand<A>

impl<A: Eq> Eq for StepWithLoopBrand<A>

impl<A> StructuralPartialEq for StepWithLoopBrand<A>