Comparison for different/incompatible types errors on equality, but not on greater/less comparisons

[gyzerok]

Bug Report

🔎 Search Terms

is:issue is:open incompatible types comparison

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about common bugs, tried searching for equality and comparisons.

⏯ Playground Link

Playground link with relevant code

💻 Code

type Opaque<Type, Token = unknown> = Type & {
  readonly __opaque__: Token
}

type One = Opaque<number, 'One'>
type Two = Opaque<number, 'Two'>

const one: One = 1 as One
const two: Two = 2 as Two

console.log(one === two) // error - incompatible types
console.log(one == two) // error - incompatible types
console.log(one < two) // works? why?

🙁 Actual behavior

The current behavior feels unexpected to me. I would understand that this is due to JavaScript compatibility if equality checks would succeed.

Also in other programming languages that I know it's usually so that greater/less comparisons can be applied only to subset of types where equality can be applied. So if the errors would be other way around it would make sense for me.

So in my opinion currently the way TypeScript compiler works is confusing.

🙂 Expected behavior

I would expect to either:

1. See errors everywhere - this is preferred behavior for me
2. See errors nowhere
3. < comparison to error, while == and === to compile

[MartinJohns]

Most likely for the same reason as: #33682 (comment)

At least it makes completely sense. Both types are numbers, so comparing larger or less should be possible. But comparing for equality would always be false, due to the additional property of both types.

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.

[gyzerok]

To be honest it is unclear for me why this behavior is intentional.

Anyway thanks for the response!

[andrewbranch]

An intersection T & U can generally be used where any T or any U is needed. I like to think about simple types on a Venn diagram:

┌──────────┐
│ T        │
│   ┌──────┼───┐
│   │      │   │
│   │ T&U  │   │
│   │      │   │
└───┼──────┘   │
    │        U │
    └──────────┘

Obviously, if I told you “give me a T from the set of all T” or “give me a U from the set of all U,” I would be happy with anything taken from the intersection, T & U.

Now suppose my one job in life is to tell you whether a number is less than another number. I am the < operator. I don’t like to operate on anything except numbers. So when I tell you “give me two numbers,” should I care if you give me a number & { readonly __opaque__: "One" }? No, because what you’ve given me is clearly from the set of all numbers—it says so right in its type declaration.

┌──────────┐
│number    │
│   ┌──────┼───┐
│   │number│   │
│   |   &  │   │
│   │whatev│   │
└───┼──────┘   │
    │    whatev│
    └──────────┘

It’s of no concern to me if what you’ve given me is a member of another set too.