Enum tear::ValRet

#[must_use = "Suggestion: use tear! to handle it"]pub enum ValRet<V, R> {
    Val(V),
    Ret(R),
}

Represents a usable value or an early return. Use with tear!

Description

The idea is to type an early return. The early return either evaluates to something (Val) or returns early (Ret).

Variants

Val(V)

The usable value

Ret(R)

The return value

Implementations

impl<V, R> ValRet<V, R>

NB: Other combinators such as and, and_then, or, map_val aren’t implemented because I didn’t need them, not because they aren’t useful.

Examples will all use the following two variables

let ok:    ValRet<&str, &str> = Val("ok");
let error: ValRet<&str, &str> = Ret("error");

pub fn val(self) -> Option<V>

Gets the Val(V) variant as Option<V>

pub fn ret(self) -> Option<R>

Gets the Ret(R) variant as Option<R>

Trait Implementations

impl<V: Clone, R: Clone> Clone for ValRet<V, R>

fn clone(&self) -> ValRet<V, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug, R: Debug> Debug for ValRet<V, R>

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

Formats the value using the given formatter.

impl<T, R> Judge for ValRet<T, R>

type Positive = T

This is considered Good

type Negative = R

This is considered Bad

fn into_moral(self) -> Moral<T, R>

Convert to Moral

fn from_good(v: T) -> Self

Wraps a good value into itself

fn from_bad(r: R) -> Self

Wraps a bad value into itself

fn result(self) -> Result<Self::Positive, Self::Negative>

Convert to result

impl<V: PartialEq, R: PartialEq> PartialEq<ValRet<V, R>> for ValRet<V, R>

fn eq(&self, other: &ValRet<V, R>) -> bool

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

fn ne(&self, other: &ValRet<V, R>) -> bool

This method tests for !=.

impl<V, R> StructuralPartialEq for ValRet<V, R>