Enum outcome::prelude::Concern

pub enum Concern<S, M> {
    Success(S),
    Mistake(M),
}

Concern is a type that can represent a Success, or Mistake.

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

See the module documentation for more usage details.

Variants

Success(S)

Contains the success value

Mistake(M)

Contains the mistake value

Implementations

impl<S, M> Concern<S, M>

pub fn as_ref(&self) -> Concern<&S, &M>

Converts from &Concern<S, M> to Concern<&S, &M>.

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

Examples

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

let x: Concern<u32, i32> = Concern::Mistake(47);
assert_eq!(x.as_ref(), Concern::Mistake(&47));

pub fn as_mut(&mut self) -> Concern<&mut S, &mut M>

Converts from &mut Concern<S, M> to Concern<&mut S, &mut F>

Examples

fn mutate(c: &mut Concern<u32, i32>) {
  match c.as_mut() {
    Concern::Success(s) => *s = 47,
    Concern::Mistake(m) => *m = 19,
  }
}

let mut x: Concern<u32, i32> = Concern::Success(42);
mutate(&mut x);
assert_eq!(x.unwrap(), 47);

let mut x: Concern<u32, i32> = Concern::Mistake(47);
mutate(&mut x);
assert_eq!(x.unwrap_mistake(), 19);

pub fn iter(&self) -> Iter<'_, S>

Returns an iterator over the possibly contained value.

The iterator yields one value if the outcome is Success, otherwise none.

Examples

Basic usage:

let x: Concern<u32, i32> = Concern::Success(42);
assert_eq!(x.iter().next(), Some(&42));

let x: Concern<u32, i32> = Concern::Mistake(47);
assert_eq!(x.iter().next(), None);

pub fn iter_mut(&mut self) -> IterMut<'_, S>

Returns a mutable iterator over the possibly contained value.

The iterator yields one value if the result is Success, otherwise none.

Examples

let mut x: Concern<i32, &str> = Concern::Success(7);
match x.iter_mut().next() {
  Some(v) => *v += 40,
  None => {}
}
assert_eq!(x, Concern::Success(47));

pub fn is_success(&self) -> bool

Returns true if the concern is a Success

Examples

Basic usage:

let x: Concern<u32, &str> = Concern::Success(42);
assert!(x.is_success());

let x: Concern<u32, &str> = Concern::Mistake("hello");
assert!(!x.is_success());

pub fn is_mistake(&self) -> bool

Returns true if the concern is a Mistake

Examples

let x: Concern<u32, &str> = Concern::Success(42);
assert!(!x.is_mistake());

let x: Concern<u32, &str> = Concern::Mistake("hello");
assert!(x.is_mistake());

pub fn success(self) -> Option<S>

Converts from Concern<S, M> to Option<S>

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

Examples

let x: Concern<u32, &str> = Concern::Success(42);
assert_eq!(x.success(), Some(42));

let x: Concern<u32, &str> = Concern::Mistake("hello");
assert_eq!(x.success(), None);

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

Converts from Concern<S, M> to Option<M>

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

Examples

let x: Concern<u32, &str> = Concern::Success(42);
assert_eq!(x.mistake(), None);

let x: Concern<u32, &str> = Concern::Mistake("hello");
assert_eq!(x.mistake(), Some("hello"));

pub fn map<T, C>(self, callable: C) -> Concern<T, M> where
    C: FnOnce(S) -> T, 

Maps a Concern<S, M> to Concern<T, F> by applying a function to a contained Success value, leaving any Mistake value untouched.

Examples

let x: Concern<u32, &str> = Concern::Success(42);
assert_eq!(x.map(|x| x + 1), Concern::Success(43));

let x: Concern<u32, &str> = Concern::Mistake("hello");
assert_eq!(x.map(|x| x + 1), Concern::Mistake("hello"));

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

Maps a Concern<S, M> to Concern<S, N> by applying a function to a contained Mistake value, leaving any Success value untouched.

Examples

let x: Concern<u32, i32> = Concern::Success(42);
assert_eq!(x.map_mistake(|x| x + 1), Concern::Success(42));

let x: Concern<u32, i32> = Concern::Mistake(46);
assert_eq!(x.map_mistake(|x| x + 1), Concern::Mistake(47));

impl<S, M: Debug> Concern<S, M>

pub fn unwrap(self) -> S

Returns the contained Success value, consuming the self value.

Panics

Panics if the value is a Mistake with a panic message provided by their value.

Examples

let x: Concern<u32, &str> = Concern::Success(42);
assert_eq!(x.unwrap(), 42);

let x: Concern<u32, &str> = Concern::Mistake("hello");
x.unwrap(); // panics with "hello"

impl<S: Debug, M> Concern<S, M>

pub fn unwrap_mistake(self) -> M

Returns the contained Mistake value, consuming the self value.

Panics

Panics if the value is a Success with a panic message provided by their value.

Examples

let x: Concern<u32, &str> = Concern::Mistake("hello");
assert_eq!(x.unwrap_mistake(), "hello");

let x: Concern<u32, &str> = Concern::Success(42);
x.unwrap_mistake(); // panics with "42"

impl<S: Deref, M> Concern<S, M>

pub fn as_deref(&self) -> Concern<&S::Target, &M>

Converts from Concern<S, M> (or &Concern<S, M>) to Concern<&<S as Deref>::Target, M>.

Coerces the Success variant of the original Concern via Deref and returns the new Concern.

Examples

let x: Concern<String, u32> = Concern::Success("hello".to_string());
let y: Concern<&str, &u32> = Concern::Success("hello");
assert_eq!(x.as_deref(), y);

impl<S: DerefMut, M> Concern<S, M>

pub fn as_deref_mut(&mut self) -> Concern<&mut S::Target, &mut M>

Converts from Concern<S, M> (or &mut Concern<S, M>) to Concern<&mut <S as DerefMut>::Target, &mut M>.

Coerces the Success variant of the original Concern via DerefMut and returns the new Concern

Examples

let mut s = "HELLO".to_string();
let mut x: Concern<String, u32> = Concern::Success("hello".to_string());
let y: Concern<&mut str, &mut u32> = Concern::Success(&mut s);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);

Trait Implementations

impl<S: Clone, M: Clone> Clone for Concern<S, M>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug, M: Debug> Debug for Concern<S, M>

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

Formats the value using the given formatter.

impl<S: Hash, M: Hash> Hash for Concern<S, M>

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<S: Ord, M: Ord> Ord for Concern<S, M>

fn cmp(&self, other: &Concern<S, M>) -> 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<S: PartialEq, M: PartialEq> PartialEq<Concern<S, M>> for Concern<S, M>

fn eq(&self, other: &Concern<S, M>) -> bool

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

fn ne(&self, other: &Concern<S, M>) -> bool

This method tests for !=.

impl<S: PartialOrd, M: PartialOrd> PartialOrd<Concern<S, M>> for Concern<S, M>

fn partial_cmp(&self, other: &Concern<S, M>) -> 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<S: Copy, M: Copy> Copy for Concern<S, M>

impl<S: Eq, M: Eq> Eq for Concern<S, M>

impl<S, M> StructuralEq for Concern<S, M>

impl<S, M> StructuralPartialEq for Concern<S, M>