Type equality?

[Nadrieril]

You mention in the README that you couldn't get type equality to work. I was curious to know what kind of things you've tried.
Just in case you hadn't seen it, there's a trick described here that seems relevant:

trait Id {
  type X;
}
impl<T> Id for T {
  type X = T;
}

Then you can use where T: Id<X=U> that functions like where T == U.
Using this and specialization, I'm under the impression that you could implement if T == U in your language.

[kitlith]

they already know of that trick since they use it for tests :P

tyrade/src/test_utils.rs

Lines 1 to 6 in c19da67

	pub trait TypeEquals<T> {}
	impl<T> TypeEquals<T> for T {}
	pub fn assert_type_eq<T1, T2>()
	where T1: TypeEquals<T2>
	{}

i suspect the goal is to get a output of TBool from the T == U, and it appears that the use of specialization in implementing the trait causes issues when you go to use it.

my implementation:

trait ComputeTEq<O> {
    type Res: TBool;
}

impl<T, O> ComputeTEq<O> for T {
    default type Res = TFalse;
}

impl<T, O> ComputeTEq<O> for T where T: TypeEquals<O> {
    type Res = TTrue;
}

type TEq<A, B> = <A as ComputeTEq<B>>::Res;

things that work as expected: (i.e. anything that should return TTrue)

// no error
assert_type_eq::<TTrue, TEq<u16, u16>>();
// "`TypeEquals<TTrue>` is not implemented for `TFalse`"
assert_type_eq::<TFalse, TEq<u16, u16>>();

things that don't work as expected: (i.e. anything that should return TFalse)

// should be no error, instead "`TypeEquals<<u16 as ComputeTEq<u32>>::Res>` is not implemented for `TFalse`"
assert_type_eq::<TFalse, TEq<u16, u32>>();
// should be "`TypeEquals<TFalse>` is not implemented for `TTrue`", instead has same error as above
assert_type_eq::<TTrue, TEq<u16, u32>>();

something something maybe this needs lazy normalization something something? idk.

[Nadrieril]

Hm, that does look like a general bug with default type; even just the following gives an error:

#![feature(specialization)]
trait ComputeTEq {
    type Res;
}
impl ComputeTEq for u8 {
    default type Res = ();
}

fn main() {
    let _: <u8 as ComputeTEq>::Res = ();
}

I'm guessing default type is not implemented at all yet.

[Nadrieril]

Ha, default const works! That's all I need (playground):

#![allow(incomplete_features)]
#![feature(const_generics)]
#![feature(specialization)]

pub trait TypeEquals<T> {}
impl<T> TypeEquals<T> for T {}

pub fn assert_type_eq<T1, T2>()
where
    T1: TypeEquals<T2>,
{
}

trait ComputeTEq<O> {
    const RES: bool;
}
impl<T, O> ComputeTEq<O> for T {
    default const RES: bool = false;
}
impl<T> ComputeTEq<T> for T {
    const RES: bool = true;
}

const fn type_eq<A, B>() -> bool {
    <A as ComputeTEq<B>>::RES
}

struct TTrue;
struct TFalse;
struct BoolToken<const B: bool>;

trait TypeifyBool {
    type Res;
}
impl TypeifyBool for BoolToken<true> {
    type Res = TTrue;
}
impl TypeifyBool for BoolToken<false> {
    type Res = TFalse;
}

type TEq<A, B> = <BoolToken<{ type_eq::<A, B>() }> as TypeifyBool>::Res;

fn main() {
    println!("{}", type_eq::<u8, u8>());
    println!("{}", type_eq::<u8, u16>());
    let _: TEq<u8, u8> = TTrue;
    let _: TEq<u8, u16> = TFalse;
    assert_type_eq::<TTrue, TEq<u8, u8>>();
    assert_type_eq::<TFalse, TEq<u8, u16>>();
}

[kitlith]

does that work for where clauses? i.e. can you impl IsFalse for TFalse {} and then bound on TEq<A, B>: IsFalse? (that's pretty much what I would need, and which is why i forgot to mention that you could get it to work with consts because i wasn't able to turn it back into a trait again or something)

[Nadrieril]

Hm, I thought so but I think I'm hitting the limits of what's implemented in const-generics :(

[kitlith]

note that you can ditch const generics by converting to a type in a different way, i.e. [(); { type_eq::<A, B>() as usize }] but i don't know that it'll actually help enough for where clauses

[Nadrieril]

I get "can't use generic params in const" for this sadly, I think it requires const generics.

[Nadrieril]

And with either [(); { type_eq::<A, B>() as usize }] or my BoolToken above I get into issues if I try to use it in a bound :(

[kitlith]

Fair enough. That probably covers why the author wasn't able to implement it.

On my end, the things I would have used this for ended up being served by https://doc.rust-lang.org/unstable-book/language-features/marker-trait-attr.html which, while not the same, gives me something close enough for my specific usecase

[Nadrieril]

On nice, I didn't know about this feature

[kitlith]

neither did i until very recently

[willcrichton]

Just to clarify: yes, it's the need to make type equality a boolean output (ie false if not equal) that made equality challenging. I wasn't using specialization at the time -- that's since changed when I added support for generic associated types, although I haven't fully explored the uses of specialization.

[kitlith]

seeing the types of things fixed by rust-lang/rust#85499 , it might be worth giving this another shot.