Struct TryThunk 

pub struct TryThunk<'a, A, E>(/* private fields */);

A deferred computation that may fail with error type E.

Like Thunk, this is NOT memoized. Each TryThunk::evaluate re-executes. Unlike Thunk, the result is Result<A, E>.

Type Parameters

• A: The type of the value produced by the computation on success.
• E: The type of the error produced by the computation on failure.

Fields

• 0: The closure that performs the computation.

Examples

use fp_library::types::*;

let computation: TryThunk<i32, &str> = TryThunk::new(|| {
    Ok(42)
});

match computation.evaluate() {
    Ok(val) => assert_eq!(val, 42),
    Err(_) => panic!("Should not fail"),
}

Implementations

impl<'a, A: 'a, E: 'a> TryThunk<'a, A, E>

pub fn new<F>(f: F) -> Self

where F: FnOnce() -> Result<A, E> + 'a,

Creates a new TryThunk from a thunk.

Type Signature

forall self. (() -> Result A E) -> self

Type Parameters

• F: The type of the thunk.

Parameters

• f: The thunk to wrap.

Returns

A new TryThunk instance.

Examples

use fp_library::types::*;

let try_thunk: TryThunk<i32, ()> = TryThunk::new(|| Ok(42));
assert_eq!(try_thunk.evaluate(), Ok(42));

pub fn pure(a: A) -> Self

where A: 'a,

Returns a pure value (already computed).

Type Signature

forall self. A -> self

Parameters

• a: The value to wrap.

Returns

A new TryThunk instance containing the value.

Examples

use fp_library::types::*;

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

pub fn defer<F>(f: F) -> Self

where F: FnOnce() -> TryThunk<'a, A, E> + 'a,

Defers a computation that returns a TryThunk.

Type Signature

forall self. (() -> TryThunk A E) -> self

Type Parameters

• F: The type of the thunk.

Parameters

• f: The thunk that returns a TryThunk.

Returns

A new TryThunk instance.

Examples

use fp_library::types::*;

let try_thunk: TryThunk<i32, ()> = TryThunk::defer(|| TryThunk::pure(42));
assert_eq!(try_thunk.evaluate(), Ok(42));

pub fn ok(a: A) -> Self

where A: 'a,

Alias for pure.

Creates a successful computation.

Type Signature

forall self. A -> self

Parameters

• a: The value to wrap.

Returns

A new TryThunk instance containing the value.

Examples

use fp_library::types::*;

let try_thunk: TryThunk<i32, ()> = TryThunk::ok(42);
assert_eq!(try_thunk.evaluate(), Ok(42));

pub fn err(e: E) -> Self

where E: 'a,

Returns a pure error.

Type Signature

forall self. E -> self

Parameters

• e: The error to wrap.

Returns

A new TryThunk instance containing the error.

Examples

use fp_library::types::*;

let try_thunk: TryThunk<i32, &str> = TryThunk::err("error");
assert_eq!(try_thunk.evaluate(), Err("error"));

pub fn bind<B: 'a, F>(self, f: F) -> TryThunk<'a, B, E>

where F: FnOnce(A) -> TryThunk<'a, B, E> + 'a,

Monadic bind: chains computations.

Type Signature

forall b. (A -> TryThunk b E) -> TryThunk b E

Type Parameters

• B: The type of the result of the new computation.
• F: The type of the function to apply.

Parameters

• f: The function to apply to the result of the computation.

Returns

A new TryThunk instance representing the chained computation.

Examples

use fp_library::types::*;

let try_thunk: TryThunk<i32, ()> = TryThunk::pure(21).bind(|x| TryThunk::pure(x * 2));
assert_eq!(try_thunk.evaluate(), Ok(42));

pub fn map<B: 'a, Func>(self, func: Func) -> TryThunk<'a, B, E>

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

Functor map: transforms the result.

Type Signature

forall b. (A -> b) -> TryThunk b E

Type Parameters

• B: The type of the result of the transformation.
• F: The type of the transformation function.

Parameters

• func: The function to apply to the result of the computation.

Returns

A new TryThunk instance with the transformed result.

Examples

use fp_library::types::*;

let try_thunk: TryThunk<i32, ()> = TryThunk::pure(21).map(|x| x * 2);
assert_eq!(try_thunk.evaluate(), Ok(42));

pub fn map_err<E2: 'a, F>(self, f: F) -> TryThunk<'a, A, E2>

where F: FnOnce(E) -> E2 + 'a,

Map error: transforms the error.

Type Signature

forall e2. (E -> e2) -> TryThunk A e2

Type Parameters

• E2: The type of the new error.
• F: The type of the transformation function.

Parameters

• f: The function to apply to the error.

Returns

A new TryThunk instance with the transformed error.

Examples

use fp_library::types::*;

let try_thunk: TryThunk<i32, i32> = TryThunk::err(21).map_err(|x| x * 2);
assert_eq!(try_thunk.evaluate(), Err(42));

pub fn catch<F>(self, f: F) -> Self

where F: FnOnce(E) -> TryThunk<'a, A, E> + 'a,

Recovers from an error.

Type Signature

forall self. (E -> TryThunk A E) -> self

Type Parameters

• F: The type of the recovery function.

Parameters

• f: The function to apply to the error value.

Returns

A new TryThunk that attempts to recover from failure.

Examples

use fp_library::types::*;

let try_thunk: TryThunk<i32, &str> = TryThunk::err("error")
    .catch(|_| TryThunk::pure(42));
assert_eq!(try_thunk.evaluate(), Ok(42));

pub fn evaluate(self) -> Result<A, E>

Forces evaluation and returns the result.

Type Signature

Result A E

Returns

The result of the computation.

Examples

use fp_library::types::*;

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

Trait Implementations

impl<'a, A, E> Deferrable<'a> for TryThunk<'a, A, E>

where A: 'a, E: 'a,

fn defer<F>(f: F) -> Self

where F: FnOnce() -> Self + 'a, Self: Sized,

Creates a TryThunk from a computation that produces it.

Type Signature

forall self. Deferrable self => (() -> self) -> self

Type Parameters

• F: The type of the thunk.

Parameters

• f: A thunk that produces the try thunk.

Returns

The deferred try thunk.

Examples

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

let task: TryThunk<i32, ()> = Deferrable::defer(|| TryThunk::pure(42));
assert_eq!(task.evaluate(), Ok(42));

impl<'a, A, E, Config> From<Lazy<'a, A, Config>> for TryThunk<'a, A, E>

where A: Clone + 'a, E: 'a, Config: LazyConfig,

fn from(memo: Lazy<'a, A, Config>) -> Self

Converts to this type from the input type.

impl<'a, A: 'a, E: 'a> From<Thunk<'a, A>> for TryThunk<'a, A, E>

fn from(eval: Thunk<'a, A>) -> Self

Converts to this type from the input type.

impl<'a, A, E, Config> From<TryLazy<'a, A, E, Config>> for TryThunk<'a, A, E>

where A: Clone + 'a, E: Clone + 'a, Config: LazyConfig,

fn from(memo: TryLazy<'a, A, E, Config>) -> Self

Converts to this type from the input type.

impl<'a, A, E> From<TryThunk<'a, A, E>> for TryLazy<'a, A, E, RcLazyConfig>

fn from(eval: TryThunk<'a, A, E>) -> Self

Converts to this type from the input type.

impl<'a, A: Monoid + 'a, E: 'a> Monoid for TryThunk<'a, A, E>

fn empty() -> Self

Returns the identity TryThunk.

Type Signature

forall self. Monoid self => self

Returns

A TryThunk producing the identity value of A.

Examples

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

let t: TryThunk<String, ()> = TryThunk::empty();
assert_eq!(t.evaluate(), Ok("".to_string()));

impl<'a, A: Semigroup + 'a, E: 'a> Semigroup for TryThunk<'a, A, E>

fn append(a: Self, b: Self) -> Self

Combines two TryThunks by combining their results.

Type Signature

forall self. Semigroup self => (self, self) -> self

Parameters

• a: The first TryThunk.
• b: The second TryThunk.

Returns

A new TryThunk containing the combined result.

Examples

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

let t1: TryThunk<String, ()> = pure::<TryThunkWithErrBrand<()>, _>("Hello".to_string());
let t2: TryThunk<String, ()> = pure::<TryThunkWithErrBrand<()>, _>(" World".to_string());
let t3 = append::<_>(t1, t2);
assert_eq!(t3.evaluate(), Ok("Hello World".to_string()));