Enum outcome::Outcome

pub enum Outcome {
    Success,
    Failure,
}

Variants

Success

Successful

Failure

Not successful

Methods

impl Outcome

fn is_success(&self) -> bool

Returns true if the outcome is a success

Examples

use outcome::*;
 
let result = Success;
 
assert!(result.is_success());

fn is_failure(&self) -> bool

Returns true if the outcome is a failure

Examples

use outcome::*;
 
let result = Failure;
 
assert!(result.is_failure());

fn or_none<T>(self, ok: T) -> Option<T>

Transforms the Outcome into an Option<T>, mapping Success to Some(good) and Failure to None

Examples

use outcome::*;
 
let result = Success;
 
assert_eq!(result.or_none(42), Some(42));

fn or_err<T, E>(self, good: T, err: E) -> Result<T, E>

Transforms the Outcome into a Result<T, E>, mapping Success to Ok(good) and Failure to Err(err)

Examples

use outcome::*;
 
let result = Success;
 
assert_eq!(result.or_err("good", "bad"), Ok("good"));

fn or_panic<T>(self, good: T) -> T

Returns good if the outcome is Success, otherwise panics

Examples

use outcome::*;
 
let result = Success;
 
assert_eq!(result.or_panic(42), 42);

fn and(self, outb: Outcome) -> Outcome

Returns Failure if the outcome is Failure, otherwise returns outb

Examples

use outcome::*;
 
let result = Success;
 
assert_eq!(result.and(Failure), Failure);

fn or(self, outb: Outcome) -> Outcome

Returns Success if the outcome is Success, otherwise returns outb

Examples

use outcome::*;
 
let result = Failure;
 
assert_eq!(result.or(Success), Success);

fn and_then<F: FnOnce() -> Outcome>(self, f: F) -> Outcome

Returns Failure if the outcome is Failure, otherwise calls f and returns result

Examples

use outcome::*;
 
let result = Success;
 
assert_eq!(result.and_then(|| Failure), Failure);

fn or_then<F: FnOnce() -> Outcome>(self, f: F) -> Outcome

Returns Success if the outcome is Success, otherwise calls f and returns result

Examples

use outcome::*;
 
let result = Failure;
 
assert_eq!(result.or_then(|| Success), Success);

Trait Implementations

impl Clone for Outcome

fn clone(&self) -> Outcome

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Outcome

impl PartialEq for Outcome

fn eq(&self, __arg_0: &Outcome) -> bool

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

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

This method tests for !=.

impl Eq for Outcome

impl Debug for Outcome

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Hash for Outcome

fn hash<__H: Hasher>(&self, __arg_0: &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 From<bool> for Outcome

fn from(good: bool) -> Self

Returns Success if good is true, otherwise return Failure

Examples

use outcome::*;
 
let result = Outcome::from(true);
 
assert_eq!(result, Success);