Struct yoke::trait_hack::YokeTraitHack

#[repr(transparent)]
pub struct YokeTraitHack<T>(pub T);

A wrapper around a type T, forwarding trait calls down to the inner type.

YokeTraitHack supports Clone, PartialEq, Eq, and serde::Deserialize out of the box. Other traits can be implemented by the caller.

For more information, see the module-level documentation.

Example

Using YokeTraitHack as a type bound in a function comparing two Yokes:

use yoke::trait_hack::YokeTraitHack;
use yoke::*;

fn compare_yokes<Y, C1, C2>(y1: Yoke<Y, C1>, y2: Yoke<Y, C2>) -> bool
where
    Y: for<'a> Yokeable<'a>,
    for<'a> YokeTraitHack<<Y as Yokeable<'a>>::Output>: PartialEq,
{
    YokeTraitHack(y1.get()).into_ref() == YokeTraitHack(y2.get()).into_ref()
}

Tuple Fields

0: T

Implementations

impl<'a, T> YokeTraitHack<&'a T>

pub fn into_ref(self) -> &'a YokeTraitHack<T>

Converts from YokeTraitHack<&T> to &YokeTraitHack<T>.

This is safe because YokeTraitHack is repr(transparent).

This method is required to implement Clone on Yoke.

Trait Implementations

impl<T: Clone> Clone for YokeTraitHack<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for YokeTraitHack<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for YokeTraitHack<T>where T: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq> PartialEq for YokeTraitHack<T>

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'zf, C: ?Sized, T> ZeroFrom<'zf, C> for YokeTraitHack<T>where T: ZeroFrom<'zf, C>,

fn zero_from(cart: &'zf C) -> Self

Clone the other C into a struct that may retain references into C.

impl<T: Eq> Eq for YokeTraitHack<T>

impl<T> StructuralEq for YokeTraitHack<T>

impl<T> StructuralPartialEq for YokeTraitHack<T>