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 either_as_deref(&self) -> &<Self::T as Deref>::Target
       where Self::T: Deref,
             Self::E: Deref<Target = <Self::T as Deref>::Target> { ... }
    fn either_as_deref_mut(&mut self) -> &mut <Self::T as Deref>::Target
       where Self::T: DerefMut,
             Self::E: DerefMut<Target = <Self::T as Deref>::Target> { ... }
    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 unwrap_err_or(self, default: Self::E) -> Self::E { ... }
    fn unwrap_err_or_else<F>(self, op: F) -> Self::E
       where F: FnOnce(Self::T) -> Self::E { ... }
    fn unwrap_err_or_default(self) -> Self::E
       where Self::E: Default { ... }
    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> { ... }
    fn flip(self) -> Result<Self::E, Self::T> { ... }
    fn into_inner<O>(self) -> O
       where Self: ResultExt<T = O, E = O> { ... }
}

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 either_as_deref(&self) -> &<Self::T as Deref>::Target

where Self::T: Deref, Self::E: Deref<Target = <Self::T as Deref>::Target>,

Like Result::as_deref, but on Ok and Err

Examples

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

fn either_as_deref_mut(&mut self) -> &mut <Self::T as Deref>::Target

where Self::T: DerefMut, Self::E: DerefMut<Target = <Self::T as Deref>::Target>,

Like Result::as_deref, but on Ok and Err

Examples

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

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 unwrap_err_or(self, default: Self::E) -> Self::E

Like Result::unwrap_or, but on Err

Examples

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

assert_eq!(ok.unwrap_err_or("ok"),  "ok");
assert_eq!(err.unwrap_err_or("ok"), "err");

fn unwrap_err_or_else<F>(self, op: F) -> Self::E

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

Like Result::unwrap_or_else, but on Err

Examples

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

assert_eq!(ok.unwrap_err_or_else(|_| "ok"),  "ok");
assert_eq!(err.unwrap_err_or_else(|_| "ok"), "err");

fn unwrap_err_or_default(self) -> Self::E

where Self::E: Default,

Like Result::unwrap_or_default, but on Err

Examples

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

assert_eq!(ok.unwrap_err_or_default(),  "");
assert_eq!(err.unwrap_err_or_default(), "err");

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()));

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

Map Ok(x) => Err(x), Err(x) => Ok(x)

Examples

let ok:  Result<i32, i32> = Ok(3);
let err: Result<i32, i32> = Err(4);
assert_eq!(ok.flip(), Err(3));
assert_eq!(err.flip(), Ok(4));

fn into_inner<O>(self) -> O

where Self: ResultExt<T = O, E = O>,

Unpack Result<T, T>

Examples

let ok:  Result<i32, i32> = Ok(3);
let err: Result<i32, i32> = Err(4);
assert_eq!(ok.into_inner(), 3);
assert_eq!(err.into_inner(), 4);

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<T: ResultLike> ResultExt for T