Using this-type with intersection type makes it possible to simulate HKT

[ENvironmentSet]

TypeScript Version: Lastly tested in v4.1.0-dev20201003, but this has been existing at least since v3.8

Search Terms: this-type, this type, intersection, HKT, higher kinded type

Code

export interface HKT {
  param: unknown;
  result: unknown;
}

interface NotHKT extends HKT {
  result: this['param'] extends true ? false : true;
}

interface FstHKT extends HKT {
  result: this['param'] extends [infer A, infer _] ? A : never;
}

interface ArrayHKT extends HKT {
  result: Array<this['param']>;
}

export type Apply<f extends HKT, x>
  = (f & { param: x })['result'];

type Test1 = Apply<NotHKT, true> // be deducedd to `false`
type Test2 = Apply<FstHKT, [string, boolean]> // be deduced to `string`
type Test3 = Apply<ArrayHKT, number> // be deduced to `number[]`

Expected behavior: I expected that reduction of this type doesn't depends on type that is intersected with.

Actual behavior: reduction of this type depends on type that is intersected with.

The actual behavior makes sense to me(at least). It's not hard to accept its behavior. However, It looks like unintended behavior or bug (just like recursive conditional type before) so that I can't certain it's okay to use this. Is this idea safe to use?

Playground Link

[jcalz]

Related to #1213

[andrewbranch]

Simpler version of the question:

interface A {
  a: string;
  getA: this['a'];
}

// Should T be 'never' or 'string'?
type T = (A & { a: number })['getA'];

Is this idea safe to use?

I don’t really know the answer to this question. I can’t find an instance of this in our test suite, so perhaps in some trivial way, the answer is no. But I would not be surprised if this behavior was intentional. It looks like it could be important for some mixin patterns, for example.

[andrewbranch]

@DanielRosenwasser agrees that this is probably intentional 😄

[ENvironmentSet]

Thx for the work :)