Type Definition this_is_fine::Fine

pub type Fine<T, E> = (T, Result<(), E>);

Broadly speaking, this is the result of an operation that sort of can’t fail.

Added Methods

• .fine() -> T
• .not_fine() -> Result<T, E>

Trait Implementations

impl<T, E> FineExt<T, E> for Fine<T, E>

fn is_ok(&self) -> bool

Returns true iff the Result is Ok(()).

fn is_err(&self) -> bool

Returns true iff the Result is Err.

fn ok(self) -> Option<T>

Converts from Fine<T, E> to Option<T>.

fn fine(self) -> T

Unwraps the T, ignoring any Err.

fn err(self) -> Option<E>

Converts from Fine<T, E> to Option<E>.

fn not_fine(self) -> Result<T, E>

Converts from Fine<T, E> to Result<T, E>.

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

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

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

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

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

Maps a Fine<T, E> to Fine<U, E>, by unconditionally applying a function to the contained T, leaving the Result untouched.

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

Maps a Fine<T, E> to Fine<T, F>, by applying a function to a contained Err’s E, leaving the T untouched.

impl<T, E> FineExtWhereEDebug<T, E> for Fine<T, E> where
    E: Debug, 

fn expect(self, msg: &str) -> T

Unwraps the T.

fn unwrap(self) -> T

Unwraps the T.

impl<T, E> FineExtWhereTDebug<T, E> for Fine<T, E> where
    T: Debug, 

fn expect_err(self, msg: &str) -> E

Unwraps the E.

fn unwrap_err(self) -> E

Unwraps the E.

impl<T, E> FineExtWhereTDeref<T, E> for Fine<T, E> where
    T: Deref, 

fn as_deref(&self) -> Fine<&<T as Deref>::Target, &E>

Coerces the T via Deref and returns a new Fine referencing the original.

impl<T, E> FineExtWhereTDerefMut<T, E> for Fine<T, E> where
    T: DerefMut, 

fn as_deref_mut(&mut self) -> Fine<&mut <T as Deref>::Target, &mut E>

Coerces the T via DerefMut and returns a new Fine referencing the original.

impl<T, E0, E1> FineTransposeExt<T, E0, E1> for Fine<Fine<T, E0>, E1>

fn transpose(self) -> Fine<Fine<T, E1>, E0>

Exchanges the Results of nested Fines.