Struct TypeId

pub struct TypeId(/* private fields */);

Thin wrapper for std::any::TypeId, which represents a globally unique identifier for a type.

Each TypeId is an opaque object which does not allow inspection of what’s inside but does allow basic operations such as cloning, comparison, printing, and showing.

While the std::any::TypeId type is currently only available for 'static types, this wrapped version is instead provided for any type implementing the Transient trait defined in this crate by simply querying the TypeId of the Static associated type defined in its Transient impl.

A slight caveat of this implementation is that this TypeId for some type T: Transient is technically the unique identifier for T::Static as defined in its Transient impl instead of T itself, but as long as the Transient trait was implemented correctly (which the unsafe implementor pinky-promised they did), then this “static identity” is effectively equivalent. However, this identifier ignores all lifetime information about the type, &'short str will have the same TypeId as &'static str, and unsafe code should not assume that it can ignore lifetimes based on the TypeId alone.

Quoting from the std::any::TypeId documentation: while TypeId implements Hash, PartialOrd, and Ord, it is worth noting that the hashes and ordering will vary between Rust releases. Beware of relying on them inside of your code!

Examples

use transient::{TypeId, Any, Transient};

let static_str = "cookie_monster";
// 'static types have a `TypeId` just like in the `std::any` module (as long
// as they implement the `Transient` trait, which &'static str does); however,
// we use the `Transient::static_type_id` method or `TypeId::of_val` function
// instead of `Any::type_id` when dealing with concrete types to avoid needing
// to use the fully qualified path (see `Any::type_id` docs).
assert_eq!(static_str.static_type_id(), TypeId::of::<&'static str>());
assert_eq!(TypeId::of_val(&static_str), TypeId::of::<&'static str>());
{
    let temp_string = static_str.to_string();
    let temp_str: &str = &temp_string;
    // unlike `std::any`, non-'static types also have a `TypeId`
    assert_eq!(temp_str.static_type_id(), TypeId::of::<&'_ str>());
    // note that this `TypeId` will match regardless of the lifetime
    assert_eq!(temp_str.static_type_id(), TypeId::of::<&'static str>());
}
// this `TypeId` can also be compared to a `std::any::TypeId`
assert_eq!(TypeId::of::<&'_ str>(), std::any::TypeId::of::<&'static str>());

Implementations

impl TypeId

pub fn of<T: Transient>() -> Self

Returns the TypeId of the Transient type this generic function has been instantiated with.

See the TypeId documentation for a discussion of the subtle differences between this identifier and the std::any::TypeId.

Examples

use transient::{Transient, Any, TypeId};

fn is_string_slice<T: Transient>(_s: &T) -> bool {
    TypeId::of::<&str>() == TypeId::of::<T>()
}

let string = "cookie monster".to_string();
let string_slice: &str = &string;

assert_eq!(is_string_slice(&0), false);
assert_eq!(is_string_slice(&string), false);
assert_eq!(is_string_slice(&string_slice), true);
assert_eq!(is_string_slice(&"cookie monster"), true);

pub fn of_val<T: Transient>(_value: &T) -> Self

Returns the TypeId for the type of the given value.

This is effectively the same as TypeId::of, but allows a value to provided so that type inference can be used to get the type T instead of needing to explicitly specify it.

See the TypeId documentation for a discussion of the subtle differences between this identifier and the std::any::TypeId.

Trait Implementations

impl Clone for TypeId

fn clone(&self) -> TypeId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeId

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

Formats the value using the given formatter.

impl From<TypeId> for TypeId

fn from(value: TypeId) -> Self

Converts to this type from the input type.

impl From<TypeId> for TypeId

fn from(value: TypeId) -> Self

Converts to this type from the input type.

impl Hash for TypeId

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 Ord for TypeId

fn cmp(&self, other: &TypeId) -> 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 PartialEq<TypeId> for TypeId

fn eq(&self, other: &TypeId) -> 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 PartialEq for TypeId

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

fn partial_cmp(&self, other: &TypeId) -> 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 Copy for TypeId

impl Eq for TypeId

impl StructuralPartialEq for TypeId