Enum tear::ValRet

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 and 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 valret(self) -> Self

Optimization (?) for the Return trait

pub fn map_ret<R1>(self, f: impl FnOnce(R) -> R1) -> ValRet<V, R1>

Returns a new ValRet where we map the old Ret to the new Ret using the function supplied

assert_eq![    ok.map_ret(|_| -1), Val("ok") ];
assert_eq![ error.map_ret(|_| -1), Ret(-1)   ];

pub fn or_else<R1>(self, f: impl FnOnce(R) -> ValRet<V, R1>) -> ValRet<V, R1>

Returns itself if it's a Val, otherwise calls the function to create a new ValRet based on the value of Ret.

fn recover (e: &str) -> ValRet<&str, i32> {
	if e == "error" { Val("recover") } else { Ret(-1) }
}
	
assert_eq![    ok.or_else(recover), Val("ok")      ];
assert_eq![ error.or_else(recover), Val("recover") ];

Trait Implementations

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

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>