Trait Yokeable

pub unsafe trait Yokeable<'a>: 'static {
    type Output: 'a;

    // Required methods
    fn transform(&'a self) -> &'a Self::Output;
    fn transform_owned(self) -> Self::Output;
    unsafe fn make(from: Self::Output) -> Self;
    fn transform_mut<F>(&'a mut self, f: F)
       where F: 'static + for<'b> FnOnce(&'b mut Self::Output);
}

The Yokeable<'a> trait is implemented on the 'static version of any zero-copy type; for example, Cow<'static, T> implements Yokeable<'a> (for all 'a).

One can use Yokeable::Output on this trait to obtain the “lifetime’d” value of the Cow<'static, T>, e.g. <Cow<'static, T> as Yokeable<'a>'>::Output is Cow<'a, T>.

A Yokeable type is essentially one with a covariant lifetime parameter, matched to the parameter in the trait definition. The trait allows one to cast the covariant lifetime to and from 'static.

Most of the time, if you need to implement Yokeable, you should be able to use the safe #[derive(Yokeable)] custom derive.

While Rust does not yet have GAT syntax, for the purpose of this documentation we shall refer to “Self with a lifetime 'a” with the syntax Self<'a>. Self<‘static> is a stand-in for the HKT Self<’_>: lifetime -> type.

With this terminology, Yokeable exposes ways to cast between Self<'static> and Self<'a> generically. This is useful for turning covariant lifetimes to dynamic lifetimes, where 'static is used as a way to “erase” the lifetime.

Safety

This trait is safe to implement on types with a covariant lifetime parameter, i.e. one where Self::transform()’s body can simply be { self }. This will occur when the lifetime parameter is used within references, but not in the arguments of function pointers or in mutable positions (either in &mut or via interior mutability)

This trait must be implemented on the 'static version of such a type, e.g. one should implement Yokeable<'a> (for all 'a) on Cow<'static, T>.

This trait is also safe to implement on types that do not borrow memory.

There are further constraints on implementation safety on individual methods.

Implementation example

Implementing this trait manually is unsafe. Where possible, you should use the safe #[derive(Yokeable)] custom derive instead. We include an example in case you have your own zero-copy abstractions you wish to make yokeable.

struct Bar<'a> {
    numbers: Cow<'a, [u8]>,
    string: Cow<'a, str>,
    owned: Vec<u8>,
}

unsafe impl<'a> Yokeable<'a> for Bar<'static> {
    type Output = Bar<'a>;
    fn transform(&'a self) -> &'a Bar<'a> {
        // covariant lifetime cast, can be done safely
        self
    }

    fn transform_owned(self) -> Bar<'a> {
        // covariant lifetime cast, can be done safely
        self
    }

    unsafe fn make(from: Bar<'a>) -> Self {
        // We're just doing mem::transmute() here, however Rust is
        // not smart enough to realize that Bar<'a> and Bar<'static> are of
        // the same size, so instead we use transmute_copy

        // This assert will be optimized out, but is included for additional
        // peace of mind as we are using transmute_copy
        debug_assert!(mem::size_of::<Bar<'a>>() == mem::size_of::<Self>());
        let ptr: *const Self = (&from as *const Self::Output).cast();
        mem::forget(from);
        ptr::read(ptr)
    }

    fn transform_mut<F>(&'a mut self, f: F)
    where
        F: 'static + FnOnce(&'a mut Self::Output),
    {
        unsafe { f(mem::transmute::<&mut Self, &mut Self::Output>(self)) }
    }
}

Required Associated Types

type Output: 'a

This type MUST be Self with the 'static replaced with 'a, i.e. Self<'a>

Required Methods

fn transform(&'a self) -> &'a Self::Output

This method must cast self between &'a Self<'static> and &'a Self<'a>.

Implementation safety

If the invariants of Yokeable are being satisfied, the body of this method should simply be { self }, though it’s acceptable to include additional assertions if desired.

fn transform_owned(self) -> Self::Output

This method must cast self between Self<'static> and Self<'a>.

Implementation safety

If the invariants of Yokeable are being satisfied, the body of this method should simply be { self }, though it’s acceptable to include additional assertions if desired.

unsafe fn make(from: Self::Output) -> Self

This method can be used to cast away Self<'a>’s lifetime.

Safety

The returned value must be destroyed before the data from was borrowing from is.

Implementation safety

A safe implementation of this method must be equivalent to a transmute between Self<'a> and Self<'static>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut Self::Output),

This method must cast self between &'a mut Self<'static> and &'a mut Self<'a>, and pass it to f.

Implementation safety

A safe implementation of this method must be equivalent to a pointer cast/transmute between &mut Self<'a> and &mut Self<'static> being passed to f

Why is this safe?

Typically covariant lifetimes become invariant when hidden behind an &mut, which is why the implementation of this method cannot just be f(self). The reason behind this is that while reading a covariant lifetime that has been cast to a shorter one is always safe (this is roughly the definition of a covariant lifetime), writing may not necessarily be safe since you could write a smaller reference to it. For example, the following code is unsound because it manages to stuff a 'a lifetime into a Cow<'static>

struct Foo {
    str: String,
    cow: Cow<'static, str>,
}

fn unsound<'a>(foo: &'a mut Foo) {
    let a: &str = &foo.str;
    foo.cow.transform_mut(|cow| *cow = Cow::Borrowed(a));
}

However, this code will not compile because Yokeable::transform_mut() requires F: 'static. This enforces that while F may mutate Self<'a>, it can only mutate it in a way that does not insert additional references. For example, F may call to_owned() on a Cow and mutate it, but it cannot insert a new borrowed reference because it has nowhere to borrow from – f does not contain any borrowed references, and while we give it Self<'a> (which contains borrowed data), that borrowed data is known to be valid

Note that the for<'b> is also necessary, otherwise the following code would compile:

// also safely implements Yokeable<'a>
struct Bar<'a> {
    num: u8,
    cow: Cow<'a, u8>,
}

fn unsound<'a>(bar: &'a mut Bar<'static>) {
    bar.transform_mut(move |bar| bar.cow = Cow::Borrowed(&bar.num));
}

which is unsound because bar could be moved later, and we do not want to be able to self-insert references to it.

The for<'b> enforces this by stopping the author of the closure from matching up the input &'b Self::Output lifetime with 'a and borrowing directly from it.

Thus the only types of mutations allowed are ones that move around already-borrowed data, or introduce new owned data:

struct Foo {
    str: String,
    cow: Cow<'static, str>,
}

fn sound<'a>(foo: &'a mut Foo) {
    foo.cow.transform_mut(move |cow| cow.to_mut().push('a'));
}

More formally, a reference to an object that f assigns to a reference in Self<’a> could be obtained from:

• a local variable: the compiler rejects the assignment because ’a certainly outlives local variables in f.
• a field in its argument: because of the for<’b> bound, the call to f must be valid for a particular ’b that is strictly shorter than ’a. Thus, the compiler rejects the assignment.
• a reference field in Self<’a>: this does not extend the set of non-static lifetimes reachable from Self<’a>, so this is fine.
• one of f’s captures: since F: ’static, the resulting reference must refer to ’static data.
• a static or thread_local variable: ditto.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a> Yokeable<'a> for bool

type Output = bool

fn transform(&self) -> &<bool as Yokeable<'a>>::Output

fn transform_owned(self) -> <bool as Yokeable<'a>>::Output

unsafe fn make(this: <bool as Yokeable<'a>>::Output) -> bool

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <bool as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for char

type Output = char

fn transform(&self) -> &<char as Yokeable<'a>>::Output

fn transform_owned(self) -> <char as Yokeable<'a>>::Output

unsafe fn make(this: <char as Yokeable<'a>>::Output) -> char

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <char as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for i8

type Output = i8

fn transform(&self) -> &<i8 as Yokeable<'a>>::Output

fn transform_owned(self) -> <i8 as Yokeable<'a>>::Output

unsafe fn make(this: <i8 as Yokeable<'a>>::Output) -> i8

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <i8 as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for i16

type Output = i16

fn transform(&self) -> &<i16 as Yokeable<'a>>::Output

fn transform_owned(self) -> <i16 as Yokeable<'a>>::Output

unsafe fn make(this: <i16 as Yokeable<'a>>::Output) -> i16

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <i16 as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for i32

type Output = i32

fn transform(&self) -> &<i32 as Yokeable<'a>>::Output

fn transform_owned(self) -> <i32 as Yokeable<'a>>::Output

unsafe fn make(this: <i32 as Yokeable<'a>>::Output) -> i32

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <i32 as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for i64

type Output = i64

fn transform(&self) -> &<i64 as Yokeable<'a>>::Output

fn transform_owned(self) -> <i64 as Yokeable<'a>>::Output

unsafe fn make(this: <i64 as Yokeable<'a>>::Output) -> i64

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <i64 as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for i128

type Output = i128

fn transform(&self) -> &<i128 as Yokeable<'a>>::Output

fn transform_owned(self) -> <i128 as Yokeable<'a>>::Output

unsafe fn make(this: <i128 as Yokeable<'a>>::Output) -> i128

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <i128 as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for isize

type Output = isize

fn transform(&self) -> &<isize as Yokeable<'a>>::Output

fn transform_owned(self) -> <isize as Yokeable<'a>>::Output

unsafe fn make(this: <isize as Yokeable<'a>>::Output) -> isize

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <isize as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for u8

type Output = u8

fn transform(&self) -> &<u8 as Yokeable<'a>>::Output

fn transform_owned(self) -> <u8 as Yokeable<'a>>::Output

unsafe fn make(this: <u8 as Yokeable<'a>>::Output) -> u8

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <u8 as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for u16

type Output = u16

fn transform(&self) -> &<u16 as Yokeable<'a>>::Output

fn transform_owned(self) -> <u16 as Yokeable<'a>>::Output

unsafe fn make(this: <u16 as Yokeable<'a>>::Output) -> u16

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <u16 as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for u32

type Output = u32

fn transform(&self) -> &<u32 as Yokeable<'a>>::Output

fn transform_owned(self) -> <u32 as Yokeable<'a>>::Output

unsafe fn make(this: <u32 as Yokeable<'a>>::Output) -> u32

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <u32 as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for u64

type Output = u64

fn transform(&self) -> &<u64 as Yokeable<'a>>::Output

fn transform_owned(self) -> <u64 as Yokeable<'a>>::Output

unsafe fn make(this: <u64 as Yokeable<'a>>::Output) -> u64

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <u64 as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for u128

type Output = u128

fn transform(&self) -> &<u128 as Yokeable<'a>>::Output

fn transform_owned(self) -> <u128 as Yokeable<'a>>::Output

unsafe fn make(this: <u128 as Yokeable<'a>>::Output) -> u128

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <u128 as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for ()

type Output = ()

fn transform(&self) -> &<() as Yokeable<'a>>::Output

fn transform_owned(self) -> <() as Yokeable<'a>>::Output

unsafe fn make(this: <() as Yokeable<'a>>::Output)

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <() as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for usize

type Output = usize

fn transform(&self) -> &<usize as Yokeable<'a>>::Output

fn transform_owned(self) -> <usize as Yokeable<'a>>::Output

unsafe fn make(this: <usize as Yokeable<'a>>::Output) -> usize

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <usize as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for ExportBox

where ExportBox: Sized,

type Output = ExportBox

fn transform(&self) -> &<ExportBox as Yokeable<'a>>::Output

fn transform_owned(self) -> <ExportBox as Yokeable<'a>>::Output

unsafe fn make(this: <ExportBox as Yokeable<'a>>::Output) -> ExportBox

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <ExportBox as Yokeable<'a>>::Output),

impl<'a> Yokeable<'a> for HelloWorld<'static>

type Output = HelloWorld<'a>

fn transform(&'a self) -> &'a <HelloWorld<'static> as Yokeable<'a>>::Output

fn transform_owned(self) -> <HelloWorld<'static> as Yokeable<'a>>::Output

unsafe fn make( this: <HelloWorld<'static> as Yokeable<'a>>::Output, ) -> HelloWorld<'static>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <HelloWorld<'static> as Yokeable<'a>>::Output),

impl<'a, K0, K1, V> Yokeable<'a> for ZeroMap2d<'static, K0, K1, V>

where K0: 'static + for<'b> ZeroMapKV<'b> + ?Sized, K1: 'static + for<'b> ZeroMapKV<'b> + ?Sized, V: 'static + for<'b> ZeroMapKV<'b> + ?Sized, <K0 as ZeroMapKV<'static>>::Container: for<'b> Yokeable<'b>, <K1 as ZeroMapKV<'static>>::Container: for<'b> Yokeable<'b>, <V as ZeroMapKV<'static>>::Container: for<'b> Yokeable<'b>,

This impl requires enabling the optional yoke Cargo feature of the zerovec crate

type Output = ZeroMap2d<'a, K0, K1, V>

fn transform( &'a self, ) -> &'a <ZeroMap2d<'static, K0, K1, V> as Yokeable<'a>>::Output

fn transform_owned( self, ) -> <ZeroMap2d<'static, K0, K1, V> as Yokeable<'a>>::Output

unsafe fn make( from: <ZeroMap2d<'static, K0, K1, V> as Yokeable<'a>>::Output, ) -> ZeroMap2d<'static, K0, K1, V>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <ZeroMap2d<'static, K0, K1, V> as Yokeable<'a>>::Output),

impl<'a, K0, K1, V> Yokeable<'a> for ZeroMap2dBorrowed<'static, K0, K1, V>

where K0: 'static + for<'b> ZeroMapKV<'b> + ?Sized, K1: 'static + for<'b> ZeroMapKV<'b> + ?Sized, V: 'static + for<'b> ZeroMapKV<'b> + ?Sized, &'static <K0 as ZeroMapKV<'static>>::Slice: for<'b> Yokeable<'b>, &'static <K1 as ZeroMapKV<'static>>::Slice: for<'b> Yokeable<'b>, &'static <V as ZeroMapKV<'static>>::Slice: for<'b> Yokeable<'b>,

This impl requires enabling the optional yoke Cargo feature of the zerovec crate

type Output = ZeroMap2dBorrowed<'a, K0, K1, V>

fn transform( &'a self, ) -> &'a <ZeroMap2dBorrowed<'static, K0, K1, V> as Yokeable<'a>>::Output

fn transform_owned( self, ) -> <ZeroMap2dBorrowed<'static, K0, K1, V> as Yokeable<'a>>::Output

unsafe fn make( from: <ZeroMap2dBorrowed<'static, K0, K1, V> as Yokeable<'a>>::Output, ) -> ZeroMap2dBorrowed<'static, K0, K1, V>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <ZeroMap2dBorrowed<'static, K0, K1, V> as Yokeable<'a>>::Output),

impl<'a, K, V> Yokeable<'a> for ZeroMap<'static, K, V>

where K: 'static + for<'b> ZeroMapKV<'b> + ?Sized, V: 'static + for<'b> ZeroMapKV<'b> + ?Sized, <K as ZeroMapKV<'static>>::Container: for<'b> Yokeable<'b>, <V as ZeroMapKV<'static>>::Container: for<'b> Yokeable<'b>,

This impl requires enabling the optional yoke Cargo feature of the zerovec crate

type Output = ZeroMap<'a, K, V>

fn transform(&'a self) -> &'a <ZeroMap<'static, K, V> as Yokeable<'a>>::Output

fn transform_owned(self) -> <ZeroMap<'static, K, V> as Yokeable<'a>>::Output

unsafe fn make( from: <ZeroMap<'static, K, V> as Yokeable<'a>>::Output, ) -> ZeroMap<'static, K, V>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <ZeroMap<'static, K, V> as Yokeable<'a>>::Output),

impl<'a, K, V> Yokeable<'a> for ZeroMapBorrowed<'static, K, V>

where K: 'static + for<'b> ZeroMapKV<'b> + ?Sized, V: 'static + for<'b> ZeroMapKV<'b> + ?Sized, &'static <K as ZeroMapKV<'static>>::Slice: for<'b> Yokeable<'b>, &'static <V as ZeroMapKV<'static>>::Slice: for<'b> Yokeable<'b>,

This impl requires enabling the optional yoke Cargo feature of the zerovec crate

type Output = ZeroMapBorrowed<'a, K, V>

fn transform( &'a self, ) -> &'a <ZeroMapBorrowed<'static, K, V> as Yokeable<'a>>::Output

fn transform_owned( self, ) -> <ZeroMapBorrowed<'static, K, V> as Yokeable<'a>>::Output

unsafe fn make( from: <ZeroMapBorrowed<'static, K, V> as Yokeable<'a>>::Output, ) -> ZeroMapBorrowed<'static, K, V>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <ZeroMapBorrowed<'static, K, V> as Yokeable<'a>>::Output),

impl<'a, K, V, S> Yokeable<'a> for LiteMap<K, V, S>

where K: 'static + ?Sized, V: 'static + ?Sized, S: 'static, LiteMap<K, V, S>: Sized,

type Output = LiteMap<K, V, S>

fn transform(&self) -> &<LiteMap<K, V, S> as Yokeable<'a>>::Output

fn transform_owned(self) -> <LiteMap<K, V, S> as Yokeable<'a>>::Output

unsafe fn make( this: <LiteMap<K, V, S> as Yokeable<'a>>::Output, ) -> LiteMap<K, V, S>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <LiteMap<K, V, S> as Yokeable<'a>>::Output),

impl<'a, Store> Yokeable<'a> for ZeroTrie<Store>

where Store: 'static, ZeroTrie<Store>: Sized,

type Output = ZeroTrie<Store>

fn transform(&self) -> &<ZeroTrie<Store> as Yokeable<'a>>::Output

fn transform_owned(self) -> <ZeroTrie<Store> as Yokeable<'a>>::Output

unsafe fn make( this: <ZeroTrie<Store> as Yokeable<'a>>::Output, ) -> ZeroTrie<Store>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <ZeroTrie<Store> as Yokeable<'a>>::Output),

impl<'a, T1, T2> Yokeable<'a> for (T1, T2)

where T1: 'static + for<'b> Yokeable<'b>, T2: 'static + for<'b> Yokeable<'b>,

type Output = (<T1 as Yokeable<'a>>::Output, <T2 as Yokeable<'a>>::Output)

fn transform(&'a self) -> &'a <(T1, T2) as Yokeable<'a>>::Output

fn transform_owned(self) -> <(T1, T2) as Yokeable<'a>>::Output

unsafe fn make(from: <(T1, T2) as Yokeable<'a>>::Output) -> (T1, T2)

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <(T1, T2) as Yokeable<'a>>::Output),

impl<'a, T> Yokeable<'a> for Cow<'static, T>

where T: 'static + ToOwned + ?Sized, <T as ToOwned>::Owned: Sized,

type Output = Cow<'a, T>

fn transform(&'a self) -> &'a Cow<'a, T>

fn transform_owned(self) -> Cow<'a, T>

unsafe fn make(from: Cow<'a, T>) -> Cow<'static, T>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <Cow<'static, T> as Yokeable<'a>>::Output),

impl<'a, T> Yokeable<'a> for Option<T>

where T: 'static + for<'b> Yokeable<'b>,

type Output = Option<<T as Yokeable<'a>>::Output>

fn transform(&'a self) -> &'a <Option<T> as Yokeable<'a>>::Output

fn transform_owned(self) -> <Option<T> as Yokeable<'a>>::Output

unsafe fn make(from: <Option<T> as Yokeable<'a>>::Output) -> Option<T>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <Option<T> as Yokeable<'a>>::Output),

impl<'a, T> Yokeable<'a> for &'static T

where T: 'static + ?Sized,

type Output = &'a T

fn transform(&'a self) -> &'a &'a T

fn transform_owned(self) -> &'a T

unsafe fn make(from: &'a T) -> &'static T

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <&'static T as Yokeable<'a>>::Output),

impl<'a, T> Yokeable<'a> for Vec<T>

where T: 'static,

type Output = Vec<T>

fn transform(&'a self) -> &'a Vec<T>

fn transform_owned(self) -> Vec<T>

unsafe fn make(from: Vec<T>) -> Vec<T>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <Vec<T> as Yokeable<'a>>::Output),

impl<'a, T> Yokeable<'a> for PhantomData<T>

where T: 'static + ?Sized,

type Output = PhantomData<T>

fn transform(&'a self) -> &'a <PhantomData<T> as Yokeable<'a>>::Output

fn transform_owned(self) -> <PhantomData<T> as Yokeable<'a>>::Output

unsafe fn make(from: <PhantomData<T> as Yokeable<'a>>::Output) -> PhantomData<T>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <PhantomData<T> as Yokeable<'a>>::Output),

impl<'a, T> Yokeable<'a> for VarZeroCow<'static, T>

where T: 'static + ?Sized,

This impl requires enabling the optional yoke Cargo feature of the zerovec crate

type Output = VarZeroCow<'a, T>

fn transform(&'a self) -> &'a <VarZeroCow<'static, T> as Yokeable<'a>>::Output

fn transform_owned(self) -> <VarZeroCow<'static, T> as Yokeable<'a>>::Output

unsafe fn make( from: <VarZeroCow<'static, T> as Yokeable<'a>>::Output, ) -> VarZeroCow<'static, T>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <VarZeroCow<'static, T> as Yokeable<'a>>::Output),

impl<'a, T> Yokeable<'a> for VarZeroVec<'static, T>

where T: 'static + VarULE + ?Sized,

This impl requires enabling the optional yoke Cargo feature of the zerovec crate

type Output = VarZeroVec<'a, T>

fn transform(&'a self) -> &'a <VarZeroVec<'static, T> as Yokeable<'a>>::Output

fn transform_owned(self) -> <VarZeroVec<'static, T> as Yokeable<'a>>::Output

unsafe fn make( from: <VarZeroVec<'static, T> as Yokeable<'a>>::Output, ) -> VarZeroVec<'static, T>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <VarZeroVec<'static, T> as Yokeable<'a>>::Output),

impl<'a, T> Yokeable<'a> for ZeroVec<'static, T>

where T: 'static + AsULE,

This impl requires enabling the optional yoke Cargo feature of the zerovec crate

type Output = ZeroVec<'a, T>

fn transform(&'a self) -> &'a <ZeroVec<'static, T> as Yokeable<'a>>::Output

fn transform_owned(self) -> <ZeroVec<'static, T> as Yokeable<'a>>::Output

unsafe fn make( from: <ZeroVec<'static, T> as Yokeable<'a>>::Output, ) -> ZeroVec<'static, T>

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <ZeroVec<'static, T> as Yokeable<'a>>::Output),

impl<'a, T, const N: usize> Yokeable<'a> for [T; N]

where T: 'static + for<'b> Yokeable<'b>,

type Output = [<T as Yokeable<'a>>::Output; N]

fn transform(&'a self) -> &'a <[T; N] as Yokeable<'a>>::Output

fn transform_owned(self) -> <[T; N] as Yokeable<'a>>::Output

unsafe fn make(from: <[T; N] as Yokeable<'a>>::Output) -> [T; N]

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <[T; N] as Yokeable<'a>>::Output),

Implementors

impl<'a> Yokeable<'a> for ChineseBasedCache<'static>

impl<'a> Yokeable<'a> for HijriCache<'static>

impl<'a> Yokeable<'a> for EraStartDate

where Self: Sized,

impl<'a> Yokeable<'a> for JapaneseEras<'static>

impl<'a> Yokeable<'a> for WeekData

where Self: Sized,

impl<'a> Yokeable<'a> for CaseMapExceptions<'static>

impl<'a> Yokeable<'a> for CaseMap<'static>

impl<'a> Yokeable<'a> for CaseMapUnfold<'static>

impl<'a> Yokeable<'a> for CollationData<'static>

impl<'a> Yokeable<'a> for CollationDiacritics<'static>

impl<'a> Yokeable<'a> for CollationJamo<'static>

impl<'a> Yokeable<'a> for CollationMetadata

where Self: Sized,

impl<'a> Yokeable<'a> for CollationReordering<'static>

impl<'a> Yokeable<'a> for CollationSpecialPrimaries<'static>

impl<'a> Yokeable<'a> for CodePointInversionList<'static>

impl<'a> Yokeable<'a> for CodePointInversionListAndStringList<'static>

impl<'a> Yokeable<'a> for CodePointTrieHeader

where Self: Sized,

impl<'a, T> Yokeable<'a> for CodePointTrie<'static, T>

where T: 'static + TrieValue,

impl<'a> Yokeable<'a> for Symbols<'static>

impl<'a> Yokeable<'a> for Day

where Self: Sized,

impl<'a> Yokeable<'a> for DayPeriod

where Self: Sized,

impl<'a> Yokeable<'a> for DecimalSecond

where Self: Sized,

impl<'a> Yokeable<'a> for Hour

where Self: Sized,

impl<'a> Yokeable<'a> for Month

where Self: Sized,

impl<'a> Yokeable<'a> for Second

where Self: Sized,

impl<'a> Yokeable<'a> for TimeZone

where Self: Sized,

impl<'a> Yokeable<'a> for Week

where Self: Sized,

impl<'a> Yokeable<'a> for Weekday

where Self: Sized,

impl<'a> Yokeable<'a> for Year

where Self: Sized,

impl<'a> Yokeable<'a> for MonthNames<'static>

impl<'a> Yokeable<'a> for YearNames<'static>

impl<'a> Yokeable<'a> for CoarseHourCycle

where Self: Sized,

impl<'a> Yokeable<'a> for TimeGranularity

where Self: Sized,

impl<'a> Yokeable<'a> for PatternPlurals<'static>

impl<'a> Yokeable<'a> for Contexts<'static>

impl<'a> Yokeable<'a> for FormatWidths<'static>

impl<'a> Yokeable<'a> for StandAloneWidths<'static>

impl<'a> Yokeable<'a> for Symbols<'static>

impl<'a> Yokeable<'a> for Contexts<'static>

impl<'a> Yokeable<'a> for FormatWidths<'static>

impl<'a> Yokeable<'a> for StandAloneWidths<'static>

impl<'a> Yokeable<'a> for GenericLengthPatterns<'static>

impl<'a> Yokeable<'a> for LengthPatterns<'static>

impl<'a> Yokeable<'a> for DateLengths<'static>

impl<'a> Yokeable<'a> for DateSymbols<'static>

impl<'a> Yokeable<'a> for Eras<'static>

impl<'a> Yokeable<'a> for TimeLengths<'static>

impl<'a> Yokeable<'a> for TimeSymbols<'static>

impl<'a> Yokeable<'a> for Contexts<'static>

impl<'a> Yokeable<'a> for FormatWidths<'static>

impl<'a> Yokeable<'a> for StandAloneWidths<'static>

impl<'a> Yokeable<'a> for Symbols<'static>

impl<'a> Yokeable<'a> for DateTimeSkeletons<'static>

impl<'a> Yokeable<'a> for GluePattern<'static>

impl<'a> Yokeable<'a> for LinearNames<'static>

impl<'a> Yokeable<'a> for GenericPattern<'static>

impl<'a> Yokeable<'a> for Pattern<'static>

impl<'a> Yokeable<'a> for PluralPattern<'static>

impl<'a> Yokeable<'a> for PackedPatterns<'static>

impl<'a> Yokeable<'a> for ExemplarCities<'static>

impl<'a> Yokeable<'a> for Locations<'static>

impl<'a> Yokeable<'a> for MetazoneGenericNames<'static>

impl<'a> Yokeable<'a> for MetazonePeriod<'static>

impl<'a> Yokeable<'a> for MetazoneSpecificNames<'static>

impl<'a> Yokeable<'a> for TimeZoneEssentials<'static>

impl<'a> Yokeable<'a> for DecimalSymbolStrsBuilder<'static>

impl<'a> Yokeable<'a> for DecimalSymbols<'static>

impl<'a> Yokeable<'a> for GroupingSizes

where Self: Sized,

impl<'a> Yokeable<'a> for CompactDecimalPatternData<'static>

impl<'a> Yokeable<'a> for Pattern<'static>

impl<'a> Yokeable<'a> for CurrencyEssentials<'static>

impl<'a> Yokeable<'a> for ShortCurrencyCompact<'static>

impl<'a> Yokeable<'a> for CurrencyDisplayname<'static>

impl<'a> Yokeable<'a> for CurrencyPatternsData<'static>

impl<'a> Yokeable<'a> for CurrencyExtendedData<'static>

impl<'a> Yokeable<'a> for PercentEssentials<'static>

impl<'a> Yokeable<'a> for UnitsDisplayName<'static>

impl<'a> Yokeable<'a> for UnitsEssentials<'static>

impl<'a> Yokeable<'a> for LanguageDisplayNames<'static>

impl<'a> Yokeable<'a> for LocaleDisplayNames<'static>

impl<'a> Yokeable<'a> for RegionDisplayNames<'static>

impl<'a> Yokeable<'a> for ScriptDisplayNames<'static>

impl<'a> Yokeable<'a> for VariantDisplayNames<'static>

impl<'a> Yokeable<'a> for DigitalDurationData<'static>

impl<'a> Yokeable<'a> for UnitsTrie<'static>

impl<'a> Yokeable<'a> for PersonNamesFormat<'static>

impl<'a> Yokeable<'a> for RelativeTimePatternData<'static>

impl<'a> Yokeable<'a> for RuleBasedTransliterator<'static>

impl<'a> Yokeable<'a> for UnitsInfo<'static>

impl<'a> Yokeable<'a> for ConditionalListJoinerPattern<'static>

impl<'a> Yokeable<'a> for ListFormatterPatterns<'static>

impl<'a> Yokeable<'a> for ListJoinerPattern<'static>

impl<'a> Yokeable<'a> for SerdeDFA<'static>

impl<'a> Yokeable<'a> for SpecialCasePattern<'static>

impl<'a> Yokeable<'a> for Aliases<'static>

impl<'a> Yokeable<'a> for ExemplarCharactersData<'static>

impl<'a> Yokeable<'a> for LikelySubtagsExtended<'static>

impl<'a> Yokeable<'a> for LikelySubtagsForLanguage<'static>

impl<'a> Yokeable<'a> for LikelySubtagsForScriptRegion<'static>

impl<'a> Yokeable<'a> for Parents<'static>

impl<'a> Yokeable<'a> for ScriptDirection<'static>

impl<'a> Yokeable<'a> for CanonicalCompositions<'static>

impl<'a> Yokeable<'a> for DecompositionData<'static>

impl<'a> Yokeable<'a> for DecompositionTables<'static>

impl<'a> Yokeable<'a> for NonRecursiveDecompositionSupplement<'static>

impl<'a, B> Yokeable<'a> for Pattern<B>

where B: 'static + PatternBackend, Self: Sized,

impl<'a> Yokeable<'a> for Rule<'static>

impl<'a> Yokeable<'a> for PluralRanges<'static>

impl<'a> Yokeable<'a> for PluralRulesData<'static>

impl<'a, V> Yokeable<'a> for PluralElementsPackedCow<'static, V>

where V: 'static + VarULE + ?Sized,

impl<'a> Yokeable<'a> for PropertyCodePointSet<'static>

impl<'a> Yokeable<'a> for PropertyUnicodeSet<'static>

impl<'a> Yokeable<'a> for PropertyEnumToValueNameLinearMap<'static>

impl<'a> Yokeable<'a> for PropertyEnumToValueNameSparseMap<'static>

impl<'a> Yokeable<'a> for PropertyScriptToIcuScriptMap<'static>

impl<'a> Yokeable<'a> for PropertyValueNameToEnumMap<'static>

impl<'a> Yokeable<'a> for ScriptWithExtensionsProperty<'static>

impl<'a, T> Yokeable<'a> for PropertyCodePointMap<'static, T>

where T: 'static + TrieValue,

impl<'a> Yokeable<'a> for LstmData<'static>

impl<'a> Yokeable<'a> for LstmDataFloat32<'static>

impl<'a> Yokeable<'a> for LstmMatrix1<'static>

impl<'a> Yokeable<'a> for LstmMatrix2<'static>

impl<'a> Yokeable<'a> for LstmMatrix3<'static>

impl<'a> Yokeable<'a> for RuleBreakData<'static>

impl<'a> Yokeable<'a> for RuleBreakDataOverride<'static>

impl<'a> Yokeable<'a> for UCharDictionaryBreakData<'static>

impl<'a> Yokeable<'a> for IanaNames<'static>

impl<'a> Yokeable<'a> for IanaToBcp47Map<'static>

impl<'a> Yokeable<'a> for TimeZone

where Self: Sized,

impl<'a> Yokeable<'a> for WindowsZonesToBcp47Map<'static>