Enum Resultish

Source

pub enum Resultish<T, E> {
    Ok(T),
    Err(E),
    Both(T, E),
}

Expand description

Resultish represents success (Ok), error (Err), or Both.

Variants§

§

Ok(T)

Contains only a success value

§

Err(E)

Contains only an error value

§

Both(T, E)

Contains a success and error value

Implementations§

Source §

impl<T, E> Resultish<T, E>

Source

pub fn as_mut(&mut self) -> Resultish<&mut T, &mut E>

Converts from &mut Resultish<T, E> to Resultish<&mut T, &mut E>.

Source

pub fn as_ref(&self) -> Resultish<&T, &E>

Converts from &Resultish<T, E> to Resultish<&T, &E>.

Source

pub fn has_ok(&self) -> bool

Returns true if the result contains a success value.

§Examples

use resultish::Resultish::{self, Both, Err, Ok};

let x: Resultish<i32, &str> = Ok(3);
assert_eq!(x.has_ok(), true);

let x: Resultish<i32, &str> = Err("Some error message");
assert_eq!(x.has_ok(), false);

let x: Resultish<i32, &str> = Both(3, "Some error message");
assert_eq!(x.has_ok(), true);

Source

pub fn has_err(&self) -> bool

Returns true if the result contains an error value.

§Examples

use resultish::Resultish::{self, Both, Err, Ok};

let x: Resultish<i32, &str> = Ok(3);
assert_eq!(x.has_err(), false);

let x: Resultish<i32, &str> = Err("Some error message");
assert_eq!(x.has_err(), true);

let x: Resultish<i32, &str> = Both(3, "Some error message");
assert_eq!(x.has_err(), true);

Source

pub fn lenient(self) -> Result<T, E>

Convert to Result leniently: Both is mapped to Result::Ok, and the error value is discarded.

§Examples

use resultish::Resultish::{self, Both, Err, Ok};

let x: Resultish<i32, &str> = Ok(3);
assert_eq!(x.lenient(), Result::Ok(3));

let x: Resultish<i32, &str> = Err("Some error message");
assert_eq!(x.lenient(), Result::Err("Some error message"));

let x: Resultish<i32, &str> = Both(3, "Some error message");
assert_eq!(x.lenient(), Result::Ok(3));

Source

pub fn lenient_err(self) -> Option<E>

Equivalent to lenient().err().

Source

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

Equivalent to lenient().ok().

Source

pub fn map<U, F>(self, op: F) -> Resultish<U, E>
where F: FnOnce(T) -> U,

Maps a Resultish<T, E> to Resultish<U, E> by applying a function to the success value, and leaving the error value untouched.

Source

pub fn map_err<F, O>(self, op: O) -> Resultish<T, F>
where O: FnOnce(E) -> F,

Maps a Resultish<T, E> to Resultish<T, F> by applying a function to the error value, and leaving the success value untouched.

Source

pub fn strict(self) -> Result<T, E>

Convert to Result strictly: Both is mapped to Result::Err, and the success value is discarded.

§Examples

use resultish::Resultish::{self, Both, Err, Ok};

let x: Resultish<i32, &str> = Ok(3);
assert_eq!(x.strict(), Result::Ok(3));

let x: Resultish<i32, &str> = Err("Some error message");
assert_eq!(x.strict(), Result::Err("Some error message"));

let x: Resultish<i32, &str> = Both(3, "Some error message");
assert_eq!(x.strict(), Result::Err("Some error message"));

Source

pub fn strict_err(self) -> Option<E>

Equivalent to strict().err().

Source

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

Equivalent to strict().ok().

Source

pub fn tuple(self) -> (Option<T>, Option<E>)

Convert to tuple of the success and error values.

§Examples

use resultish::Resultish::{self, Both, Err, Ok};

let x: Resultish<i32, &str> = Ok(3);
assert_eq!(x.tuple(), (Some(3), None));

let x: Resultish<i32, &str> = Err("Some error message");
assert_eq!(x.tuple(), (None, Some("Some error message")));

let x: Resultish<i32, &str> = Both(3, "Some error message");
assert_eq!(x.tuple(), (Some(3), Some("Some error message")));