Trait TypeIdentity

pub trait TypeIdentity {
    type Type: ?Sized;

    // Provided methods
    fn into_type(self) -> Self::Type
       where Self: Sized,
             Self::Type: Sized { ... }
    fn as_type(&self) -> &Self::Type { ... }
    fn as_type_mut(&mut self) -> &mut Self::Type { ... }
    fn into_type_box(self: Box<Self>) -> Box<Self::Type> { ... }
    fn into_type_arc(this: Arc<Self>) -> Arc<Self::Type> { ... }
    fn into_type_rc(this: Rc<Self>) -> Rc<Self::Type> { ... }
    fn from_type(this: Self::Type) -> Self
       where Self: Sized,
             Self::Type: Sized { ... }
    fn from_type_ref(this: &Self::Type) -> &Self { ... }
    fn from_type_mut(this: &mut Self::Type) -> &mut Self { ... }
    fn from_type_box(this: Box<Self::Type>) -> Box<Self> { ... }
    fn from_type_arc(this: Arc<Self::Type>) -> Arc<Self> { ... }
    fn from_type_rc(this: Rc<Self::Type>) -> Rc<Self> { ... }
}

Allows converting Self to Self::Type by proving that both types are equal.

Usecases

This trait allows:

• Defining extension traits without repeating method signatures.

• Creating a type Alias in a where clause, eg: Vec<i32>: TypeIdentity<Type = List>.

• Unwrapping a generic type, eg: I: TypeIdentity<Type = Option<U>>.

Example

Defining an extension trait on Vec<T>.

use core_extensions::TypeIdentity;

trait VecExt<T>: TypeIdentity<Type = Vec<T>> + Sized {
    fn is_nonempty(&self) -> bool {
        !self.as_type().is_empty()
    }

    fn moved_vec(self) -> Vec<T> {
        self.into_type()
    }

    fn mutable_vec(&mut self) -> &mut Vec<T> {
        self.as_type_mut()
    }
}
impl<T> VecExt<T> for Vec<T> {}

assert!( vec![100].is_nonempty());
assert!(!Vec::<i32>::new().is_nonempty());

Example of a method requiring Self == Other

Wrapper::iter is only callable on Wrapper<Vec<T>>

use core_extensions::TypeIdentity;

use std::slice;

struct Wrapper<U>(U);

impl<U> Wrapper<U> {
     fn iter<T>(&self) -> slice::Iter<T>
     where U: TypeIdentity<Type = Vec<T>>
     {
         self.0.as_type().iter()
     }
}

assert_eq!(
    Wrapper(vec![0, 1, 2, 3, 4]).iter().cloned().collect::<Vec<_>>(),
    vec![0, 1, 2, 3, 4]
);

Example of creating a type alias in a where clause

use core_extensions::TypeIdentity;

use std::ops::Deref;

struct Example<T>(T);

impl<T, Target0, Target1> Deref for Example<T>
where
    T: Deref,
    <T as Deref>::Target: TypeIdentity<Type = Target0>,
    Target0: Deref,
    <Target0 as Deref>::Target: TypeIdentity<Type = Target1>,
{   
    type Target = Target1;
     
    fn deref(&self) -> &Target1 {
        &**self
    }
}

Required Associated Types

type Type: ?Sized

This is always Self.

Provided Methods

fn into_type(self) -> Self::Type

where Self: Sized, Self::Type: Sized,

Converts a value back to the original type.

fn as_type(&self) -> &Self::Type

Converts a reference back to the original type.

fn as_type_mut(&mut self) -> &mut Self::Type

Converts a mutable reference back to the original type.

fn into_type_box(self: Box<Self>) -> Box<Self::Type>

Converts a box back to the original type.

fn into_type_arc(this: Arc<Self>) -> Arc<Self::Type>

Converts an Arc back to the original type.

Self parameter

Enabling the “rust_1_46” feature changes this method from taking a this parameter to taking aself parameter, which allows calling it with .into_type_arc()

fn into_type_rc(this: Rc<Self>) -> Rc<Self::Type>

Converts an Rc back to the original type.

Self parameter

Enabling the “rust_1_46” feature changes this method from taking a this parameter to taking aself parameter, which allows calling it with .into_type_rc()

fn from_type(this: Self::Type) -> Self

where Self: Sized, Self::Type: Sized,

Converts a value back to the original type.

fn from_type_ref(this: &Self::Type) -> &Self

Converts a reference back to the original type.

fn from_type_mut(this: &mut Self::Type) -> &mut Self

Converts a mutable reference back to the original type.

fn from_type_box(this: Box<Self::Type>) -> Box<Self>

Converts a box back to the original type.

fn from_type_arc(this: Arc<Self::Type>) -> Arc<Self>

Converts an Arc back to the original type.

fn from_type_rc(this: Rc<Self::Type>) -> Rc<Self>

Converts an Rc back to the original type.

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.

Implementors

impl<T: ?Sized> TypeIdentity for T

type Type = T