Enum Decision 

pub enum Decision<P> {
    IsTrue(P),
    IsFalse(String),
}

A decision about a proposition P.

Decision::IsTrue carries a witness (proof) that P holds. Decision::IsFalse carries an explanation that it does not.

Variants

IsTrue(P)

The proposition holds.

IsFalse(String)

The proposition does not hold; the string is an explanatory message.

Implementations

impl<P> Decision<P>

pub fn is_true(&self) -> bool

Returns true if the decision is positive.

pub fn is_false(&self) -> bool

Returns true if the decision is negative.

pub fn unwrap(self) -> P

Unwrap the positive proof, panicking if negative.

pub fn into_option(self) -> Option<P>

Convert to Option, dropping the negative message.

pub fn map<Q>(self, f: impl FnOnce(P) -> Q) -> Decision<Q>

Map the positive witness through f.

pub fn and<Q>(self, other: Decision<Q>) -> Decision<(P, Q)>

Combine with another Decision via conjunction.

pub fn or(self, other: Decision<P>) -> Decision<P>

Combine with another Decision via disjunction (left-biased).

pub fn negate(self) -> Decision<String>

where P: Debug,

Negate the decision.

pub fn flat_map<Q>(self, f: impl FnOnce(P) -> Decision<Q>) -> Decision<Q>

Apply f if true, returning a new decision.

pub fn unwrap_or(self, default: P) -> P

Return default if false.

pub fn unwrap_or_else(self, f: impl FnOnce(String) -> P) -> P

Apply a fallback function if false.

impl Decision<bool>

pub fn to_bool(&self) -> bool

Convert a simple bool decision to a native bool.

Trait Implementations

impl<P: Clone> Clone for Decision<P>

fn clone(&self) -> Decision<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug> Debug for Decision<P>

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

Formats the value using the given formatter.

impl From<bool> for Decision<bool>

fn from(b: bool) -> Self

Converts to this type from the input type.

impl<P: PartialEq> PartialEq for Decision<P>

fn eq(&self, other: &Decision<P>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P: Eq> Eq for Decision<P>

impl<P> StructuralPartialEq for Decision<P>