4 releases (stable)

1.0.2 Aug 17, 2024
1.0.0 May 14, 2024
0.0.1 May 13, 2024

#16 in No standard library

Download history 97345/week @ 2024-07-18 109052/week @ 2024-07-25 114239/week @ 2024-08-01 124449/week @ 2024-08-08 127140/week @ 2024-08-15 135143/week @ 2024-08-22 147144/week @ 2024-08-29 199475/week @ 2024-09-05 180909/week @ 2024-09-12 185427/week @ 2024-09-19 204495/week @ 2024-09-26 211287/week @ 2024-10-03 217320/week @ 2024-10-10 206741/week @ 2024-10-17 185878/week @ 2024-10-24 188827/week @ 2024-10-31

841,261 downloads per month
Used in 1,517 crates (6 directly)

MIT/Apache

13KB
126 lines

Const TypeId and non-'static TypeId

github crates.io docs.rs build status

Const TypeId

This crate provides ConstTypeId, which is like core::any::TypeId but is constructible in const in stable Rust. (The standard library's TypeId's is nightly-only to construct in const; the tracking issue for this is rust#77125.)

Being able to construct ConstTypeId in const makes it suitable for use cases that rely on static promotion:

use std::fmt::{self, Debug, Display};
use std::ptr;
use typeid::ConstTypeId;

pub struct ObjectVTable {
    type_id: ConstTypeId,
    drop_in_place: unsafe fn(*mut ()),
    display: unsafe fn(*const (), &mut fmt::Formatter) -> fmt::Result,
    debug: unsafe fn(*const (), &mut fmt::Formatter) -> fmt::Result,
}

impl ObjectVTable {
    pub const fn new<T: Display + Debug>() -> &'static Self {
        &ObjectVTable {
            type_id: const { ConstTypeId::of::<T>() },
            drop_in_place: |ptr| unsafe { ptr::drop_in_place(ptr.cast::<T>()) },
            display: |ptr, f| unsafe { Display::fmt(&*ptr.cast::<T>(), f) },
            debug: |ptr, f| unsafe { Debug::fmt(&*ptr.cast::<T>(), f) },
        }
    }
}

and in associated constants:

use typeid::ConstTypeId;

pub trait GetTypeId {
    const TYPEID: ConstTypeId;
}

impl<T: 'static> GetTypeId for T {
    const TYPEID: ConstTypeId = ConstTypeId::of::<Self>();
}

Non-'static TypeId

This crate provides typeid::of, which takes an arbitrary non-'static type T and produces the TypeId for the type obtained by replacing all lifetimes in T by 'static, other than higher-rank lifetimes found in trait objects.

For example if T is &'b dyn for<'a> Trait<'a, 'c>, then typeid::of::<T>() produces the TypeId of &'static dyn for<'a> Trait<'a, 'static>.

It should be obvious that unlike with the standard library's TypeId, typeid::of::<A>() == typeid::of::<B>() does not mean that A and B are the same type. However, there is a common special case where this behavior is exactly what is needed. If:

  • A is an arbitrary non-'static type parameter, and
  • B is 'static, and
  • all types with the same id as B are also 'static

then typeid::of::<A>() == typeid::of::<B>() guarantees that A and B are the same type.

use core::any::TypeId;
use core::slice;

pub fn example<T>(slice: &[T]) {
    // T is arbitrary and non-'static.

    if typeid::of::<T>() == TypeId::of::<u8>() {
        // T is definitely u8
        let bytes = unsafe { slice::from_raw_parts(slice.as_ptr().cast(), slice.len()) };
        process_bytes(bytes);
    } else {
        for t in slice {
            process(t);
        }
    }
}

fn process<T>(_: &T) {/* ... */}
fn process_bytes(_: &[u8]) {/* ... */}

License

Licensed under either of Apache License, Version 2.0 or MIT license at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

No runtime deps