Comprison of TypeIds in const context

[WaffleLapkin]

Is there any way to compare 2 TypeIds in const context? (It's possible to create them in const context, and it's even soon to be stabilized)

What I want is a static check for type (un)equality without auto traits:

// will fail with index out of bounds if T == U
const _: () = [()][(TypeId::of::<T>() == TypeId::of::<U>()) as usize];

(this exact code currently fails to compile with "calls in constants are limited to constant functions, tuple structs and tuple variants" error, because == isn't const)

Maybe it's a good idea to add API like the following to TypeId?

impl TypeId {
    const fn eq(&self, rhs: &Self) -> bool {
        self.t == rhs.t
    }
}

I could work on this, though I haven't seen similar apps in std, so I wanted to ask about it before doing anything.

[KodrAus]

There's a snippet in the stabilization PR that compares two type ids, but it does it using match:

const USIZE: TypeId = TypeId::of::<usize>();

match TypeId::of::<Self>() {
    // Use a closure for `usize` that transmutes the generic `Self` to
    // a concrete `usize` and dispatches to `Self::usize`.
    USIZE => |x| Self::usize(unsafe { &*(x as *const Self as *const usize) }),
    // For other types, dispatch to the generic `Self::default`.
    _ => Self::default,
}

[WaffleLapkin]

Oh, I've missed it 🤦 Then I think this issue is not critical at all. Thanks.

However match won't work with generics, you can't write code like this:

const fn type_eq<A: 'static, B: 'static>() -> bool {
    let A = TypeId::of::<A>();
    const B: TypeId = TypeId::of::<B>(); // error[E0401]: can't use generic parameters from outer function
    match A {
        B => true,
        _ => false,
    }
}

(playground)

[nbdd0121]

I think this is blocked by #67792, which would allow PartialEq implementation of TypeId to be marked as const.

@rustbot modify labels: A-const-fn S-blocked

[WaffleLapkin]

We could add stand-alone function and then replace it by const imply. (if we'll do this before the stabilization of stand-alone fns, it won't be even a breaking change)

[rodrimati1992]

You can use associated constants to get the TypeId of a generic type:
https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=50e369ee80dcbceab6563d183cf8c894

#![feature(const_type_id)]

use std::any::{type_name, TypeId};

pub struct GetTypeId<T>(T);

impl<T: 'static> GetTypeId<T> {
    pub const VALUE: TypeId = TypeId::of::<T>();
}

#[macro_export]
macro_rules! typeid {
    ($t:ty) => {
        $crate::GetTypeId::<$t>::VALUE
    };
}

const fn same_type<T: 'static, U: 'static>() -> bool {
    match typeid!(T) {
        typeid!(U) => true,
        _ => false,
    }
}

fn print_if_equal<T: 'static, U: 'static>() {
    if same_type::<T, U>() {
        println!("{} == {}", type_name::<T>(), type_name::<U>());
    } else {
        println!("{} != {}", type_name::<T>(), type_name::<U>());
    }
}

fn main() {
    print_if_equal::<usize, u32>();
    print_if_equal::<usize, usize>();
}

Edit:
I just noticed that the match doesn't work, it prints this:

usize != u32
usize != usize

Reported this in #73976

[WaffleLapkin]

Then I'll go ahead and close this issue, technically comparison can be done. The only problem is a bug reported in #73976

I've actually used similar hack with assoc const, how I could forget... anyway, thanks @rodrimati1992

[nbdd0121]

@WaffleLapkin The pattern in #73976 is now forbidden. However you can use this transmute hack:

#![feature(const_fn)]
#![feature(const_type_id)]

use std::any::TypeId;
use std::any::type_name;
use std::mem::transmute;

const fn same_type<A: 'static, B: 'static>() -> bool {
    unsafe { transmute::<_, u64>(TypeId::of::<A>()) == transmute::<_, u64>(TypeId::of::<B>()) }
}

fn print_if_equal<T: 'static, U: 'static>() {
    if same_type::<T, U>() {
        println!("{} == {}", type_name::<T>(), type_name::<U>());
    } else {
        println!("{} != {}", type_name::<T>(), type_name::<U>());
    }
}

fn main() {
    print_if_equal::<usize, u32>();
    print_if_equal::<usize, usize>();
}

[WaffleLapkin]

@nbdd0121 it's actually a de jure UB since TpeId has neither #[repr(C)] nor #[repr(transparent)], so I don't think it's an "ok" solution.

(reopening the issue since the pattern from #73900 (comment) is now forbidden)

[raldone01]

See this pr for more information #101698.