Enum outcome::prelude::Aberration

pub enum Aberration<M, F> {
    Mistake(M),
    Failure(F),
}

Aberration is a type that can represent a Mistake, or Failure.

NOTE: This type will become a alias once ! is stabilized.

See the module documentation for details.

Variants

Mistake(M)

Contains the mistake value. Analogous to Outcome::Mistake

Failure(F)

Contains the failure value. Analogous to Outcome::Failure

Implementations

impl<M, F> Aberration<M, F>

pub fn as_ref(&self) -> Aberration<&M, &F>

Converts from &Aberration<M, F> to Aberration<&M, &F>.

Produces a new Aberration, containing a reference into the original, leaving it in place.

Examples

let x: Aberration<u32, &str> = Aberration::Mistake(42);
assert_eq!(x.as_ref(), Aberration::Mistake(&42));

let x: Aberration<&str, u32> = Aberration::Failure(47);
assert_eq!(x.as_ref(), Aberration::Failure(&47));

pub fn as_mut(&mut self) -> Aberration<&mut M, &mut F>

Converts from &mut Aberration<M, F> to Aberration<&mut M, &mut F>

Examples

fn mutate(x: &mut Aberration<u32, i32>) {
  match x.as_mut() {
    Aberration::Mistake(m) => *m = 42,
    Aberration::Failure(f) => *f = 47,
  }
}

let mut x: Aberration<u32, i32> = Aberration::Mistake(1);
mutate(&mut x);
assert_eq!(x.unwrap_mistake(), 42);

let mut x: Aberration<u32, i32> = Aberration::Failure(1);
mutate(&mut x);
assert_eq!(x.unwrap_failure(), 47);

pub fn is_mistake(&self) -> bool

Returns true if the aberration is a Mistake

Examples

Basic usage:

let x: Aberration<u32, i32> = Aberration::Mistake(42);
assert!(x.is_mistake());

let x: Aberration<u32, i32> = Aberration::Failure(47);
assert!(!x.is_mistake());

pub fn is_failure(&self) -> bool

Returns true if the aberration is a Failure

Examples

Basic usage:

let x: Aberration<u32, i32> = Aberration::Failure(1);
assert!(x.is_failure());

let x: Aberration<u32, i32> = Aberration::Mistake(1);
assert!(!x.is_failure());

pub fn mistake(self) -> Option<M>

Converts from Aberration<M, F> to Option<M>

Converts self into an Option<M>, consuming self, and discarding the failure value if any.

Examples

let x: Aberration<u32, i32> = Aberration::Failure(42);
assert_eq!(x.mistake(), None);

let x: Aberration<u32, i32> = Aberration::Mistake(42);
assert_eq!(x.mistake(), Some(42));

pub fn failure(self) -> Option<F>

Converts from Aberration<M, F> to Option<F>

Converts self into an Option<F>, consuming self, and discarding the mistake value if any.

Examples

let x: Aberration<u32, i32> = Aberration::Failure(42);
assert_eq!(x.failure(), Some(42));

let x: Aberration<u32, i32> = Aberration::Mistake(42);
assert_eq!(x.failure(), None);

pub fn map_mistake<N, C>(self, callable: C) -> Aberration<N, F> where
    C: FnOnce(M) -> N, 

Maps an Aberration<M, F> to Aberration<N, F> by applying a function to a contained Mistake value, leaving any Failure value untouched.

pub fn map_failure<G, C>(self, callable: C) -> Aberration<M, G> where
    C: FnOnce(F) -> G, 

Maps an Aberration<M, F> to Aberration<M, G> by applying a function to a contained Failure value, leaving any Mistake value untouched.

impl<M, F: Debug> Aberration<M, F>

pub fn unwrap_mistake(self) -> M

Returns the contained Mistake value, consuming the self value.

Panics

Panics if the value is a Failure, with a custom panic message provided by the failure.

Examples

let x: Aberration<&str, i32> = Aberration::Failure(47);
x.unwrap_mistake(); // panics with '47'

let x: Aberration<&str, i32> = Aberration::Mistake("try again!");
assert_eq!(x.unwrap_mistake(), "try again!");

impl<M: Debug, F> Aberration<M, F>

pub fn unwrap_failure(self) -> F

Returns the contained Failure value, consuming the self value.

Panics

Panics if the value is a Mistake, with a custom panic message provided by the mistake.

Examples

let x: Aberration<i32, &str> = Aberration::Mistake(47);
x.unwrap_failure(); // panics with '47'

let x: Aberration<i32, &str> = Aberration::Failure("error!");
assert_eq!(x.unwrap_failure(), "error!");

Trait Implementations

impl<M: Clone, F: Clone> Clone for Aberration<M, F>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: Debug, F: Debug> Debug for Aberration<M, F>

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

Formats the value using the given formatter.

impl<S, M, F, N: From<M>, G: From<F>> FromResidual<Aberration<M, F>> for Outcome<S, N, G>

Available on crate feature nightly only.

fn from_residual(residual: Aberration<M, F>) -> Self

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

Constructs the type from a compatible Residual type.

impl<M, E, F: From<E>> FromResidual<Result<Infallible, E>> for Aberration<M, F>

Available on crate feature nightly only.

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

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

Constructs the type from a compatible Residual type.

impl<M: Hash, F: Hash> Hash for Aberration<M, F>

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, 

Feeds a slice of this type into the given Hasher.

impl<M: Ord, F: Ord> Ord for Aberration<M, F>

fn cmp(&self, other: &Aberration<M, F>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<M: PartialEq, F: PartialEq> PartialEq<Aberration<M, F>> for Aberration<M, F>

fn eq(&self, other: &Aberration<M, F>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Aberration<M, F>) -> bool

This method tests for !=.

impl<M: PartialOrd, F: PartialOrd> PartialOrd<Aberration<M, F>> for Aberration<M, F>

fn partial_cmp(&self, other: &Aberration<M, F>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<M: Debug, F: Debug> Termination for Aberration<M, F>

fn report(self) -> ExitCode

Is called to get the representation of the value as status code. This status code is returned to the operating system.

impl<M, F> Try for Aberration<M, F>

Available on crate feature nightly only.

type Output = M

🔬 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, F>

🔬 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<M, E> WrapFailure for Aberration<M, E> where
    E: Error + Send + Sync + 'static, 

Available on crate feature report only.

type Return = Aberration<M, Report>

The expected return type for an impl.

fn wrap_failure_with<D, F>(self, message: F) -> Self::Return where
    D: Display + Send + Sync + 'static,
    F: FnOnce() -> D, 

Wrap the failure value with a new adhoc error that is evaluated lazily only once an error does occur.

fn wrap_failure<D>(self, message: D) -> Self::Return where
    D: Display + Send + Sync + 'static, 

Wrap the failure value with a new adhoc error.

fn with_context<D, F>(self, message: F) -> Self::Return where
    D: Display + Send + Sync + 'static,
    F: FnOnce() -> D, 

Compatibility re-export of wrap_failure_with for interop with anyhow and eyre.

fn context<D>(self, message: D) -> Self::Return where
    D: Display + Send + Sync + 'static, 

Compatibility re-export of wrap_failure for interop with anyhow and eyre.

impl<M, E> WrapFailure for Aberration<M, E> where
    E: Diagnostic + Send + Sync + 'static, 

Available on crate feature diagnostic only.

type Return = Aberration<M, Report>

The expected return type for an impl.

fn wrap_failure_with<D, F>(self, message: F) -> Self::Return where
    D: Display + Send + Sync + 'static,
    F: FnOnce() -> D, 

Wrap the failure value with a new adhoc error that is evaluated lazily only once an error does occur.

fn wrap_failure<D>(self, message: D) -> Self::Return where
    D: Display + Send + Sync + 'static, 

Wrap the failure value with a new adhoc error.

fn with_context<D, F>(self, message: F) -> Self::Return where
    D: Display + Send + Sync + 'static,
    F: FnOnce() -> D, 

Compatibility re-export of wrap_failure_with for interop with anyhow and eyre.

fn context<D>(self, message: D) -> Self::Return where
    D: Display + Send + Sync + 'static, 

Compatibility re-export of wrap_failure for interop with anyhow and eyre.

impl<M: Copy, F: Copy> Copy for Aberration<M, F>

impl<M: Eq, F: Eq> Eq for Aberration<M, F>

impl<M, F> StructuralEq for Aberration<M, F>

impl<M, F> StructuralPartialEq for Aberration<M, F>