Struct TryThunkWithOkBrand 

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

Brand for TryThunk with the success value filled in (Functor over Err).

Trait Implementations

impl<A: 'static> ApplyFirst for TryThunkWithOkBrand<A>

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<A: 'static> ApplySecond for TryThunkWithOkBrand<A>

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 TryThunkWithOkBrand<A>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for TryThunkWithOkBrand<A>

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

Formats the value using the given formatter.

impl<A: Default> Default for TryThunkWithOkBrand<A>

fn default() -> TryThunkWithOkBrand<A>

Returns the “default value” for a type.

impl<A: 'static> Foldable for TryThunkWithOkBrand<A>

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

where Func: Fn(E, B) -> B + 'a, FnBrand: CloneableFn + 'a,

Folds the TryThunk from the right (over error).

Type Signature

forall self e b. Foldable self => ((e, b) -> b, b, self e) -> b

Type Parameters

• 'a: The lifetime of the computation.
• FnBrand: The brand of the cloneable function to use.
• E: The type of the elements in the structure.
• B: The type of the accumulator.
• Func: The type of the folding function.

Parameters

• func: The function to apply to each element and the accumulator.
• initial: The initial value of the accumulator.
• fa: The TryThunk to fold.

Returns

The final accumulator value.

Examples

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

let try_thunk: TryThunk<i32, i32> = pure::<TryThunkWithOkBrand<i32>, _>(10);
let result = fold_right::<RcFnBrand, TryThunkWithOkBrand<i32>, _, _, _>(|a, b| a + b, 5, try_thunk);
assert_eq!(result, 15);

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

where Func: Fn(B, E) -> B + 'a, FnBrand: CloneableFn + 'a,

Folds the TryThunk from the left (over error).

Type Signature

forall self e b. Foldable self => ((b, e) -> b, b, self e) -> b

Type Parameters

• 'a: The lifetime of the computation.
• FnBrand: The brand of the cloneable function to use.
• E: The type of the elements in the structure.
• B: The type of the accumulator.
• Func: The type of the folding function.

Parameters

• func: The function to apply to the accumulator and each element.
• initial: The initial value of the accumulator.
• fa: The TryThunk to fold.

Returns

The final accumulator value.

Examples

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

let try_thunk: TryThunk<i32, i32> = pure::<TryThunkWithOkBrand<i32>, _>(10);
let result = fold_left::<RcFnBrand, TryThunkWithOkBrand<i32>, _, _, _>(|b, a| b + a, 5, try_thunk);
assert_eq!(result, 15);

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

where M: Monoid + 'a, Func: Fn(E) -> M + 'a, FnBrand: CloneableFn + 'a,

Maps the value to a monoid and returns it (over error).

Type Signature

forall self e m. (Foldable self, Monoid m) => (e -> m, self e) -> m

Type Parameters

• 'a: The lifetime of the computation.
• FnBrand: The brand of the cloneable function to use.
• E: 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 Thunk to fold.

Returns

The monoid value.

Examples

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

let try_thunk: TryThunk<i32, i32> = pure::<TryThunkWithOkBrand<i32>, _>(10);
let result = fold_map::<RcFnBrand, TryThunkWithOkBrand<i32>, _, _, _>(|a| a.to_string(), try_thunk);
assert_eq!(result, "10");

impl<A: 'static> Functor for TryThunkWithOkBrand<A>

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

where Func: Fn(E) -> E2 + 'a,

Maps a function over the error value in the TryThunk.

Type Signature

forall self e e2. Functor self => (e -> e2, self e) -> self e2

Type Parameters

• 'a: The lifetime of the computation.
• E: The type of the error value inside the TryThunk.
• E2: The type of the result of the transformation.
• Func: The type of the transformation function.

Parameters

• func: The function to apply to the error.
• fa: The TryThunk instance.

Returns

A new TryThunk instance with the transformed error.

Examples

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

let try_thunk: TryThunk<i32, i32> = pure::<TryThunkWithOkBrand<i32>, _>(10);
let mapped = map::<TryThunkWithOkBrand<i32>, _, _, _>(|x| x * 2, try_thunk);
assert_eq!(mapped.evaluate(), Err(20));

impl<A: Hash> Hash for TryThunkWithOkBrand<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<A: 'static> Kind_cdc7cd43dac7585f for TryThunkWithOkBrand<A>

Generated implementation of Kind_cdc7cd43dac7585f for TryThunkWithOkBrand < A >.

type Of<'a, E: 'a> = TryThunk<'a, A, E>

The applied type.

impl<A: 'static> Lift for TryThunkWithOkBrand<A>

fn lift2<'a, E1, E2, E3, Func>( func: Func, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, E1>, fb: <Self as Kind_cdc7cd43dac7585f>::Of<'a, E2>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, E3>

where Func: Fn(E1, E2) -> E3 + 'a, E1: Clone + 'a, E2: Clone + 'a, E3: 'a,

Lifts a binary function into the TryThunk context (over error).

Type Signature

forall self e1 e2 e3. Lift self => ((e1, e2) -> e3, self e1, self e2) -> self e3

Type Parameters

• 'a: The lifetime of the computation.
• E1: The type of the first error value.
• E2: The type of the second error value.
• E3: The type of the result error value.
• Func: The type of the binary function.

Parameters

• func: The binary function to apply to the errors.
• fa: The first TryThunk.
• fb: The second TryThunk.

Returns

A new TryThunk instance containing the result of applying the function to the errors.

Examples

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

let eval1: TryThunk<i32, i32> = pure::<TryThunkWithOkBrand<i32>, _>(10);
let eval2: TryThunk<i32, i32> = pure::<TryThunkWithOkBrand<i32>, _>(20);
let result = lift2::<TryThunkWithOkBrand<i32>, _, _, _, _>(|a, b| a + b, eval1, eval2);
assert_eq!(result.evaluate(), Err(30));

impl<A: Ord> Ord for TryThunkWithOkBrand<A>

fn cmp(&self, other: &TryThunkWithOkBrand<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<A: PartialEq> PartialEq for TryThunkWithOkBrand<A>

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

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

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

Wraps a value in a TryThunk context (as error).

Type Signature

forall self e. Pointed self => e -> self e

Type Parameters

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

Parameters

• e: The value to wrap.

Returns

A new TryThunk instance containing the value as an error.

Examples

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

let try_thunk: TryThunk<i32, i32> = pure::<TryThunkWithOkBrand<i32>, _>(42);
assert_eq!(try_thunk.evaluate(), Err(42));

impl<A: 'static> Semiapplicative for TryThunkWithOkBrand<A>

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

Applies a function wrapped in TryThunk (as error) to a value wrapped in TryThunk (as error).

Type Signature

forall self e1 e2. Semiapplicative self => (self (e1 -> e2), self e1) -> self e2

Type Parameters

• 'a: The lifetime of the computation.
• FnBrand: The brand of the cloneable function wrapper.
• E1: The type of the input error.
• E2: The type of the result error.

Parameters

• ff: The TryThunk containing the function (in Err).
• fa: The TryThunk containing the value (in Err).

Returns

A new TryThunk instance containing the result of applying the function.

Examples

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

let func: TryThunk<i32, _> = pure::<TryThunkWithOkBrand<i32>, _>(cloneable_fn_new::<RcFnBrand, _, _>(|x: i32| x * 2));
let val: TryThunk<i32, _> = pure::<TryThunkWithOkBrand<i32>, _>(21);
let result = apply::<RcFnBrand, TryThunkWithOkBrand<i32>, _, _>(func, val);
assert_eq!(result.evaluate(), Err(42));

impl<A: 'static> Semimonad for TryThunkWithOkBrand<A>

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

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

Chains TryThunk computations (over error).

Type Signature

forall self e1 e2. Semimonad self => (self e1, e1 -> self e2) -> self e2

Type Parameters

• 'a: The lifetime of the computation.
• E1: The type of the result of the first computation (error).
• E2: The type of the result of the new computation (error).
• Func: The type of the function to apply.

Parameters

• ma: The first TryThunk.
• func: The function to apply to the error result of the computation.

Returns

A new TryThunk instance representing the chained computation.

Examples

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

let try_thunk: TryThunk<i32, i32> = pure::<TryThunkWithOkBrand<i32>, _>(10);
let result = bind::<TryThunkWithOkBrand<i32>, _, _, _>(try_thunk, |x| pure::<TryThunkWithOkBrand<i32>, _>(x * 2));
assert_eq!(result.evaluate(), Err(20));

impl<A: Copy> Copy for TryThunkWithOkBrand<A>

impl<A: Eq> Eq for TryThunkWithOkBrand<A>

impl<A> StructuralPartialEq for TryThunkWithOkBrand<A>