Struct type_equalities::TypeEq

pub struct TypeEq<T: ?Sized, U: ?Sized> { /* fields omitted */ }

Evidence of the equality T == U as a zero-sized type.

assert_eq!(core::mem::size_of::<TypeEq<T, U>>(), 0);

It is important to note that the TypeEq is invariant in both arguments.

fn coerce_lt<'a, 'b: 'a, T>(eq: TypeEq<&'b T, &'b T>)
    -> TypeEq<&'b T, &'a T>
{
    eq
}

fn coerce_lt_inv<'a, 'b: 'a, T>(eq: TypeEq<&'a T, &'a T>)
    -> TypeEq<&'a T, &'b T>
{
    eq
}

Unsizing also does not work for TypeEq.

fn coerce_dyn<T: core::fmt::Debug>(eq: &TypeEq<T, T>)
    -> &TypeEq<T, dyn core::fmt::Debug>
{
    eq
}

Implementations

impl<T: ?Sized> TypeEq<T, T>

pub const fn refl() -> TypeEq<T, T>

Same as crate::refl.

impl<T: ?Sized, U: ?Sized> TypeEq<T, U>

pub const fn trivial() -> Self where
    T: IsEqual<U>, 

Same as crate::trivial_eq.

Note: this function is const only on nightly, since it depends on the const_fn_trait_bound feature.

pub fn substitute<F: TypeFunction<T> + TypeFunction<U>>(
    self,
    t: ApF<F, T>
) -> ApF<F, U> where
    ApF<F, T>: Sized,
    ApF<F, U>: Sized, 

Same as crate::substitute.

pub fn coerce(self, t: T) -> U where
    T: Sized,
    U: Sized, 

Same as crate::coerce. Note that this is operationally a no-op.

Examples

assert_eq!(refl().coerce(42), 42);

pub fn lift_through<F: TypeFunction<T> + TypeFunction<U>>(
    self
) -> TypeEq<ApF<F, T>, ApF<F, U>>

Lift the type equality through any TypeFunction

pub fn invert(self) -> TypeEq<U, T>

Get the inverse equality. T == U ==> U == T

pub fn trans<V: ?Sized>(self, rhs: TypeEq<U, V>) -> TypeEq<T, V>

Apply transitivity. T == U & U == V ==> T == V

impl<T: ?Sized, U: ?Sized> TypeEq<T, U>

pub fn use_eq<C: Consumer<T, U>>(self, c: C) -> C::Result

Use the observed equality to call the consumer to compute a result.

Consider using either TypeEq::coerce or TypeEq::lift_through first.

Trait Implementations

impl<T: ?Sized, U: ?Sized> Clone for TypeEq<T, U>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: ?Sized, U: ?Sized> Copy for TypeEq<T, U>