Trait ResultOptionExt

pub trait ResultOptionExt<T, E> {
    // Required methods
    fn unwrap_or_err<E2>(self, err: E2) -> Result<T, E2>;
    fn unwrap_or_else_err<E2, F: FnOnce() -> E2>(self, f: F) -> Result<T, E2>;
    fn unwrap_or_map_err<E2, F: FnOnce(E) -> E2>(
        self,
        default: E2,
        f: F,
    ) -> Result<T, E2>;
    fn unwrap_or_else_map_err<E2, F: FnOnce(E) -> E2, F2: FnOnce() -> E2>(
        self,
        default: F2,
        f: F,
    ) -> Result<T, E2>;
}

Required Methods

fn unwrap_or_err<E2>(self, err: E2) -> Result<T, E2>

Maps either a Result<Option<T>, E> or Option<Result<T, E>> to a Result<T, E2> where E2 is the type of the provided err.

If it’s a Result:

• Ok(Some(t)) -> Ok(t)
• Ok(None) -> Err(err)
• Err(_) -> Err(err)

If it’s an Option:

• Some(t) -> Ok(t)
• None -> Err(err)

Example

use composable_utils::ResultOptionExt;

enum ErrorOne {
   One,
}

enum ErrorTwo {
   Two,
}

fn result_ok_none() -> Result<Option<&'static str>, ErrorOne> {
   Ok(None)
}

fn option_some_err() -> Option<Result<&'static str, ErrorOne>> {
   Some(Err(ErrorOne::One))
}

assert!(matches!(result_ok_none().unwrap_or_err(ErrorTwo::Two), Err(ErrorTwo::Two)));
assert!(matches!(option_some_err().unwrap_or_err(ErrorTwo::Two), Err(ErrorTwo::Two)));

fn unwrap_or_else_err<E2, F: FnOnce() -> E2>(self, f: F) -> Result<T, E2>

Maps either a Result<Option<T>, E> or Option<Result<T, E>> to a Result<T, E2> where E2 is the type of the result of the provided closure.

If it’s a Result:

• Ok(Some(t)) -> Ok(t)
• Ok(None) -> Err(f())
• Err(_) -> Err(f())

If it’s an Option:

• Some(t) -> Ok(t)
• None -> Err(f())

Example

use composable_utils::ResultOptionExt;

enum ErrorOne {
   One,
}

enum ErrorTwo {
   Two,
}

fn result_ok_none() -> Result<Option<&'static str>, ErrorOne> {
   Ok(None)
}

fn option_some_err() -> Option<Result<&'static str, ErrorOne>> {
   Some(Err(ErrorOne::One))
}

assert!(matches!(result_ok_none().unwrap_or_else_err(|| ErrorTwo::Two), Err(ErrorTwo::Two)));
assert!(matches!(option_some_err().unwrap_or_else_err(|| ErrorTwo::Two), Err(ErrorTwo::Two)));

fn unwrap_or_map_err<E2, F: FnOnce(E) -> E2>( self, default: E2, f: F, ) -> Result<T, E2>

Maps either a Result<Option<T>, E> or Option<Result<T, E>> to a Result<T, E2> by applying a function to a contained Err value, leaving an Ok value untouched. Defaults to Err(default) if None.

Example

use composable_utils::ResultOptionExt;

enum ErrorOne {
   One,
}

enum ErrorTwo {
   Two,
   Three,
}

fn result_ok_none() -> Result<Option<&'static str>, ErrorOne> {
   Ok(None)
}

fn option_some_err() -> Option<Result<&'static str, ErrorOne>> {
   Some(Err(ErrorOne::One))
}

assert!(matches!(result_ok_none().unwrap_or_map_err(ErrorTwo::Two, |err| ErrorTwo::Three), Err(ErrorTwo::Two)));
assert!(matches!(option_some_err().unwrap_or_map_err(ErrorTwo::Two, |err| ErrorTwo::Three), Err(ErrorTwo::Three)));

fn unwrap_or_else_map_err<E2, F: FnOnce(E) -> E2, F2: FnOnce() -> E2>( self, default: F2, f: F, ) -> Result<T, E2>

Maps either a Result<Option<T>, E> or Option<Result<T, E>> to a Result<T, E2> by applying a function to a contained Err value, leaving an Ok value untouched. Defaults to Err(default) if None.

Example

use composable_utils::ResultOptionExt;

enum ErrorOne {
   One,
}

enum ErrorTwo {
   Two,
   Three,
}

fn result_ok_none() -> Result<Option<&'static str>, ErrorOne> {
   Ok(None)
}

fn option_some_err() -> Option<Result<&'static str, ErrorOne>> {
   Some(Err(ErrorOne::One))
}

assert!(matches!(result_ok_none().unwrap_or_else_map_err(|| ErrorTwo::Two, |err| ErrorTwo::Three), Err(ErrorTwo::Two)));
assert!(matches!(option_some_err().unwrap_or_else_map_err(|| ErrorTwo::Two, |err| ErrorTwo::Three), Err(ErrorTwo::Three)));

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<T, E> ResultOptionExt<T, E> for Option<Result<T, E>>

fn unwrap_or_err<E2>(self, err: E2) -> Result<T, E2>

fn unwrap_or_else_err<E2, F: FnOnce() -> E2>(self, f: F) -> Result<T, E2>

fn unwrap_or_map_err<E2, F: FnOnce(E) -> E2>( self, default: E2, f: F, ) -> Result<T, E2>

fn unwrap_or_else_map_err<E2, F: FnOnce(E) -> E2, F2: FnOnce() -> E2>( self, default: F2, f: F, ) -> Result<T, E2>

impl<T, E> ResultOptionExt<T, E> for Result<Option<T>, E>

fn unwrap_or_err<E2>(self, err: E2) -> Result<T, E2>

fn unwrap_or_else_err<E2, F: FnOnce() -> E2>(self, f: F) -> Result<T, E2>

fn unwrap_or_map_err<E2, F: FnOnce(E) -> E2>( self, default: E2, f: F, ) -> Result<T, E2>

fn unwrap_or_else_map_err<E2, F: FnOnce(E) -> E2, F2: FnOnce() -> E2>( self, default: F2, f: F, ) -> Result<T, E2>

Implementors