Could you explain how does Equal type implementation work?

[KnightSlayer]

type-challenges/utils/index.d.ts

Line 7 in e3cc0d3

export type Equal<X, Y> =

[sbr61]

As a first thought, let's talk about assignability:

type Assignable<X, Y> = X extends Y ? true : false

This tests for assignability of X to Y instead of testing for equality.

So what about mutual assignability? Can we use the following type?

type MutuallyAssignable<X, Y> = X extends Y ? Y extends X ? true : false : false

Actually not. Mutual assignability does not guarantee type equality:

type X1 = { a: string, b?: boolean }
type X2 = { a: string, c?: number }
type X1X2 = MutuallyAssignable<X1, X2> // literal type true

function x1x2(x1: X1, x2: X2) {
    // Mutual assignability:
    x1 = x2; // ok
    x2 = x1; // ok

    // Type inequality:
    x1.b = x2.b; // error: Property 'b' does not exist on type 'X2'.
    x2.c = x1.c; // error: Property 'c' does not exist on type 'X1'.
}

Fortunately, for some set of types, extends means equality, and for others, equality can be expressed in terms of extends. We make the following observations:

• (1) For literal types L1 and L2, L1 is equal to L2 if and only if L1 extends L2.
• (2) Two non-argument function types are equal if and only if their return types are equal.
• (3) For non-argument function types F1 and F2 returning literal types L1 and L2, respectively, F1 is equal to F2 if and only if L1 extends L2.
• (4) Two types X1 and X2 are equal, when the set of all types E1 with E1 extends X1 is equal to the set of all types E2 with E2 extends X2.

(1) is true because literal types have only one value. (2) is true because type F = () => R just describes a one-to-one mapping of non-argument function types to their return types. (3) follows from (1) and (2).

(4) means that two types are equal if they share the same assignable types (and if they also share the same non-assignable types). To continue the example from above, as X1 and X2 are different types, we should be able to find a type X1E1 which is assignable to X1, but not to X2. Here is one:

type X1E1 = { a: string, c: string }

function x1x2e1(x1: X1, x2: X2, e1: X1E1) {
    x1 = e1; // ok
    x2 = e1; // error: Type 'E1' is not assignable to type 'X2'.
             //          Types of property 'c' are incompatible.
             //            Type 'string' is not assignable to type 'number'.
}

With these observations in mind, we can find the implementation of Equals now. Literal types are easy, see (1). For an arbitrary type X, we classify the assignability to X with a literal type 1, and the non-assignability with a literal type 2, allowing for a simple equality test of the classification types via extends. So for any type T, we classify the assignability (or non-assignability) with

T extends X ? 1 : 2

But (4) tells us that we need to do the classification for all types T on the left-hand side of the extends. To do this, we need to introduce T as a type parameter, but on the right-hand side of the type definition. This can be achieved by using a generic function type:

<T>() => T extends X ? 1 : 2

But now we are classifying non-argument function return types although we would compare the function types themselves. (3) shows that this is equivalent to comparing their return types, so we found a suitable comparer type for checking type equality and can define Equals as follows:

type Equal<X, Y> =
  (<T>() => T extends X ? 1 : 2) extends
  (<T>() => T extends Y ? 1 : 2) ? true : false

Actually, we now make a classification to either () => 1 for assignability or to () => 2 for non-assignability, which are both types with a single value.

This is the actual implementation of Equal from '@type-challenges/utils'.

Note: This is an excerpt from my solution to the Includes type challenge here:
898 - Includes - Non-recursive solution using array union with explanations.

[zhangzhuang15]

It really helps me, thanks for your sharing @sbr61

But one thing still confuse me, please look at these codes:

type M<T> = <N>() => N extends T ?  1 : 2;
type Y = M<unknown>;
type YY = M<any>;
type R = Y extends YY ?  1 : 0

R is always 1, why not 0 ? What do you think of it ?

[sbr61]

If you inline your definitions , you get:

type RR = (<N>() => N extends unknown ?  1 : 2) extends (<N>() => N extends any ?  1 : 2) ?  1 : 0

which correctly evaluates to 0.

It looks like you found a bug. See some related problems reported here: #55618 and #48070.