Enum woah::Result

pub enum Result<T, L, F> {
    Success(T),
    LocalErr(L),
    FatalErr(F),
}

A type representing success (Success), a local error (LocalErr), or a fatal error (FatalErr).

See the woah top-level documentation for details.

Variants

Success(T)

Contains the success value.

LocalErr(L)

Contains a local error value (which should be handled)

FatalErr(F)

Contains a fatal error value (which should be propagated)

Implementations

impl<T, L, F> Result<T, L, F>

pub fn into_result(self) -> StdResult<StdResult<T, L>, F>

Convert woah::Result<T, L, F> into a Result<Result<T, L>, F>, which is equivalent in ? behavior.

Example

use woah::prelude::*;

let result: StdResult<StdResult<i64, &str>, &str> = LocalErr("a local error").into_result();
assert_eq!(result, Ok(Err("a local error")));

pub fn from_result(ok: StdResult<T, L>) -> Self

Construct either a Success or LocalErr variant based on a Result.

Example

use woah::prelude::*;

let result: Result<i64, &str, &str> = Result::from_result(Ok(0));
assert_eq!(result, Success(0));

pub fn from_success(val: T) -> Self

Construct the Success variant based on some success value.

Example

use woah::prelude::*;

let fatal_err: Result<i64, &str, &str> = Result::from_success(0);
assert_eq!(fatal_err, Success(0));

pub fn from_local_err(err: L) -> Self

Construct the LocalErr variant based on some error.

Example

use woah::prelude::*;

let fatal_err: Result<i64, &str, &str> = Result::from_fatal_error("a fatal error");
assert_eq!(fatal_err, FatalErr("a fatal error"));

pub fn from_fatal_error(err: F) -> Self

Construct the FatalErr variant based on some error.

Example

use woah::prelude::*;

let fatal_err: Result<i64, &str, &str> = Result::from_fatal_error("a fatal error");
assert_eq!(fatal_err, FatalErr("a fatal error"));

pub fn is_success(&self) -> bool

Returns true if the result is Success.

Example

use woah::prelude::*;

let x: Result<i32, &str, &str> = Success(-3);
assert_eq!(x.is_success(), true);

let x: Result<i32, &str, &str> = LocalErr("Some error message");
assert_eq!(x.is_success(), false);

let x: Result<i32, &str, &str> = FatalErr("Another error message");
assert_eq!(x.is_success(), false);

pub fn is_err(&self) -> bool

Returns true if the result is LocalErr or FatalErr.

Example

use woah::prelude::*;

let x: Result<i32, &str, &str> = Success(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str, &str> = LocalErr("Some error message");
assert_eq!(x.is_err(), true);

let x: Result<i32, &str, &str> = FatalErr("Another error message");
assert_eq!(x.is_err(), true);

pub fn is_local_err(&self) -> bool

Returns true if the result is LocalErr.

Example

use woah::prelude::*;

let x: Result<i32, &str, &str> = Success(-3);
assert_eq!(x.is_local_err(), false);

let x: Result<i32, &str, &str> = LocalErr("Some error message");
assert_eq!(x.is_local_err(), true);

let x: Result<i32, &str, &str> = FatalErr("Another error message");
assert_eq!(x.is_local_err(), false);

pub fn is_fatal_err(&self) -> bool

Returns true if the result is FatalErr.

Example

use woah::prelude::*;

let x: Result<i32, &str, &str> = Success(-3);
assert_eq!(x.is_fatal_err(), false);

let x: Result<i32, &str, &str> = LocalErr("Some error message");
assert_eq!(x.is_fatal_err(), false);

let x: Result<i32, &str, &str> = FatalErr("Another error message");
assert_eq!(x.is_fatal_err(), true);

pub fn contains<U>(&self, x: &U) -> bool where
    U: PartialEq<T>, 

Returns true if the result is a Success value containing the given value.

Examples

use woah::prelude::*;

let x: Result<u32, &str, &str> = Success(2);
assert_eq!(x.contains(&2), true);

let x: Result<u32, &str, &str> = Success(3);
assert_eq!(x.contains(&2), false);

let x: Result<u32, &str, &str> = LocalErr("Some error message");
assert_eq!(x.contains(&2), false);

pub fn contains_err<U, Y>(&self, e: Either<&U, &Y>) -> bool where
    U: PartialEq<L>,
    Y: PartialEq<F>, 

Returns true if the result is a LocalErr or FatalErr value containing the given value.

Examples

use woah::prelude::*;
use either::Either;

let x: Result<&str, u32, &str> = LocalErr(2);
let check: Either<_, &&str> = Either::Left(&2);
assert_eq!(x.contains_err(check), true);

let x: Result<&str, &str, u32> = FatalErr(3);
let check: Either<&&str, _> = Either::Right(&2);
assert_eq!(x.contains_err(check), false);

let x: Result<u32, &str, &str> = Success(0);
let check: Either<&&str, &&str> = Either::Left(&"");
assert_eq!(x.contains_err(check), false);

pub fn contains_local_err<E>(&self, e: &E) -> bool where
    E: PartialEq<L>, 

Returns true if the result is a LocalErr value containing the given value.

Examples

use woah::prelude::*;

let x: Result<&str, u32, &str> = LocalErr(2);
assert_eq!(x.contains_local_err(&2), true);

let x: Result<&str, u32, &str> = LocalErr(3);
assert_eq!(x.contains_local_err(&2), false);

let x: Result<&str, u32, &str> = Success("Some error message");
assert_eq!(x.contains_local_err(&2), false);

pub fn contains_fatal_err<E>(&self, e: &E) -> bool where
    E: PartialEq<F>, 

Returns true if the result is a FatalErr value containing the given value.

Examples

use woah::prelude::*;

let x: Result<&str, &str, u32> = FatalErr(2);
assert_eq!(x.contains_fatal_err(&2), true);

let x: Result<&str, &str, u32> = FatalErr(3);
assert_eq!(x.contains_fatal_err(&2), false);

let x: Result<&str, &str, u32> = Success("Some error message");
assert_eq!(x.contains_fatal_err(&2), false);

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

Convert a Success variant to an Option::Some, otherwise to a None.

Example

use woah::prelude::*;

let x: Result<u32, &str, &str> = Success(2);
assert_eq!(x.success(), Some(2));

let x: Result<&str, u32, &str> = LocalErr(2);
assert_eq!(x.success(), None);

let x: Result<&str, &str, u32> = FatalErr(2);
assert_eq!(x.success(), None);

pub fn err(self) -> Option<Either<L, F>>

Convert a LocalErr or FatalErr variant to an Option<Either<_, _>>, otherwise to a None.

Example

use woah::prelude::*;
use either::Either::{self, Left, Right};

let x: Result<u32, &str, &str> = Success(2);
assert_eq!(x.err(), None);

let x: Result<&str, u32, &str> = LocalErr(2);
assert_eq!(x.err(), Some(Left(2)));

let x: Result<&str, &str, u32> = FatalErr(2);
assert_eq!(x.err(), Some(Right(2)));

pub fn local_err(self) -> Option<L>

Convert a LocalErr variant to an Option::Some, otherwise to a None.

Example

use woah::prelude::*;

let x: Result<u32, &str, &str> = Success(2);
assert_eq!(x.local_err(), None);

let x: Result<&str, u32, &str> = LocalErr(2);
assert_eq!(x.local_err(), Some(2));

let x: Result<&str, &str, u32> = FatalErr(2);
assert_eq!(x.local_err(), None);

pub fn fatal_err(self) -> Option<F>

Convert a FatalErr variant to an Option::Some, otherwise to a None.

Example

use woah::prelude::*;

let x: Result<u32, &str, &str> = Success(2);
assert_eq!(x.fatal_err(), None);

let x: Result<&str, u32, &str> = LocalErr(2);
assert_eq!(x.fatal_err(), None);

let x: Result<&str, &str, u32> = FatalErr(2);
assert_eq!(x.fatal_err(), Some(2));

pub fn as_ref(&self) -> Result<&T, &L, &F>

Get a reference to the contained value.

Example

use woah::prelude::*;

let x: Result<u32, u32, u32> = Success(0);
assert_eq!(x.as_ref(), Success(&0));

let x: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(x.as_ref(), LocalErr(&0));

let x: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(x.as_ref(), FatalErr(&0));

pub fn as_mut(&mut self) -> Result<&mut T, &mut L, &mut F>

Get a mutable reference to the contained value.

Example

use woah::prelude::*;

let mut x: Result<u32, u32, u32> = Success(0);
assert_eq!(x.as_mut(), Success(&mut 0));

let mut x: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(x.as_mut(), LocalErr(&mut 0));

let mut x: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(x.as_mut(), FatalErr(&mut 0));

pub fn map<U, S>(self, f: U) -> Result<S, L, F> where
    U: FnOnce(T) -> S, 

Apply a function to the contained value if it’s a Success.

Example

use woah::prelude::*;

let x: Result<u32, u32, u32> = Success(0);
assert_eq!(x.map(|s| s + 1), Success(1));

let x: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(x.map(|s| s + 1), LocalErr(0));

let x: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(x.map(|s| s + 1), FatalErr(0));

pub fn map_or<U, G>(self, default: U, f: G) -> U where
    G: FnOnce(T) -> U, 

Apply a function to the contained value if it’s a Success.

Otherwise return the provided value.

Example

use woah::prelude::*;

let x: Result<u32, u32, u32> = Success(0);
assert_eq!(x.map_or(5, |s| s + 1), 1);

let x: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(x.map_or(5, |s| s + 1), 5);

let x: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(x.map_or(5, |s| s + 1), 5);

pub fn map_or_else<U, LD, FD, G>(
    self,
    default_local: LD,
    default_fatal: FD,
    f: G
) -> U where
    LD: FnOnce(L) -> U,
    FD: FnOnce(F) -> U,
    G: FnOnce(T) -> U, 

Apply a function to the contained value if it’s a Success.

Otherwise run one of the provided default functions.

Example

use woah::prelude::*;

let x: Result<u32, u32, u32> = Success(0);
assert_eq!(x.map_or_else(|l| l + 3, |f| f + 2, |s| s + 1), 1);

let x: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(x.map_or_else(|l| l + 3, |f| f + 2, |s| s + 1), 3);

let x: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(x.map_or_else(|l| l + 3, |f| f + 2, |s| s + 1), 2);

pub fn map_err<U, M, G>(self, f: U) -> Result<T, M, G> where
    U: FnOnce(Either<L, F>) -> Either<M, G>, 

Apply a function to the contained value if it’s a LocalErr or FatalErr.

Example

use woah::prelude::*;
use either::Either::{self, Left, Right};

fn modify_error(err: Either<u32, u32>) -> Either<u32, u32> {
    match err {
        Left(l) => Left(l + 1),
        Right(f) => Right(f + 1),
    }
}

let x: Result<u32, u32, u32> = Success(0);
assert_eq!(x.map_err(modify_error), Success(0));

let x: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(x.map_err(modify_error), LocalErr(1));

let x: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(x.map_err(modify_error), FatalErr(1));

pub fn map_local_err<U, S>(self, f: U) -> Result<T, S, F> where
    U: FnOnce(L) -> S, 

Apply a function to the contained value if it’s a LocalErr.

Example

use woah::prelude::*;

let x: Result<u32, u32, u32> = Success(0);
assert_eq!(x.map_local_err(|l| l + 1), Success(0));

let x: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(x.map_local_err(|l| l + 1), LocalErr(1));

let x: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(x.map_local_err(|l| l + 1), FatalErr(0));

pub fn map_fatal_err<U, S>(self, f: U) -> Result<T, L, S> where
    U: FnOnce(F) -> S, 

Apply a function to the contained value if it’s a FatalErr.

Example

use woah::prelude::*;

let x: Result<u32, u32, u32> = Success(0);
assert_eq!(x.map_fatal_err(|f| f + 1), Success(0));

let x: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(x.map_fatal_err(|f| f + 1), LocalErr(0));

let x: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(x.map_fatal_err(|f| f + 1), FatalErr(1));

pub fn iter(&self) -> Iter<'_, T>

Get an iterator over the inner value in the Result, if it’s a Success.

Example

use woah::prelude::*;

let r: Result<u32, &str, &str> = Success(0);

assert_eq!(r.iter().next(), Some(&0));

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Get a mutable iterator over the inner value in the Result, if it’s a Success.

Example

use woah::prelude::*;

let mut r: Result<u32, &str, &str> = Success(0);

{
    let next = r.iter_mut().next();

    assert!(next.is_some());

    *next.unwrap() = 5;
}

assert_eq!(r, Success(5));

pub fn and<U>(self, res: Result<U, L, F>) -> Result<U, L, F>

If it’s a Success, replace it with res.

Example

use woah::prelude::*;

let r1: Result<u32, &str, &str> = Success(0);
let r2: Result<u32, _, &str> = r1.and(LocalErr(""));
assert_eq!(r2, LocalErr(""));

pub fn and_then<U, G>(self, op: G) -> Result<U, L, F> where
    G: FnOnce(T) -> Result<U, L, F>, 

If it’s a Success, replace it with the result of op.

Example

use woah::prelude::*;

let r1: Result<u32, &str, &str> = Success(0);
let r2: Result<u32, _, &str> = r1.and_then(|c| {
    if c == 0 {
        LocalErr("local")
    } else {
        FatalErr("fatal")
    }
});

assert_eq!(r2, LocalErr("local"));

pub fn or<M, G>(
    self,
    res_local: Result<T, M, G>,
    res_fatal: Result<T, M, G>
) -> Result<T, M, G>

If it’s a LocalErr or FatalErr, replace them with the appropriate value.

Example

use woah::prelude::*;

let l: Result<u32, u32, u32> = LocalErr(1);
let f: Result<u32, u32, u32> = FatalErr(2);

let r: Result<u32, u32, u32> = Success(0);
assert_eq!(r.or(l, f), Success(0));

let r: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(r.or(l, f), LocalErr(1));

let r: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(r.or(l, f), FatalErr(2));

pub fn or_local<M>(self, res: Result<T, M, F>) -> Result<T, M, F>

If it’s a LocalErr, replace them with the given value.

Example

use woah::prelude::*;

let l: Result<u32, u32, u32> = LocalErr(1);

let r: Result<u32, u32, u32> = Success(0);
assert_eq!(r.or_local(l), Success(0));

let r: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(r.or_local(l), LocalErr(1));

let r: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(r.or_local(l), FatalErr(0));

pub fn or_fatal<G>(self, res: Result<T, L, G>) -> Result<T, L, G>

If it’s a FatalErr, replace them with the given value.

Example

use woah::prelude::*;

let f: Result<u32, u32, u32> = FatalErr(2);

let r: Result<u32, u32, u32> = Success(0);
assert_eq!(r.or_fatal(f), Success(0));

let r: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(r.or_fatal(f), LocalErr(0));

let r: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(r.or_fatal(f), FatalErr(2));

pub fn or_else<O, P, M, G>(self, op_local: O, op_fatal: P) -> Result<T, M, G> where
    O: FnOnce(L) -> Result<T, M, G>,
    P: FnOnce(F) -> Result<T, M, G>, 

If it’s a LocalErr or FatalErr, replace them with the appropriate function result.

Example

use woah::prelude::*;

let l = |l| LocalErr(l + 1);
let f = |f| FatalErr(f + 2);

let r: Result<u32, u32, u32> = Success(0);
assert_eq!(r.or_else(l, f), Success(0));

let r: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(r.or_else(l, f), LocalErr(1));

let r: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(r.or_else(l, f), FatalErr(2));

pub fn or_else_local<O, M>(self, op: O) -> Result<T, M, F> where
    O: FnOnce(L) -> Result<T, M, F>, 

If it’s a LocalErr, replace it with the appropriate function result.

Example

use woah::prelude::*;

let l = |l| LocalErr(l + 1);

let r: Result<u32, u32, u32> = Success(0);
assert_eq!(r.or_else_local(l), Success(0));

let r: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(r.or_else_local(l), LocalErr(1));

let r: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(r.or_else_local(l), FatalErr(0));

pub fn or_else_fatal<O, G>(self, op: O) -> Result<T, L, G> where
    O: FnOnce(F) -> Result<T, L, G>, 

If it’s a FatalErr, replace it with the appropriate function result.

Example

use woah::prelude::*;

let f = |f| FatalErr(f + 2);

let r: Result<u32, u32, u32> = Success(0);
assert_eq!(r.or_else_fatal(f), Success(0));

let r: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(r.or_else_fatal(f), LocalErr(0));

let r: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(r.or_else_fatal(f), FatalErr(2));

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

Return inner value if it’s a Success, or alt otherwise.

Example

use woah::prelude::*;

let r: Result<u32, u32, u32> = Success(0);
assert_eq!(r.unwrap_or(5), 0);

let r: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(r.unwrap_or(5), 5);

let r: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(r.unwrap_or(5), 5);

pub fn unwrap_or_else<M, G>(self, local_op: M, fatal_op: G) -> T where
    M: FnOnce(L) -> T,
    G: FnOnce(F) -> T, 

Return inner value if it’s a Success, or the appropriate function otherwise.

Example

use woah::prelude::*;

let l = |_| 5;
let f = |_| 10;

let r: Result<u32, u32, u32> = Success(0);
assert_eq!(r.unwrap_or_else(l, f), 0);

let r: Result<u32, u32, u32> = LocalErr(0);
assert_eq!(r.unwrap_or_else(l, f), 5);

let r: Result<u32, u32, u32> = FatalErr(0);
assert_eq!(r.unwrap_or_else(l, f), 10);

impl<'a, T, L, F> Result<&'a T, L, F> where
    T: Copy, 

pub fn copied(self) -> Result<T, L, F>

Copy the value if it’s a Success.

Example

use woah::prelude::*;

let r: Result<&u32, (), ()> = Success(&0);
assert_eq!(r.copied(), Success(0));

impl<'a, T, L, F> Result<&'a mut T, L, F> where
    T: Copy, 

pub fn copied(self) -> Result<T, L, F>

Copy the value if it’s a Success.

Example

use woah::prelude::*;

let r: Result<&u32, (), ()> = Success(&0);
assert_eq!(r.copied(), Success(0));

impl<'a, T, L, F> Result<&'a T, L, F> where
    T: Clone, 

pub fn cloned(self) -> Result<T, L, F>

Clone the value if it’s a Success.

Example

use woah::prelude::*;

let r: Result<&u32, (), ()> = Success(&0);
assert_eq!(r.cloned(), Success(0));

impl<'a, T, L, F> Result<&'a mut T, L, F> where
    T: Clone, 

pub fn cloned(self) -> Result<T, L, F>

Clone the value if it’s a Success.

Example

use woah::prelude::*;

let r: Result<&u32, (), ()> = Success(&0);
assert_eq!(r.cloned(), Success(0));

impl<T, L, F> Result<T, L, F> where
    L: Debug,
    F: Debug, 

pub fn unwrap(self) -> T

Get the value if it’s a Success, panic otherwise.

Example

use woah::prelude::*;

let r: Result<u32, (), ()> = Success(0);
assert_eq!(r.unwrap(), 0);

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

Get the value if it’s a Success, panic with a msg otherwise.

Example

use woah::prelude::*;

let r: Result<u32, (), ()> = Success(0);
assert_eq!(r.expect("should be success"), 0);

impl<T, L, F> Result<T, L, F> where
    T: Debug,
    L: Debug,
    F: Debug, 

pub fn unwrap_err(self) -> Either<L, F>

pub fn expect_err(self, msg: &str) -> Either<L, F>

impl<T, L, F> Result<T, L, F> where
    T: Debug,
    F: Debug, 

pub fn unwrap_local_err(self) -> L

pub fn expect_local_err(self, msg: &str) -> L

impl<T, L, F> Result<T, L, F> where
    T: Debug,
    L: Debug, 

pub fn unwrap_fatal_err(self) -> F

pub fn expect_fatal_err(self, msg: &str) -> F

impl<T, L, F> Result<T, L, F> where
    T: Default, 

pub fn unwrap_or_default(self) -> T

pub fn into_result_default(self) -> StdResult<T, F>

impl<T, L, F> Result<T, L, F> where
    L: Into<!>,
    F: Into<!>, 

pub fn into_success(self) -> T

impl<T, L, F> Result<T, L, F> where
    T: Deref, 

pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &L, &F>

impl<T, L, F> Result<T, L, F> where
    L: Deref,
    F: Deref, 

pub fn as_deref_err(
    &self
) -> Result<&T, &<L as Deref>::Target, &<F as Deref>::Target>

impl<T, L, F> Result<T, L, F> where
    L: Deref, 

pub fn as_deref_local_err(&self) -> Result<&T, &<L as Deref>::Target, &F>

impl<T, L, F> Result<T, L, F> where
    F: Deref, 

pub fn as_deref_fatal_err(&self) -> Result<&T, &L, &<F as Deref>::Target>

impl<T, L, F> Result<T, L, F> where
    T: DerefMut, 

pub fn as_deref_mut(
    &mut self
) -> Result<&mut <T as Deref>::Target, &mut L, &mut F>

impl<T, L, F> Result<T, L, F> where
    L: DerefMut,
    F: DerefMut, 

pub fn as_deref_mut_err(
    &mut self
) -> Result<&mut T, &mut <L as Deref>::Target, &mut <F as Deref>::Target>

impl<T, L, F> Result<T, L, F> where
    L: DerefMut, 

pub fn as_deref_mut_local_err(
    &mut self
) -> Result<&mut T, &mut <L as Deref>::Target, &mut F>

impl<T, L, F> Result<T, L, F> where
    F: DerefMut, 

pub fn as_deref_mut_fatal_err(
    &mut self
) -> Result<&mut T, &mut L, &mut <F as Deref>::Target>

impl<T, L, F> Result<Option<T>, L, F>

pub fn transpose(self) -> Option<Result<T, L, F>>

Trait Implementations

impl<T, L, F> Clone for Result<T, L, F> where
    T: Clone,
    L: Clone,
    F: Clone, 

fn clone(&self) -> Result<T, L, F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Result<T, L, F>)

Performs copy-assignment from source.

impl<T: Debug, L: Debug, F: Debug> Debug for Result<T, L, F>

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

Formats the value using the given formatter.

impl<'de, T, L, F> Deserialize<'de> for Result<T, L, F> where
    T: Deserialize<'de>,
    L: Deserialize<'de>,
    F: Deserialize<'de>, 

fn deserialize<D>(deserializer: D) -> StdResult<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T, L, F> From<Result<Result<T, L>, F>> for Result<T, L, F>

fn from(result: StdResult<StdResult<T, L>, F>) -> Result<T, L, F>

Converts to this type from the input type.

impl<T, L, F> From<Result<T, L, F>> for StdResult<StdResult<T, L>, F>

fn from(other: Result<T, L, F>) -> StdResult<StdResult<T, L>, F>

Converts to this type from the input type.

impl<T, L, F> From<Result<T, L>> for Result<T, L, F>

fn from(result: StdResult<T, L>) -> Result<T, L, F>

Converts to this type from the input type.

impl<A, V, L, F> FromIterator<Result<A, L, F>> for Result<V, L, F> where
    V: FromIterator<A>, 

fn from_iter<I>(iter: I) -> Result<V, L, F> where
    I: IntoIterator<Item = Result<A, L, F>>, 

Creates a value from an iterator.

impl<T, L, F> FromResidual<<Result<T, L, F> as Try>::Residual> for Result<T, L, F>

fn from_residual(residual: StdResult<Infallible, F>) -> Self

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

Constructs the type from a compatible Residual type.

impl<T: Hash, L: Hash, F: Hash> Hash for Result<T, L, F>

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, 

Feeds a slice of this type into the given Hasher.

impl<'a, T, L, F> IntoIterator for &'a mut Result<T, L, F>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<'a, T, L, F> IntoIterator for &'a Result<T, L, F>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<T, L, F> IntoIterator for Result<T, L, F>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value.

impl<T: Ord, L: Ord, F: Ord> Ord for Result<T, L, F>

fn cmp(&self, other: &Result<T, L, F>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T: PartialEq, L: PartialEq, F: PartialEq> PartialEq<Result<T, L, F>> for Result<T, L, F>

fn eq(&self, other: &Result<T, L, F>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Result<T, L, F>) -> bool

This method tests for !=.

impl<T: PartialOrd, L: PartialOrd, F: PartialOrd> PartialOrd<Result<T, L, F>> for Result<T, L, F>

fn partial_cmp(&self, other: &Result<T, L, F>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U, L, F> Product<Result<U, L, F>> for Result<T, L, F> where
    T: Product<U>, 

fn product<I>(iter: I) -> Result<T, L, F> where
    I: Iterator<Item = Result<U, L, F>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<T, L, F> Serialize for Result<T, L, F> where
    T: Serialize,
    L: Serialize,
    F: Serialize, 

fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T, U, L, F> Sum<Result<U, L, F>> for Result<T, L, F> where
    T: Sum<U>, 

fn sum<I>(iter: I) -> Result<T, L, F> where
    I: Iterator<Item = Result<U, L, F>>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<L, F> Termination for Result<(), L, F> where
    L: Debug,
    F: Debug, 

fn report(self) -> ExitCode

Is called to get the representation of the value as status code. This status code is returned to the operating system.

impl<L, F> Termination for Result<!, L, F> where
    L: Debug,
    F: Debug, 

fn report(self) -> ExitCode

Is called to get the representation of the value as status code. This status code is returned to the operating system.

impl<T, L, F> Try for Result<T, L, F>

type Output = Result<T, L>

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

The type of the value produced by ? when not short-circuiting.

type Residual = Result<Infallible, F>

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

The type of the value passed to FromResidual::from_residual as part of ? when short-circuiting.

fn from_output(output: StdResult<T, L>) -> Self

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

Constructs the type from its Output type.

fn branch(self) -> ControlFlow<StdResult<Infallible, F>, StdResult<T, L>>

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

Used in ? to decide whether the operator should produce a value (because this returned ControlFlow::Continue) or propagate a value back to the caller (because this returned ControlFlow::Break).

impl<T: Copy, L: Copy, F: Copy> Copy for Result<T, L, F>

impl<T: Eq, L: Eq, F: Eq> Eq for Result<T, L, F>

impl<T, L, F> StructuralEq for Result<T, L, F>

impl<T, L, F> StructuralPartialEq for Result<T, L, F>