Enum Augmented 

pub enum Augmented<T, A: Clone> {
    Primary(T),
    WithAux(T, A),
}

An Augmented value is a generic wrapper that holds a primary value of type T and an optional auxiliary value of type A.

This is useful when a function needs to return a value that has some additional, optional context attached to it. For example, A can be used to override some of the fields of T without modifying T itself.

Variants

Primary(T)

The primary value, without any auxiliary data.

WithAux(T, A)

The primary value, with auxiliary data.

Implementations

impl<T, A: Clone> Augmented<T, A>

pub fn map<U>(self, f: impl FnOnce(T) -> U) -> Augmented<U, A>

Maps an Augmented<T, A> to an Augmented<U, A> by applying a function to the contained primary value, leaving the auxiliary value untouched.

pub fn extract(self) -> T

Extracts the primary value from the Augmented value, discarding the auxiliary value if it exists.

pub fn as_ref(&self) -> Augmented<&T, A>

Converts an Augmented<T, A> to an Augmented<&T, A>.

pub fn as_mut(&mut self) -> Augmented<&mut T, A>

Converts an Augmented<T, A> to an Augmented<&mut T, A>.

impl<T, A: Clone> Augmented<&mut T, A>

pub fn as_unmut(&self) -> Augmented<&T, A>

Converts an Augmented<&mut T, A> to an Augmented<&T, A>.

impl<T, A: Clone> Augmented<Option<T>, A>

pub fn transpose(self) -> Option<Augmented<T, A>>

Transposes an Augmented<Option<T>, A> into an Option<Augmented<T, A>>.

impl<T, A: Clone, E> Augmented<Result<T, E>, A>

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

Transposes an Augmented<Result<T, E>, A> into a Result<Augmented<T, A>, E>.

Trait Implementations

impl<T: Clone, A: Clone + Clone> Clone for Augmented<T, A>

fn clone(&self) -> Augmented<T, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, A: Debug + Clone> Debug for Augmented<T, A>

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

Formats the value using the given formatter.

impl<T, A: Clone> Deref for Augmented<T, A>

fn deref(&self) -> &Self::Target

Dereferences the Augmented value to the primary value.

type Target = T

The resulting type after dereferencing.

impl<T, A: Clone> DerefMut for Augmented<T, A>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the Augmented value to the primary value.

impl<T, A: Clone> From<T> for Augmented<T, A>

fn from(t: T) -> Self

Creates a Primary Augmented value from a primary value.

impl<T: PartialEq, A: PartialEq + Clone> PartialEq for Augmented<T, A>

fn eq(&self, other: &Augmented<T, A>) -> 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: Copy, A: Copy + Clone> Copy for Augmented<T, A>

impl<T: Eq, A: Eq + Clone> Eq for Augmented<T, A>

impl<T, A: Clone> StructuralPartialEq for Augmented<T, A>