Enum w_result::WResult

#[must_use]
pub enum WResult<T, W, E> {
    WOk(T, Vec<W>),
    WErr(E),
}

A result type that carries warnings.

Variants

WOk(T, Vec<W>)

Contains the success value along with any accumulated warnings.

WErr(E)

Contains the error value.

Methods

impl<T, W, E> WResult<T, W, E>

fn is_ok(&self) -> bool

Returns true if this WResult is WOk

fn is_err(&self) -> bool

Returns true if this WResult is WErr

fn is_warn_or_err(&self) -> bool

Returns true if this WResult is WErr or if it is WOk but contains warnings.

fn ok_discard(self) -> Option<T>

Converts this WResult to an Option by taking the taking the WOk value or mapping WErr to None. Any warnings are discarded.

fn err(self) -> Option<E>

Converts this WResult to an Option by taking the WErr variant or mapping WOk to None.

fn ok_werr(self) -> Option<T>

Converts this WResult to an Option by taking the WOk variant or mapping WErr to None. This function is similar to ok_discard except if there are any warnings then they are treated as errors and this function returns None.

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

Map the WOk value of this WResult, if any.

fn map_err<U, F>(self, op: F) -> WResult<T, W, U> where
    F: FnOnce(E) -> U, 

Map the WErr value of this WResult, if any.

fn map_warnings<U, F>(self, op: F) -> WResult<T, U, E> where
    F: FnMut(W) -> U, 

Map the warnings of this WResult.

fn and<U>(self, res: WResult<U, W, E>) -> WResult<U, W, E>

If self is WOk, returns res with the warnings from self accumulated into the final result. Otherwise returns the WErr value of self.

fn and_then<U, V, F>(self, op: F) -> WResult<U, V, E> where
    F: FnOnce(T, Vec<W>) -> WResult<U, V, E>, 

If self is WOk, returns the result of applying op to self's value and warnings. Otherwise returns the WErr value of self.

fn or<U>(self, res: WResult<T, W, U>) -> WResult<T, W, U>

If self is WOk returns self. Otherwise returns res.

fn or_else<U, F>(self, op: F) -> WResult<T, W, F> where
    F: FnOnce(E) -> WResult<T, W, F>, 

If self is WOk returns self. Otherwise returns the result of applying op to self's error value.

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

Convert this WResult<T, W, E> to a Result<T, E>, discarding any errors. See also result_log for a version of this function that logs warnings.

fn result_werr_res(self) -> Result<T, Result<W, E>>

Convert this WResult<T, W, E> to a Result<T, Result<W, E>>. This is a way to convert from WResult to Result, treating warnings as errors but allowing W and E to be two different types. See also result_werr for when W and E are the same type. If there are multiple warnings the first is returned.

fn unwrap_discard_or(self, optb: T) -> T

If self is WOk, unwraps it discarding any warnings. Otherwise returns optb. See also unwrap_log_or for a version of this function that logs warnings.

fn unwrap_or_werr(self, optb: T) -> T

If self is WOk and has no warnings, unwraps it. Otherwise returns optb.

fn unwrap_discard_or_else<F>(self, op: F) -> T where
    F: FnOnce(E) -> T, 

If self is WOk, unwraps it discarding any warnings. Otherwise returns the result of applying op to self's error value. See also unwrap_log_or_else for a version of this function that logs warnings.

impl<T, E> WResult<T, E, E>

fn err_werr(self) -> Option<E>

Take the error value of this WResult, if any. Otherwise returns the first warning, if any. This function is the same as WResult::err except that warnings are treated as errors.

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

Convert this WResult to a Result but treat warnings as errors. If there are multiple warnings the first is returned.

fn unwrap_or_else_werr<F>(self, op: F) -> T where
    F: FnOnce(E) -> T, 

If self is WOk and has no warnings then unwrap it. Otherwise return the result of applying op to self's error or first warning.

impl<T, W, E> WResult<T, W, E> where
    W: Display, 

fn ok_log(self) -> Option<T>

Take the WOk value of self, if any. Warnings are logged using the warn! macro before being discarded.

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

Convert this WResult<T, W, E> to a Result<T, E>. Warnings are logged using the warn! macro before being discarded.

fn unwrap_log_or(self, optb: T) -> T

If self is WOk, unwrap it and log any warnings using the warn! macro. Otherwise return optb.

fn unwrap_log_or_else<F>(self, op: F) -> T where
    F: FnOnce(E) -> T, 

If self is WOk, unwrap it and log any warnings using the warn! macro. Otherwise return the result of applying op to self's error value.

Trait Implementations

impl<T: PartialEq, W: PartialEq, E: PartialEq> PartialEq for WResult<T, W, E>

fn eq(&self, __arg_0: &WResult<T, W, E>) -> bool

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

fn ne(&self, __arg_0: &WResult<T, W, E>) -> bool

This method tests for !=.

impl<T: Eq, W: Eq, E: Eq> Eq for WResult<T, W, E>

impl<T: Hash, W: Hash, E: Hash> Hash for WResult<T, W, E>

fn hash<__HTWE: Hasher>(&self, __arg_0: &mut __HTWE)

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<T: Clone, W: Clone, E: Clone> Clone for WResult<T, W, E>

fn clone(&self) -> WResult<T, W, E>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, W: Debug, E: Debug> Debug for WResult<T, W, E>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T, W, E> From<Result<T, E>> for WResult<T, W, E>

fn from(val: Result<T, E>) -> WResult<T, W, E>

Performs the conversion.

impl<A, T, W, E> FromIterator<WResult<A, W, E>> for WResult<T, W, E> where
    T: FromIterator<A>, 

fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator<Item = WResult<A, W, E>>, 

Creates a value from an iterator.