Enum Maybe 

pub enum Maybe<T> {
    Unspecified,
    Specified(T),
}

The Maybe type represents an optional that might or might not be specified.

An Option is deserialized as None if either the value is not specified or the value is null. Maybe allows us to distinguish between the two.

Examples

use s2_common::maybe::Maybe;

#[derive(Debug, PartialEq, Eq, serde::Deserialize)]
pub struct MyStruct {
    #[serde(default)]
    pub field: Maybe<Option<u32>>,
}

assert_eq!(
    MyStruct { field: Maybe::Unspecified },
    serde_json::from_str("{}").unwrap(),
);

assert_eq!(
    MyStruct { field: Maybe::Specified(None) },
    serde_json::from_str(r#"{ "field": null }"#).unwrap(),
);

assert_eq!(
    MyStruct { field: Maybe::Specified(Some(10)) },
    serde_json::from_str(r#"{ "field": 10 }"#).unwrap(),
);

Variants

Unspecified

Specified(T)

Implementations

impl<T> Maybe<T>

pub fn is_unspecified(&self) -> bool

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

where F: FnOnce(T) -> U,

pub fn unwrap_or_default(self) -> T

where T: Default,

impl<T> Maybe<Option<T>>

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

where F: FnOnce(T) -> U,

pub fn try_map_opt<U, E, F>(self, f: F) -> Result<Maybe<Option<U>>, E>

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

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

where T: Default,

Trait Implementations

impl<T: Clone> Clone for Maybe<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Maybe<T>

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

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<'de, T: Deserialize<'de>> Deserialize<'de> for Maybe<T>

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for Maybe<T>

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

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for Maybe<T>

impl<T> StructuralPartialEq for Maybe<T>