Struct TryLazy 

pub struct TryLazy<'a, A, E, Config: LazyConfig = RcLazyConfig>(/* private fields */)
where
    A: 'a,
    E: 'a;

A lazily-computed, memoized value that may fail.

The computation runs at most once. If it succeeds, the value is cached. If it fails, the error is cached. Subsequent accesses return the cached result.

Type Parameters

• A: The type of the computed value.
• E: The type of the error.
• Config: The memoization configuration.

Fields

• 0: The internal lazy cell.

Implementations

impl<'a, A, E, Config: LazyConfig> TryLazy<'a, A, E, Config>

where A: 'a, E: 'a,

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

Gets the memoized result, computing on first access.

Type Signature

Result A E

Returns

A result containing a reference to the value or error.

Examples

use fp_library::types::*;

let memo = TryLazy::<_, _, RcLazyConfig>::new(|| Ok::<i32, ()>(42));
assert_eq!(memo.evaluate(), Ok(&42));

impl<'a, A, E> TryLazy<'a, A, E, RcLazyConfig>

where A: 'a, E: 'a,

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

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

Creates a new TryLazy that will run f on first access.

Type Signature

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

Type Parameters

• F: The type of the initializer closure.

Parameters

• f: The closure that produces the result.

Returns

A new TryLazy instance.

Examples

use fp_library::types::*;

let memo = TryLazy::<_, _, RcLazyConfig>::new(|| Ok::<i32, ()>(42));
assert_eq!(memo.evaluate(), Ok(&42));

impl<'a, A> TryLazy<'a, A, String, RcLazyConfig>

where A: 'a,

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

where F: FnOnce() -> A + UnwindSafe + 'a,

Creates a TryLazy that catches unwinds (panics).

Type Signature

forall self. UnwindSafe () -> A => (() -> A) -> self

Type Parameters

• F: The type of the initializer closure.

Parameters

• f: The closure that might panic.

Returns

A new TryLazy instance where panics are converted to Err(String).

Examples

use fp_library::types::*;

let memo = TryLazy::<_, String, RcLazyConfig>::catch_unwind(|| {
    if true { panic!("oops") }
    42
});
assert_eq!(memo.evaluate(), Err(&"oops".to_string()));

impl<'a, A, E> TryLazy<'a, A, E, ArcLazyConfig>

where A: 'a, E: 'a,

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

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

Creates a new TryLazy that will run f on first access.

Type Signature

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

Type Parameters

• F: The type of the initializer closure.

Parameters

• f: The closure that produces the result.

Returns

A new TryLazy instance.

Examples

use fp_library::types::*;

let memo = TryLazy::<_, _, ArcLazyConfig>::new(|| Ok::<i32, ()>(42));
assert_eq!(memo.evaluate(), Ok(&42));

Trait Implementations

impl<'a, A, E, Config: LazyConfig> Clone for TryLazy<'a, A, E, Config>

where A: 'a, E: 'a,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, A, E> Deferrable<'a> for TryLazy<'a, A, E, RcLazyConfig>

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

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

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

Defers a computation that produces a TryLazy value.

This flattens the nested structure: instead of TryLazy<TryLazy<A, E>, E>, we get TryLazy<A, E>. The inner TryLazy is computed only when the outer TryLazy is evaluated.

Type Signature

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

Type Parameters

• F: The type of the thunk.

Parameters

• f: The thunk that produces the lazy value.

Returns

A new TryLazy value.

Examples

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

let lazy = TryLazy::<_, (), RcLazyConfig>::defer(|| RcTryLazy::new(|| Ok(42)));
assert_eq!(lazy.evaluate(), Ok(&42));

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

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

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

Converts to this type from the input type.

impl<'a, A, E> From<Lazy<'a, A, ArcLazyConfig>> for TryLazy<'a, A, E, ArcLazyConfig>

where A: Clone + Send + Sync + 'a, E: Send + Sync + 'a,

fn from(memo: Lazy<'a, A, ArcLazyConfig>) -> 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, E, Config> From<TryLazy<'static, A, E, Config>> for TryTrampoline<A, E>

where A: Clone + Send + 'static, E: Clone + Send + 'static, Config: LazyConfig,

fn from(memo: TryLazy<'static, 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, E> From<TryTrampoline<A, E>> for TryLazy<'a, A, E, RcLazyConfig>

where A: Send, E: Send,

fn from(task: TryTrampoline<A, E>) -> Self

Converts to this type from the input type.

impl<'a, A, E> SendDeferrable<'a> for TryLazy<'a, A, E, ArcLazyConfig>

where A: Clone + Send + Sync + 'a, E: Clone + Send + Sync + 'a,

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

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

Defers a computation that produces a thread-safe TryLazy value.

This flattens the nested structure: instead of ArcTryLazy<ArcTryLazy<A, E>, E>, we get ArcTryLazy<A, E>. The inner TryLazy is computed only when the outer TryLazy is evaluated.

Type Signature

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

Type Parameters

• F: The type of the thunk.

Parameters

• f: The thunk that produces the lazy value.

Returns

A new ArcTryLazy value.

Examples

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

let lazy: ArcTryLazy<i32, ()> = ArcTryLazy::send_defer(|| ArcTryLazy::new(|| Ok(42)));
assert_eq!(lazy.evaluate(), Ok(&42));