Trait ResultExt

pub trait ResultExt: ResultLike {
    // Provided methods
    fn err_as_deref(&self) -> Result<&Self::T, &<Self::E as Deref>::Target>
       where Self::E: Deref { ... }
    fn err_as_deref_mut(
        &mut self,
    ) -> Result<&mut Self::T, &mut <Self::E as Deref>::Target>
       where Self::E: DerefMut { ... }
    fn copied_err<'a>(self) -> Result<Self::T, <Self::E as ThisRef<'a>>::Out>
       where Self::E: ThisRef<'a>,
             <Self::E as ThisRef<'a>>::Out: Copy { ... }
    fn cloned_err<'a>(self) -> Result<Self::T, <Self::E as ThisRef<'a>>::Out>
       where Self::E: ThisRef<'a>,
             <Self::E as ThisRef<'a>>::Out: Clone { ... }
    fn iter_err(&self) -> IntoIter<&Self::E> { ... }
    fn iter_err_mut(&mut self) -> IntoIter<&mut Self::E> { ... }
    fn into_iter_err(self) -> IntoIter<Self::E> { ... }
    fn map_err_or<E, F>(self, default: E, f: F) -> E
       where F: FnOnce(Self::E) -> E { ... }
    fn map_err_or_else<E, D, F>(self, default: D, f: F) -> E
       where F: FnOnce(Self::E) -> E,
             D: FnOnce(Self::T) -> E { ... }
    fn transpose_err<E>(self) -> Option<Result<Self::T, E>>
       where Self: ResultLike<E = Option<E>> { ... }
    fn err_into<E>(self) -> Result<Self::T, E>
       where Self::E: Into<E> { ... }
}

Result extension methods for Err

Provided Methods

fn err_as_deref(&self) -> Result<&Self::T, &<Self::E as Deref>::Target>

where Self::E: Deref,

Like Result::as_deref, but on Err

Examples

let x: Result<(), String> = Err("foo".to_owned());
let y: Result<&(), &str> = x.err_as_deref();

fn err_as_deref_mut( &mut self, ) -> Result<&mut Self::T, &mut <Self::E as Deref>::Target>

where Self::E: DerefMut,

Like Result::as_deref_mut, but on Err

Examples

let mut x: Result<(), String> = Err("foo".to_owned());
let y: Result<&mut (), &mut str> = x.err_as_deref_mut();

fn copied_err<'a>(self) -> Result<Self::T, <Self::E as ThisRef<'a>>::Out>

where Self::E: ThisRef<'a>, <Self::E as ThisRef<'a>>::Out: Copy,

Like Result::copied, but on Err

Examples

let x: Result<(), &i32> = Err(&2);
let _: Result<(), i32> = x.copied_err();

fn cloned_err<'a>(self) -> Result<Self::T, <Self::E as ThisRef<'a>>::Out>

where Self::E: ThisRef<'a>, <Self::E as ThisRef<'a>>::Out: Clone,

Like Result::cloned, but on Err

Examples

let msg = "foo".to_owned();
let x: Result<(), &String> = Err(&msg);
let _: Result<(), String> = x.cloned_err();

fn iter_err(&self) -> IntoIter<&Self::E>

Like Result::iter, but on Err

Examples

let ok: Result<i32, i32> = Ok(1);
let err: Result<i32, i32> = Err(1);

assert_eq!(ok.iter_err().next(),  None);
assert_eq!(err.iter_err().next(), Some(&1));

fn iter_err_mut(&mut self) -> IntoIter<&mut Self::E>

Like Result::iter_mut, but on Err

Examples

let mut ok: Result<i32, i32> = Ok(1);
let mut err: Result<i32, i32> = Err(1);

assert_eq!(ok.iter_err_mut().next(),  None);
assert_eq!(err.iter_err_mut().next(), Some(&mut 1));

fn into_iter_err(self) -> IntoIter<Self::E>

Like Result::into_iter, but on Err

Examples

let ok: Result<i32, i32> = Ok(1);
let err: Result<i32, i32> = Err(1);

assert_eq!(ok.into_iter_err().next(),  None);
assert_eq!(err.into_iter_err().next(), Some(1));

fn map_err_or<E, F>(self, default: E, f: F) -> E

where F: FnOnce(Self::E) -> E,

Like Result::map_or, but on Err

Examples

let ok: Result<i32, &str> = Ok(1);
let err: Result<i32, &str> = Err("err");

assert_eq!(ok.map_err_or(0, str::len),  0);
assert_eq!(err.map_err_or(0, str::len), 3);

fn map_err_or_else<E, D, F>(self, default: D, f: F) -> E

where F: FnOnce(Self::E) -> E, D: FnOnce(Self::T) -> E,

Like Result::map_or_else, but on Err

Examples

let ok: Result<usize, &str> = Ok(1);
let err: Result<usize, &str> = Err("err");

assert_eq!(ok.map_err_or_else(|n| n*2, str::len),  2);
assert_eq!(err.map_err_or_else(|n| n*2, str::len), 3);

fn transpose_err<E>(self) -> Option<Result<Self::T, E>>

where Self: ResultLike<E = Option<E>>,

Like Result::transpose, but on Err

Examples

let ok: Result<i32, Option<i32>> = Ok(1);
let none: Result<i32, Option<i32>> = Err(None);
let some: Result<i32, Option<i32>> = Err(Some(3));

assert_eq!(ok.transpose_err(),   Some(Ok(1)));
assert_eq!(none.transpose_err(), None);
assert_eq!(some.transpose_err(), Some(Err(3)));

fn err_into<E>(self) -> Result<Self::T, E>

where Self::E: Into<E>,

Like self.map_err(Into::into)

Examples

let e: Result<(), &str> = Err("foo");
let e1: Result<(), String> = e.err_into();
assert_eq!(e1, Err("foo".to_owned()));

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.

Implementors

impl<T: ResultLike> ResultExt for T