Enum Known 

pub enum Known<T> {
    Known(T),
    Unknown,
}

A value that may not exist yet.

The point of a dedicated type is that Unknown cannot be mistaken for a zero or an empty string once it reaches a comparison. Combining anything with Unknown yields Unknown.

Variants

Known(T)

The value was produced.

Unknown

The value was not produced.

Implementations

impl<T> Known<T>

pub fn is_known(&self) -> bool

Whether a value is present.

pub fn get(&self) -> Option<&T>

Borrow the value if present.

pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Known<U>

Map the value, keeping Unknown unknown.

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

Combine two values; if either is unknown the result is unknown.

use gate_contract::Known;
let a = Known::Known(2);
let b: Known<i32> = Known::Unknown;
assert_eq!(a.zip_with(b, |x, y| x + y), Known::Unknown);

Trait Implementations

impl<T: Clone> Clone for Known<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for Known<T>

impl<T: Debug> Debug for Known<T>

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

Formats the value using the given formatter.

impl<T> Default for Known<T>

fn default() -> Known<T>

Returns the “default value” for a type.

impl<T: Eq> Eq for Known<T>

impl<T> From<Option<T>> for Known<T>

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

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for Known<T>

fn eq(&self, other: &Known<T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialEq> StructuralPartialEq for Known<T>