Enum Erm 

pub enum Erm<T> {
    Yes(T),
    No,
    Maybe(T),
    MaybeNot,
    DontKnow,
}

You can use this like an Option with the first two variants, but you can do…more.

Variants

Yes(T)

This is Option::Some. It works.

No

This is Option::None. It does not work.

Maybe(T)

Outputs of randomised procedures, for example, can be represented with this variant. It means you’re confident enough in the outcome that you’d like to go ahead with it, while making sure you remember that stuff could go wrong.

MaybeNot

This variant is for when it’s probably a good idea to treat the outcome as a failure, but if you’re really optimistic, you can still try it.

DontKnow

No promises. You really should retry or something.

Implementations

impl<T> Erm<T>

pub fn is(&self) -> bool

Like is_some().

pub fn is_and(self, f: impl FnOnce(T) -> bool) -> bool

Like is_some_and().

pub fn is_not(&self) -> bool

Like is_none().

pub fn is_not_or(self, f: impl FnOnce(T) -> bool) -> bool

Like is_none_or().

pub fn might_be(&self) -> bool

Optimistic.

pub fn might_not_be(&self) -> bool

Pessimistic.

pub fn known(&self) -> bool

pub fn unknown(&self) -> bool

pub const fn as_ref(&self) -> Erm<&T>

pub const fn as_mut(&mut self) -> Erm<&mut T>

pub fn expect(self, msg: &str) -> T

pub fn expect_sure(self, msg: &str) -> T

pub fn unwrap(self) -> T

pub fn unwrap_sure(self) -> T

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

pub fn unwrap_sure_or(self, default: T) -> T

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

pub fn unwrap_sure_or_else(self, f: impl FnOnce() -> T) -> T

pub fn unwrap_or_default(self) -> T

where T: Default,

pub fn unwrap_sure_or_default(self) -> T

where T: Default,

pub unsafe fn unwrap_unchecked(self) -> T

pub fn map<U>(self, f: impl FnOnce(T) -> U) -> Erm<U>

pub fn inspect(self, f: impl FnOnce(&T)) -> Erm<T>

pub fn map_or<U>(self, default: U, f: impl FnOnce(T) -> U) -> U

pub fn map_or_else<U>( self, default: impl FnOnce() -> U, f: impl FnOnce(T) -> U, ) -> U

pub fn map_or_default<U, F>(self, f: F) -> U

where U: Default, F: FnOnce(T) -> U,

pub fn ok_or(self, err: T) -> Result<T, T>

pub fn sure_or(self, err: T) -> Result<T, T>

pub fn ok_or_else(self, err: impl FnOnce() -> T) -> Result<T, T>

pub fn sure_or_else(self, err: impl FnOnce() -> T) -> Result<T, T>

pub fn as_deref(&self) -> Erm<&T::Target>

where T: Deref,

pub fn as_deref_mut(&mut self) -> Erm<&mut T::Target>

where T: DerefMut,

pub const fn take(&mut self) -> Erm<T>

pub fn ensure(self) -> Erm<T>

pub fn and<U>(self, other: Erm<U>) -> Erm<U>

pub fn and_sure<U>(self, other: Erm<U>) -> Erm<U>

pub fn and_then<U, F>(self, f: F) -> Erm<U>

where F: FnOnce(T) -> Erm<U>,

pub fn and_then_sure<U, F>(self, f: F) -> Erm<U>

where F: FnOnce(T) -> Erm<U>,

pub fn filter<P>(self, predicate: P) -> Erm<T>

where P: Fn(&T) -> bool,

pub fn or(self, optb: Erm<T>) -> Erm<T>

pub fn or_sure(self, optb: Erm<T>) -> Erm<T>

pub fn or_else(self, f: impl FnOnce() -> Erm<T>) -> Erm<T>

pub fn or_else_sure(self, f: impl FnOnce() -> Erm<T>) -> Erm<T>

pub fn xor(self, other: Erm<T>) -> Erm<T>

pub fn iter(&self) -> Iter<'_, T>

pub fn iter_mut(&mut self) -> IterMut<'_, T>

pub fn insert(&mut self, value: T) -> &mut T

pub fn insert_maybe(&mut self, value: T) -> &mut T

pub fn get_or_insert(&mut self, value: T) -> &mut T

pub fn get_or_insert_maybe(&mut self, value: T) -> &mut T

pub fn get_or_insert_with<F>(&mut self, f: F) -> &mut T

where F: FnOnce() -> T,

pub fn get_or_insert_with_maybe<F>(&mut self, f: F) -> &mut T

where F: FnOnce() -> T,

pub fn get_or_insert_default(&mut self) -> &mut T

where T: Default,

pub fn take_if<P>(&mut self, predicate: P) -> Erm<T>

where P: FnOnce(&mut T) -> bool,

pub const fn replace(&mut self, value: T) -> Erm<T>

pub fn zip<U>(self, other: Erm<U>) -> Erm<(T, U)>

pub fn zip_or_default<U>(self, other: Erm<U>) -> Erm<(T, U)>

where T: Default, U: Default,

pub fn zip_with<U, F>(self, other: Erm<U>, f: F) -> Erm<T>

where F: FnOnce(T, U) -> T,

impl<T, U> Erm<(T, U)>

pub fn unzip(self) -> (Erm<T>, Erm<U>)

impl<T> Erm<&T>

pub fn copied(self) -> Erm<T>

where T: Copy,

pub fn cloned(self) -> Erm<T>

where T: Clone,

impl<T> Erm<&mut T>

pub fn copied(self) -> Erm<T>

where T: Copy,

pub fn cloned(self) -> Erm<T>

where T: Clone,

impl<T, E> Erm<Result<T, E>>

pub fn transpose(self) -> Result<Erm<T>, E>

Trait Implementations

impl<T: Clone> Clone for Erm<T>

fn clone(&self) -> Erm<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Erm<T>

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

Formats the value using the given formatter.

impl<T> Default for Erm<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T> From<&'a Erm<T>> for Erm<&'a T>

fn from(value: &'a Erm<T>) -> Self

Converts to this type from the input type.

impl<'a, T> From<&'a mut Erm<T>> for Erm<&'a mut T>

fn from(value: &'a mut Erm<T>) -> Self

Converts to this type from the input type.

impl<T> From<Option<T>> for Erm<T>

fn from(value: Option<T>) -> Self

Converts to this type from the input type.

impl<T> From<T> for Erm<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for Erm<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Into<Option<T>> for Erm<T>

fn into(self) -> Option<T>

Converts this type into the (usually inferred) input type.

impl<'a, T> IntoIterator for &'a Erm<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Erm<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for Erm<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for Erm<T>

fn eq(&self, other: &Erm<T>) -> 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<T: Copy> Copy for Erm<T>

impl<T: Eq> Eq for Erm<T>

impl<T> StructuralPartialEq for Erm<T>