Enum erg_common::triple::Triple

pub enum Triple<T, E> {
    Ok(T),
    Err(E),
    None,
}

Variants

Ok(T)

Err(E)

None

Implementations

impl<T, E> Triple<T, E>

pub fn none_then(self, err: E) -> Result<T, E>

pub fn none_or_result(self, f: impl FnOnce() -> E) -> Result<T, E>

pub fn none_or_else(self, f: impl FnOnce() -> Triple<T, E>) -> Triple<T, E>

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

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

pub fn or_else(self, f: impl FnOnce() -> Result<T, E>) -> Result<T, E>

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

pub fn unwrap_err(self) -> E

pub fn map_ok<T2>(self, f: impl FnOnce(T) -> T2) -> Triple<T2, E>

pub fn map_ok_or<T2>(self, default: T2, f: impl FnOnce(T) -> T2) -> T2

pub fn map_err<E2>(self, f: impl FnOnce(E) -> E2) -> Triple<T, E2>

impl<T> Triple<T, T>

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

impl<T, E: Error> Triple<T, E>

pub fn unwrap(self) -> T

Trait Implementations

impl<T: Clone, E: Clone> Clone for Triple<T, E>

fn clone(&self) -> Triple<T, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, E: Debug> Debug for Triple<T, E>

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

Formats the value using the given formatter.

impl<T: Hash, E: Hash> Hash for Triple<T, E>

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<T: PartialEq, E: PartialEq> PartialEq<Triple<T, E>> for Triple<T, E>

fn eq(&self, other: &Triple<T, E>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Copy, E: Copy> Copy for Triple<T, E>

impl<T: Eq, E: Eq> Eq for Triple<T, E>

impl<T, E> StructuralEq for Triple<T, E>

impl<T, E> StructuralPartialEq for Triple<T, E>