Enum jumpy::prelude::Maybe

#[repr(C, u8)]
pub enum Maybe<T> {
    Unset,
    Set(T),
}

An equivalent to Option<T> that has a stable memory layout and implements HasSchema.

Variants

Unset

The value is not set.

Set(T)

The value is set.

Implementations

impl<T> Maybe<T>

pub fn option(self) -> Option<T>

Convert this Maybe into an Option.

pub fn is_set(&self) -> bool

Returns true if the option is a Set value.

pub fn is_unset(&self) -> bool

Returns true if the option is an Unset value.

pub fn is_some(&self) -> bool

Returns true if the option is a Set value.

pub fn is_none(&self) -> bool

Returns true if the option is an Unset value.

pub fn contains<U>(&self, x: &U) -> bool

where U: PartialEq<T>,

Returns true if the option is a Set value containing the given value.

pub fn as_ref(&self) -> Maybe<&T>

Converts from &Maybe<T> to Maybe<&T>.

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

Converts from &mut Maybe<T> to Maybe<&mut T>.

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

Returns the contained Set value, consuming the self value.

pub fn unwrap(self) -> T

Returns the contained Set value, consuming the self value.

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

Returns the contained Set value or a provided default.

pub fn unwrap_or_else<F>(self, f: F) -> T

where F: FnOnce() -> T,

Returns the contained Set value or computes it from a closure.

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

where F: FnOnce(T) -> U,

Maps a Maybe<T> to Maybe<U> by applying a function to a contained value.

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

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

Returns Unset if the option is Unset, otherwise calls f with the wrapped value and returns the result.

pub fn and<U>(self, optb: Maybe<U>) -> Maybe<U>

Returns Unset if the option is Unset, otherwise returns optb.

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

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

Returns Unset if the option is Unset, otherwise calls predicate with the wrapped value and returns:

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

Returns the option if it contains a value, otherwise returns optb.

pub fn or_else<F>(self, f: F) -> Maybe<T>

where F: FnOnce() -> Maybe<T>,

Returns the option if it contains a value, otherwise calls f and returns the result.

pub fn xor(self, optb: Maybe<T>) -> Maybe<T>

Returns Set if exactly one of self, optb is Set, otherwise returns Unset.

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

Inserts v into the option if it is Unset, then returns a mutable reference to the contained value.

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

where F: FnOnce() -> T,

Inserts a value computed from f into the option if it is Unset, then returns a mutable reference to the contained value.

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

Takes the value out of the option, leaving an Unset in its place.

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

Replaces the actual value in the option by the value given in parameter, returning the old value if present.

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

Zips self with another Maybe.

pub unsafe fn unwrap_unchecked(self) -> T

Returns the contained Set value, consuming the self value, without checking that the value is not Unset.

Safety

Calling this method on an Unset value is undefined behavior.

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

where F: FnOnce(T) -> U,

Maps a Maybe<T> to U by applying a function to a contained value, or returns a default.

pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U

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

Maps a Maybe<T> to U by applying a function to a contained value, or computes a default.

pub fn unwrap_or_default(self) -> T

where T: Default,

Returns the contained Set value or a default.

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

Transforms the Maybe<T> into a Result<T, E>, mapping Set(v) to Ok(v) and Unset to Err(err).

pub fn ok_or_else<E, F>(self, err: F) -> Result<T, E>

where F: FnOnce() -> E,

Transforms the Maybe<T> into a Result<T, E>, mapping Set(v) to Ok(v) and Unset to Err(err()).

Trait Implementations

impl<T> Clone for Maybe<T>

where T: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Maybe<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Maybe<T>

fn default() -> Maybe<T>

Returns the “default value” for a type.

impl<T> From<Maybe<T>> for Option<T>

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

Converts to this type from the input type.

impl<T> From<Option<T>> for Maybe<T>

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

Converts to this type from the input type.

impl<T> HasSchema for Maybe<T>

where T: HasSchema + Clone,

fn schema() -> &'static Schema

Get this type’s [Schema].

fn register_schema()

Register this schema with the global schema registry.

fn cast<T>(this: &Self) -> &T

where T: HasSchema,

Cast a reference of this type to a reference of another type with the same memory layout.

fn try_cast<T>(this: &Self) -> Result<&T, SchemaMismatchError>

where T: HasSchema,

Cast a reference of this type to a reference of another type with the same memory layout.

fn cast_mut<T>(this: &mut Self) -> &mut T

where T: HasSchema,

Cast a mutable reference of this type to a reference of another type with the same memory layout.

fn try_cast_mut<T>(this: &mut Self) -> Result<&mut T, SchemaMismatchError>

where T: HasSchema,

Cast a mutable reference of this type to a reference of another type with the same memory layout.

fn as_schema_ref(&self) -> SchemaRef<'_>

where Self: Sized,

Converts a reference of T to a SchemaRef

fn as_schema_mut(&mut self) -> SchemaRefMut<'_>

where Self: Sized,

Converts a reference of T to a SchemaRefMut

impl<T> Hash for Maybe<T>

where T: Hash,

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

where __H: Hasher,

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> Ord for Maybe<T>

where T: Ord,

fn cmp(&self, other: &Maybe<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T> PartialEq for Maybe<T>

where T: PartialEq,

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

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

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

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

impl<T> PartialOrd for Maybe<T>

where T: PartialOrd,

fn partial_cmp(&self, other: &Maybe<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Copy for Maybe<T>

where T: Copy,

impl<T> Eq for Maybe<T>

where T: Eq,

impl<T> StructuralPartialEq for Maybe<T>