Enum Result

pub enum Result<T, RE, FE> {
    Ok(T),
    Recoverable(RE),
    Fatal(FE),
}

Variants

Ok(T)

Recoverable(RE)

Fatal(FE)

Implementations

impl<T, RE, FE> Result<T, RE, FE>

pub fn from_std(value: StdResult<StdResult<T, RE>, FE>) -> Self

pub fn from_split<E>( split: impl FnOnce(E) -> StdResult<RE, FE>, value: StdResult<T, E>, ) -> Self

pub fn ok_or_recoverable(value: StdResult<T, RE>) -> Self

pub fn ok_or_fatal(value: StdResult<T, FE>) -> Self

pub fn from_err(error: StdResult<RE, FE>) -> Self

pub fn to_std(self) -> StdResult<StdResult<T, RE>, FE>

pub fn to_std_flipped(self) -> StdResult<T, StdResult<RE, FE>>

pub const fn is_ok(&self) -> bool

pub fn is_ok_and(self, f: impl FnOnce(T) -> bool) -> bool

pub const fn is_any_err(&self) -> bool

pub const fn is_recoverable(&self) -> bool

pub fn is_recoverable_and(self, f: impl FnOnce(RE) -> bool) -> bool

pub const fn is_fatal(&self) -> bool

pub fn is_fatal_and(self, f: impl FnOnce(FE) -> bool) -> bool

pub fn ok(self) -> Option<T>

pub fn recoverable(self) -> Option<RE>

pub fn fatal(self) -> Option<FE>

pub fn non_fatal(self) -> Option<StdResult<T, RE>>

pub fn err(self) -> Option<StdResult<RE, FE>>

pub fn as_ref(&self) -> Result<&T, &RE, &FE>

pub fn as_mut(&mut self) -> Result<&mut T, &mut RE, &mut FE>

pub fn map<O>(self, f: impl FnOnce(T) -> O) -> Result<O, RE, FE>

pub fn map_or<O>(self, default: O, f: impl FnOnce(T) -> O) -> O

pub fn map_or_else<O>( self, default: impl FnOnce() -> O, f: impl FnOnce(T) -> O, ) -> O

pub fn map_recoverable<REO>( self, f: impl FnOnce(RE) -> REO, ) -> Result<T, REO, FE>

pub fn map_fatal<FEO>(self, f: impl FnOnce(FE) -> FEO) -> Result<T, RE, FEO>

pub fn inspect(self, f: impl FnOnce(&T)) -> Self

pub fn inspect_recoverable(self, f: impl FnOnce(&RE)) -> Self

pub fn inspect_fatal(self, f: impl FnOnce(&FE)) -> Self

pub fn as_deref(&self) -> Result<&T::Target, &RE, &FE>

where T: Deref,

pub fn as_deref_mut(&mut self) -> Result<&mut T::Target, &mut RE, &mut FE>

where T: DerefMut,

pub fn iter(&self) -> IntoIter<&T>

pub fn iter_mut(&mut self) -> IntoIter<&mut T>

pub fn expect_nonfatal(self, msg: &str) -> LocalResult<T, RE>

where FE: Debug,

pub fn expect_ok(self, msg: &str) -> T

where RE: Debug, FE: Debug,

pub fn unwrap_nonfatal(self) -> LocalResult<T, RE>

where FE: Debug,

pub fn unwrap_ok(self) -> T

where RE: Debug, FE: Debug,

pub fn unwrap_or_default(self) -> T

where T: Default,

pub fn unwrap_or(self, default: T) -> T

pub fn unwrap_or_else(self, default: impl FnOnce() -> T) -> T

pub fn and<O>(self, res: Result<O, RE, FE>) -> Result<O, RE, FE>

pub fn and_then<O>( self, f: impl FnOnce(T) -> Result<O, RE, FE>, ) -> Result<O, RE, FE>

pub fn flatten_err<E: From<RE> + From<FE>>(self) -> StdResult<T, E>

pub fn convert_err<REO: From<RE>, FEO: From<FE>>(self) -> Result<T, REO, FEO>

pub fn more_fatal<REO>( self, f: impl FnOnce(RE) -> StdResult<REO, FE>, ) -> Result<T, REO, FE>

pub fn less_fatal<FEO>( self, f: impl FnOnce(FE) -> StdResult<RE, FEO>, ) -> Result<T, RE, FEO>

pub fn collect_layered<U>( iter: impl IntoIterator<Item = Result<U, RE, FE>>, ) -> Self

where T: FromIterator<U>,

impl<'a, T, RE, FE> Result<&'a T, RE, FE>

pub fn map_deref(self) -> Result<&'a <T as Deref>::Target, RE, FE>

where T: Deref,

pub fn copied(self) -> Result<T, RE, FE>

where T: Copy,

pub fn cloned(self) -> Result<T, RE, FE>

where T: Clone,

impl<'a, T, RE, FE> Result<&'a mut T, RE, FE>

pub fn map_deref(self) -> Result<&'a T::Target, RE, FE>

where T: DerefMut,

pub fn map_deref_mut(self) -> Result<&'a mut T::Target, RE, FE>

where T: DerefMut,

pub fn copied(self) -> Result<T, RE, FE>

where T: Copy,

pub fn cloned(self) -> Result<T, RE, FE>

where T: Clone,

impl<T, RE, FE> Result<Result<T, RE, FE>, RE, FE>

pub fn flatten(self) -> Result<T, RE, FE>

Trait Implementations

impl<T: Clone, RE: Clone, FE: Clone> Clone for Result<T, RE, FE>

fn clone(&self) -> Result<T, RE, FE>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, RE: Debug, FE: Debug> Debug for Result<T, RE, FE>

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

Formats the value using the given formatter.

impl<T, RE, FE> From<LocalResult<T, RE>> for Result<T, RE, FE>

fn from(value: LocalResult<T, RE>) -> Self

Converts to this type from the input type.

impl<T, RE, FE> From<Result<Result<T, RE>, FE>> for Result<T, RE, FE>

fn from(value: StdResult<StdResult<T, RE>, FE>) -> Self

Converts to this type from the input type.

impl<T, RE, FE> From<Result<T, RE, FE>> for StdResult<StdResult<T, RE>, FE>

fn from(value: Result<T, RE, FE>) -> Self

Converts to this type from the input type.

impl<T, RE, FE, C, EC> FromIterator<Result<T, RE, FE>> for CollectedErrs<StdResult<C, EC>>

where C: FromIterator<T>, EC: FromIterator<StdResult<RE, FE>>,

fn from_iter<I: IntoIterator<Item = Result<T, RE, FE>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T, RE, FE, C, REC, FEC> FromIterator<Result<T, RE, FE>> for CollectedErrs<Result<C, REC, FEC>>

where C: FromIterator<T>, REC: FromIterator<RE>, FEC: FromIterator<FE>,

fn from_iter<I: IntoIterator<Item = Result<T, RE, FE>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T, RE, FE, C, REC> FromIterator<Result<T, RE, FE>> for CollectedRecoverables<Result<C, REC, FE>>

where C: FromIterator<T>, REC: FromIterator<RE>,

fn from_iter<I: IntoIterator<Item = Result<T, RE, FE>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T, RE, FE, C> FromIterator<Result<T, RE, FE>> for Result<C, RE, FE>

where C: FromIterator<T>,

fn from_iter<I: IntoIterator<Item = Result<T, RE, FE>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T, RE, FE, REO: From<RE>> FromResidual<LocalResult<Infallible, RE>> for Result<T, REO, FE>

fn from_residual(residual: LocalResult<Infallible, RE>) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2)

Constructs the type from a compatible Residual type.

impl<T, FE, REO, FEO: From<FE>> FromResidual<Result<Infallible, FE>> for Result<T, REO, FEO>

fn from_residual(residual: StdResult<Infallible, FE>) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2)

Constructs the type from a compatible Residual type.

impl<T, FE, FEO: From<FE>> FromResidual<Result<Infallible, Infallible, FE>> for StdResult<T, FEO>

fn from_residual(residual: Result<Infallible, Infallible, FE>) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2)

Constructs the type from a compatible Residual type.

impl<T, RE, FE, FEO: From<FE>> FromResidual<Result<Infallible, Infallible, FE>> for Result<T, RE, FEO>

fn from_residual(residual: Result<Infallible, Infallible, FE>) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2)

Constructs the type from a compatible Residual type.

impl<T: Hash, RE: Hash, FE: Hash> Hash for Result<T, RE, FE>

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, T, RE, FE> IntoIterator for &'a Result<T, RE, FE>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = IntoIter<&'a T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, RE, FE> IntoIterator for &'a mut Result<T, RE, FE>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IntoIter<&'a mut T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, RE, FE> IntoIterator for Result<T, RE, FE>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Ord, RE: Ord, FE: Ord> Ord for Result<T, RE, FE>

fn cmp(&self, other: &Result<T, RE, FE>) -> 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<T: PartialEq, RE: PartialEq, FE: PartialEq> PartialEq for Result<T, RE, FE>

fn eq(&self, other: &Result<T, RE, FE>) -> 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<T: PartialOrd, RE: PartialOrd, FE: PartialOrd> PartialOrd for Result<T, RE, FE>

fn partial_cmp(&self, other: &Result<T, RE, FE>) -> 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<T, RE, FE> Try for Result<T, RE, FE>

type Output = LocalResult<T, RE>

🔬This is a nightly-only experimental API. (try_trait_v2)

The type of the value produced by ? when not short-circuiting.

type Residual = Result<Infallible, Infallible, FE>

🔬This is a nightly-only experimental API. (try_trait_v2)

The type of the value passed to FromResidual::from_residual as part of ? when short-circuiting.

fn from_output(output: Self::Output) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2)

Constructs the type from its Output type.

fn branch(self) -> ControlFlow<Self::Residual, Self::Output>

🔬This is a nightly-only experimental API. (try_trait_v2)

Used in ? to decide whether the operator should produce a value (because this returned ControlFlow::Continue) or propagate a value back to the caller (because this returned ControlFlow::Break).

impl<T: Copy, RE: Copy, FE: Copy> Copy for Result<T, RE, FE>

impl<T: Eq, RE: Eq, FE: Eq> Eq for Result<T, RE, FE>

impl<T, RE, FE> StructuralPartialEq for Result<T, RE, FE>