Struct Keep 

pub struct Keep<T>(pub T::Owning)
where
    T: ToOwning;

An Idempotent implementation which wraps a type that is already Owning.

Keep has an additional function outside of its use with Idempotent, which is that it implements Clone. Recall that all types which implement Clone have a blanket implementation of IntoOwning which is just the identity function. Contrapositively, therefore, any type with a non-trivial IntoOwning implementation cannot implement Clone. Usually, the conversion target of a struct’s or enum’s IntoOwning implementation is the same struct or enum with different generic parameters. You might wish to be able to clone such an object after it has already been converted into its owning form, but this is not possible because it breaks Rust’s rules about conflicting trait implementations. If you already know you have a type that IntoOwning (and therefore implements its supertrait ToOwning), then you can work around this by calling .to_owning() instead of .clone() and this will do the same thing. However, if you need to pass the object to something whose generic bounds require a Clone implementation, wrapping it with Keep can be a convenient solution.

Tuple Fields

0: T::Owning

Trait Implementations

impl<T> Clone for Keep<T>

where T: ToOwning, T::Owning: ToOwning<Owning = T::Owning>,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Keep<T>

where T: ToOwning + Debug, T::Owning: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Keep<T>

where T: ToOwning + Default, T::Owning: Default,

fn default() -> Keep<T>

Returns the “default value” for a type.

impl<T> Deref for Keep<T>

where T: ToOwning,

type Target = <T as ToOwning>::Owning

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for Keep<T>

where T: ToOwning,

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

Mutably dereferences the value.

impl<T> Hash for Keep<T>

where T: ToOwning + Hash, T::Owning: Hash,

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> Idempotent<T> for Keep<T>

where T: IntoOwning, T::Owning: ToOwning<Owning = T::Owning>,

fn to_ref(&self) -> IdemRef<'_, T>

Get a reference to either a T or a T::Owning.

fn to_mut(&mut self) -> IdemMut<'_, T>

Get a mutable reference to either a T or a T::Owning.

fn into_kept(self) -> T::Owning

Converts self into a T::Owning; equivalent to into_owning().0.

impl<T> Ord for Keep<T>

where T: ToOwning + Ord, T::Owning: Ord,

fn cmp(&self, other: &Keep<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for Keep<T>

where T: ToOwning + PartialEq, T::Owning: PartialEq,

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

where T: ToOwning + PartialOrd, T::Owning: PartialOrd,

fn partial_cmp(&self, other: &Keep<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Eq for Keep<T>

where T: ToOwning + Eq, T::Owning: Eq,

impl<T> StructuralPartialEq for Keep<T>

where T: ToOwning,