Support Implicit Generics Inference

Search Terms

implicit generics, broader type inference, better type inference

Suggestion

I'd like TypeScript to know when two types are unknown, but equal.
That is, say I've function equals():

type T = { type: 'a', p1: boolean } | { type: 'b', p2: string };

function equals(a: T, b: T) {
  // Currently, we have to write:
  if (a.type === 'a' && b.type === 'a') { return a.p1 === b.p1;  }
  if (a.type === 'b' && b.type === 'b') { return a.p2 === b.p2; }
  return false;

  // But I'd like to be able to write:
  if (a.type !== b.type) { return false; }
  return a.type === 'a' ? a.p1 === b.p1 : a.p2 === b.p2;
}

Use Cases

I can't think about other use cases except comparisons (if you know let me know), but I think they're common enough. This will also make them somewhat faster (no need to check both's type).

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Non sono nominati file del repository, test o entry point. Inizia riproducendo l’esempio equals in TypeScript e determina il comportamento di narrowing previsto quando i discriminanti sono uguali. Il lavoro è completato quando l’inferenza implicita richiesta funziona senza compromettere il comportamento esistente del type-checking, con test che coprono l’esempio.