Struct efficient_enum::option::EfficientOptionTuple

pub struct EfficientOptionTuple<A, B, TM = TagMSB>(_, _)
 where
    A: TaggableValue<TM, Two>;

An option type similar to (A, Option<B>), but where no extra data is used. Instead, some of the space in A is used to "tag the union".

The one true downside is that it is impossible to get &A from &EfficientOptionTuple. The reason for this is that doing so would expose the private tag info.

Methods

impl<TM, A, B> EfficientOptionTuple<A, B, TM> where
    A: TaggableValue<TM, Two>, 

fn new(a: A, b: Option<B>) -> Self

Constructs a new EfficientOptionTuple

fn none(a: A) -> Self

Constructs an EfficientOptionTuple with no B value

fn some(a: A, b: B) -> Self

Constructs an EfficientOptionTuple with a B value

fn destructure(self) -> (A, Option<B>)

Destructures an EfficientOptionTuple

fn destructure_0(self) -> A

Destructures an EfficientOptionTuple into the A value

fn destructure_1(self) -> Option<B>

Destructures an EfficientOptionTuple into the B value if one exists

unsafe fn unwrap_destructure(self) -> (A, B)

Destructures an EfficientOptionTuple by assuming the B values exists

unsafe fn unwrap_destructure_1(self) -> B

Destructures an EfficientOptionTupleinto the B value by assuming one exists

fn take_1(&mut self) -> Option<B>

Takes the B value out of the option, leaving a None in its place.

fn is_some(&self) -> bool

Returns true if the option is a Some value.

fn is_none(&self) -> bool

Returns true if the option is a None value.

fn inner(&mut self) -> EfficientOptionTupleInner<A, B, TM>

Returns an EfficientOptionTupleInnerSome if the option is a Some value, returns an EfficientOptionTupleInnerNone otherwise.

unsafe fn inner_some(&mut self) -> EfficientOptionTupleInnerSome<A, B, TM>

Returns an EfficientOptionTupleInnerSome.

unsafe fn inner_none(&mut self) -> EfficientOptionTupleInnerNone<A, B, TM>

Returns an EfficientOptionTupleInnerSome.

fn clone_0(&self) -> A where
    A: Clone, 

Clones the A value

fn clone_1(&self) -> Option<B> where
    B: Clone, 

Clones the B value if one exists

fn ref_1(&self) -> Option<&B>

Gets a reference to the B value if one exists

unsafe fn unwrap_ref_1(&self) -> &B

Gets a reference to the B value by assuming one exists

fn mut_1(&mut self) -> Option<&mut B>

Gets mutable a reference to the B value if one exists

unsafe fn unwrap_mut_1(&mut self) -> &mut B

Gets mutable a reference to the B value if one exists

fn replace_0(&mut self, a: A) -> A

Replaces the A value

fn replace_1(&mut self, b: Option<B>) -> Option<B>

Replaces the B value

fn map<R, F: FnOnce(&mut A, Option<&mut B>) -> R>(&mut self, f: F) -> R

Maps the A and B values to a result

Trait Implementations

impl<TM, A: Clone, B: Clone> Clone for EfficientOptionTuple<A, B, TM> where
    A: TaggableValue<TM, Two>, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<TM, A: Copy, B: Copy> Copy for EfficientOptionTuple<A, B, TM> where
    A: TaggableValue<TM, Two>, 

impl<TM, A: Default, B> Default for EfficientOptionTuple<A, B, TM> where
    A: TaggableValue<TM, Two>, 

fn default() -> Self

Returns the "default value" for a type.

impl<TM, A: Debug, B: Debug> Debug for EfficientOptionTuple<A, B, TM> where
    A: TaggableValue<TM, Two>, 

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

Formats the value using the given formatter.

impl<TM, A: PartialEq, B: PartialEq> PartialEq for EfficientOptionTuple<A, B, TM> where
    A: TaggableValue<TM, Two>, 

fn eq(&self, other: &Self) -> bool

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

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

This method tests for !=.

impl<TM, A: Eq, B: Eq> Eq for EfficientOptionTuple<A, B, TM> where
    A: TaggableValue<TM, Two>, 

impl<TM, A: Hash, B: Hash> Hash for EfficientOptionTuple<A, B, TM> where
    A: TaggableValue<TM, Two>, 

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, 

Feeds a slice of this type into the given [Hasher].

impl<TM, A, B> From<(A, Option<B>)> for EfficientOptionTuple<A, B, TM> where
    A: TaggableValue<TM, Two>, 

fn from((a, b): (A, Option<B>)) -> Self

Performs the conversion.

impl<TM, A, B> Into<(A, Option<B>)> for EfficientOptionTuple<A, B, TM> where
    A: TaggableValue<TM, Two>, 

fn into(self) -> (A, Option<B>)

Performs the conversion.