Enum MaybeOption 

pub enum MaybeOption<T> {
    Unset,
    None,
    Some(T),
}

Like an Option but with an additional Unset variant, that’s why it’s maybe an option.

This type is useful to disambiguate between absent values and those set explicitly to none/null.

Serde

Serializing requires to skip unset variants, and deserializing requires default:

#[serde(default, skip_serializing_if = "MaybeOption::is_unset")]

Variants

Unset

None

Some(T)

Implementations

impl<T> MaybeOption<T>

pub const fn is_unset(&self) -> bool

Returns true if the option is an Unset value.

Examples

let x: MaybeOption<u32> = MaybeOption::Unset;
assert_eq!(x.is_unset(), true);

let x: MaybeOption<u32> = MaybeOption::None;
assert_eq!(x.is_unset(), false);

pub const fn is_none(&self) -> bool

Returns true if the option is a None value.

Examples

let x: MaybeOption<u32> = MaybeOption::Some(2);
assert_eq!(x.is_none(), false);

let x: MaybeOption<u32> = MaybeOption::None;
assert_eq!(x.is_none(), true);

pub const fn is_some(&self) -> bool

Returns true if the option is a Some value.

Examples

let x: MaybeOption<u32> = MaybeOption::Some(2);
assert_eq!(x.is_some(), true);

let x: MaybeOption<u32> = MaybeOption::None;
assert_eq!(x.is_some(), false);

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

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

Examples

Calculates the length of an MaybeOption<String> as an MaybeOption<usize> without moving the String. The map method takes the self argument by value, consuming the original, so this technique uses as_ref to first take an MaybeOption to a reference to the value inside the original.

let text: MaybeOption<String> = MaybeOption::Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: MaybeOption<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {text:?}");

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

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

Examples

let mut x = MaybeOption::Some(2);
match x.as_mut() {
    MaybeOption::Some(v) => *v = 42,
    MaybeOption::None => {}
    MaybeOption::Unset => {}
}
assert_eq!(x, MaybeOption::Some(42));

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

where F: FnOnce(T) -> U,

Maps a MaybeOption<T> to MaybeOption<U> by applying a function to a contained value (if Some).

Examples

Calculates the length of an MaybeOption<String> as an MaybeOption<usize>, consuming the original:

let maybe_some_string = MaybeOption::Some(String::from("Hello, World!"));
// `Option::map` takes self *by value*, consuming `maybe_some_string`
let maybe_some_len = maybe_some_string.map(|s| s.len());
assert_eq!(maybe_some_len, MaybeOption::Some(13));

let x: MaybeOption<&str> = MaybeOption::None;
assert_eq!(x.map(|s| s.len()), MaybeOption::None);

let x: MaybeOption<&str> = MaybeOption::Unset;
assert_eq!(x.map(|s| s.len()), MaybeOption::Unset);

pub fn map_option<U, F: FnOnce(Option<T>) -> Option<U>>( self, f: F, ) -> MaybeOption<U>

Maps a MaybeOption<T> to MaybeOption<U> by applying a function to the contained nullable value

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

Converts this value into the double-option pattern

impl<T, E> MaybeOption<Result<T, E>>

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

Transposes a MaybeOption of a Result into a Result of a MaybeOption.

Trait Implementations

impl<T: Clone> Clone for MaybeOption<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for MaybeOption<T>

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

Formats the value using the given formatter.

impl<T> Default for MaybeOption<T>

fn default() -> MaybeOption<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for MaybeOption<T>

where T: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<MaybeOption<T>> for MaybeUndefined<T>

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

Converts to this type from the input type.

impl<T, U> From<MaybeOption<T>> for Option<Option<U>>

where U: From<T>,

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

Converts to this type from the input type.

impl<T> From<MaybeUndefined<T>> for MaybeOption<T>

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

Converts to this type from the input type.

impl<T, U> From<Option<Option<T>>> for MaybeOption<U>

where U: From<T>,

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

Converts to this type from the input type.

impl<T: Hash> Hash for MaybeOption<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: InputType> InputType for MaybeOption<T>

type RawValueType = <T as InputType>::RawValueType

The raw type used for validator.

fn type_name() -> Cow<'static, str>

Type the name.

fn qualified_type_name() -> String

Qualified typename.

fn create_type_info(registry: &mut Registry) -> String

Create type information in the registry and return qualified typename.

fn parse(value: Option<Value>) -> InputValueResult<Self>

Parse from Value. None represents undefined.

fn to_value(&self) -> Value

Convert to a Value for introspection.

fn as_raw_value(&self) -> Option<&Self::RawValueType>

Returns a reference to the raw value.

impl<T: PartialEq> PartialEq for MaybeOption<T>

fn eq(&self, other: &MaybeOption<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> Serialize for MaybeOption<T>

where T: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Copy> Copy for MaybeOption<T>

impl<T: Eq> Eq for MaybeOption<T>

impl<T> StructuralPartialEq for MaybeOption<T>