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.

Aucun fichier du dépôt, test ou point d’entrée n’est nommé. Commencez par reproduire l’exemple equals en TypeScript et déterminez le comportement de narrowing attendu lorsque les discriminants sont égaux. C’est terminé lorsque l’inférence implicite demandée fonctionne sans casser le comportement existant du type-checking, avec des tests couvrant l’exemple.