Enum tear::Moral

pub enum Moral<Y, N> {
    Good(Y),
    Bad(N),
}

A notion of good and bad for the terror! macro

Variants

Good(Y)

The good

Bad(N)

And the bad

Implementations

impl<Y, N> Moral<Y, N>

pub fn good(self) -> Option<Y>

Gets the Good(Y) variant as Option<Y>

pub fn bad(self) -> Option<N>

Gets the Bad(N) variant as Option<N>

pub fn into_valret(self) -> ValRet<Y, N>

Convert to ValRet

Maps Good to Val and Bad to Ret.

pub fn into_result(self) -> Result<Y, N>

Convert to Result. Use Judge::result instead

Maps Good to Ok and Bad to Err.

pub fn resume_or_else<B>(
    self,
    f: impl FnOnce(N) -> Looping<Y, B>
) -> Looping<Y, B>

(dev) Convert to a Looping by mapping Good to Resume, and Bad through a function

The function f takes the bad value and maps it to a Looping value.

Used in the twist! macro with the mapping (=>) syntax. See twist! documentation.

Trait Implementations

impl<Y: Clone, N: Clone> Clone for Moral<Y, N>

fn clone(&self) -> Moral<Y, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Y: Debug, N: Debug> Debug for Moral<Y, N>

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

Formats the value using the given formatter.

impl<Y, N> Judge for Moral<Y, N>

type Positive = Y

This is considered Good

type Negative = N

This is considered Bad

fn into_moral(self) -> Moral<Y, N>

Convert to Moral

fn from_good(v: Y) -> Self

Wraps a good value into itself

fn from_bad(v: N) -> Self

Wraps a bad value into itself

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

Convert to result

impl<Y: PartialEq, N: PartialEq> PartialEq<Moral<Y, N>> for Moral<Y, N>

fn eq(&self, other: &Moral<Y, N>) -> bool

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

fn ne(&self, other: &Moral<Y, N>) -> bool

This method tests for !=.

impl<Y, N> StructuralPartialEq for Moral<Y, N>