Struct Maybe 

pub struct Maybe<T, G = ()> { /* private fields */ }

Represents a type similar in spirit to the built-in Option type. Unlike Option however, Maybe does have in-place initializer support.

(In-place initializer support is impossible to provide for Option due to its enum nature, and because it is not marked with repr(transparent)).

Maybe is convertable to and from Option (via the From / Into traits), however these conversions are not recommended when the wrapped value is large which defeats the purpose of using Maybe in the first place.

The canonical way to use Maybe with large values is to initialize it in-place with one of the provided init constructors, and then use one of the as_ref, as_mut, as_deref and as_deref_mut methods to access the wrapped value.

Implementations

impl<T, G> Maybe<T, G>

pub fn new(value: Option<T>) -> Maybe<T, G>

Create a new Maybe value from an Option.

Note that when the wrapped value is large, it is recommended instead to use Maybe::init_none() and Maybe::init_some() to create the Maybe value in-place.

pub const fn none() -> Maybe<T, G>

Create a new, empty Maybe value.

pub const fn some(value: T) -> Maybe<T, G>

Create a new Maybe value with a wrapped value.

pub fn init_none() -> impl Init<Maybe<T, G>>

Create an in-place initializer for a Maybe value that is empty.

pub fn init_some<I, E>(value: I) -> impl Init<Maybe<T, G>, E>

where I: Init<T, E>,

Create an in-place initializer for a Maybe value that is not empty by initializing the wrapped value with the provided initializer.

pub fn init<I, E>(value: Option<I>) -> impl Init<Maybe<T, G>, E>

where I: Init<T, E>,

Create an in-place initializer for a Maybe value that might or might not be empty.

pub fn clear(&mut self)

Sets the Maybe value to “none”.

pub fn reinit<I>(&mut self, value: I)

where I: Init<Maybe<T, G>>,

Re-initialize the Maybe value with a new in-place initializer.

pub fn try_reinit<I, E>(&mut self, value: I) -> Result<(), E>

where I: Init<Maybe<T, G>, E>,

Try to re-initialize the Maybe value with a new in-place initializer.

If the re-initialization fails, the Maybe value is left to none.

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

Return a mutable reference to the wrapped value, if it exists.

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

Return a reference to the wrapped value, if it exists.

pub fn as_opt_mut(&mut self) -> Option<&mut T>

Return - as an Option - a mutable reference to the wrapped value, if it exists.

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

Return - as an Option - a reference to the wrapped value, if it exists.

pub fn as_deref(&self) -> Maybe<&<T as Deref>::Target, G>

where T: Deref,

Derefs the wrapped value, if it exists.

pub fn as_deref_mut(&mut self) -> Maybe<&mut <T as Deref>::Target, G>

where T: DerefMut,

Derefs mutably the wrapped value, if it exists.

pub fn as_opt_deref(&self) -> Option<&<T as Deref>::Target>

where T: Deref,

Derefs - as an Option - the wrapped value, if it exists.

pub fn as_opt_deref_mut(&mut self) -> Option<&mut <T as Deref>::Target>

where T: DerefMut,

Derefs - as an Option - mutably the wrapped value, if it exists.

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

Consume the Maybe value and return the wrapped value, if it exists.

Note that this method is not efficient when the wrapped value is large (might result in big stack memory usage due to moves), hence its usage is not recommended when the wrapped value is large.

pub fn is_none(&self) -> bool

Return whether the Maybe value is empty.

pub fn is_some(&self) -> bool

Return whether the Maybe value is not empty.

Trait Implementations

impl<T, G> Clone for Maybe<T, G>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, G> Debug for Maybe<T, G>

where T: Debug, G: Debug,

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

Formats the value using the given formatter.

impl<T, G> Default for Maybe<T, G>

fn default() -> Maybe<T, G>

Returns the “default value” for a type.

impl<T, G> Drop for Maybe<T, G>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T, G> Eq for Maybe<T, G>

where T: Eq,

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<'a, T> FromTLV<'a> for Maybe<T, AsNullable>

where T: FromTLV<'a>,

fn from_tlv(element: &TLVElement<'a>) -> Result<Maybe<T, AsNullable>, Error>

Deserialize the type from a TLV-encoded element.

fn init_from_tlv( element: TLVElement<'a>, ) -> impl Init<Maybe<T, AsNullable>, Error>

Generate an in-place initializer for the type that initializes the type from a TLV-encoded element.

fn nullable_from_tlv(element: &TLVElement<'a>) -> Result<Self, Error>

Deserialize the type from a TLV-encoded element.

fn init_nullable_from_tlv(element: TLVElement<'a>) -> impl Init<Self, Error>

Generate an in-place initializer for the type that initializes the type from a TLV-encoded element.

impl<'a, T> FromTLV<'a> for Maybe<T>

where T: FromTLV<'a> + 'a,

fn from_tlv(element: &TLVElement<'a>) -> Result<Maybe<T>, Error>

Deserialize the type from a TLV-encoded element.

fn init_from_tlv(element: TLVElement<'a>) -> impl Init<Maybe<T>, Error>

Generate an in-place initializer for the type that initializes the type from a TLV-encoded element.

fn nullable_from_tlv(element: &TLVElement<'a>) -> Result<Self, Error>

Deserialize the type from a TLV-encoded element.

fn init_nullable_from_tlv(element: TLVElement<'a>) -> impl Init<Self, Error>

Generate an in-place initializer for the type that initializes the type from a TLV-encoded element.

impl<T, G> Hash for Maybe<T, G>

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, G> PartialEq for Maybe<T, G>

where T: PartialEq,

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

Equality operator ==.

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

Inequality operator !=.

impl<T> ToTLV for Maybe<T, AsNullable>

where T: ToTLV,

fn to_tlv<W>(&self, tag: &TLVTag, tw: W) -> Result<(), Error>

where W: TLVWrite,

Serialize the type to a TLV-encoded stream.

fn tlv_iter(&self, tag: TLVTag) -> impl Iterator<Item = Result<TLV<'_>, Error>>

Serialize the type as an iterator of TLV instances by potentially borrowing data from the type.

fn nullable_to_tlv<W>(&self, tag: &TLVTag, tw: W) -> Result<(), Error>

where W: TLVWrite,

Serialize the type to a TLV-encoded stream.

fn nullable_tlv_iter( &self, tag: TLVTag, ) -> impl Iterator<Item = Result<TLV<'_>, Error>>

Serialize the type as an iterator of TLV instances by potentially borrowing data from the type.

impl<T> ToTLV for Maybe<T>

where T: ToTLV,

fn to_tlv<W>(&self, tag: &TLVTag, tw: W) -> Result<(), Error>

where W: TLVWrite,

Serialize the type to a TLV-encoded stream.

fn tlv_iter(&self, tag: TLVTag) -> impl Iterator<Item = Result<TLV<'_>, Error>>

Serialize the type as an iterator of TLV instances by potentially borrowing data from the type.

fn nullable_to_tlv<W>(&self, tag: &TLVTag, tw: W) -> Result<(), Error>

where W: TLVWrite,

Serialize the type to a TLV-encoded stream.

fn nullable_tlv_iter( &self, tag: TLVTag, ) -> impl Iterator<Item = Result<TLV<'_>, Error>>

Serialize the type as an iterator of TLV instances by potentially borrowing data from the type.