negating type constraints

Sometimes it's useful to put a limit on what a type parameter can be. In a way it is a counterpart of the extends constraint.

Problem

Consider an example, a classic function that takes whatever and returns void:

function ignore<a>(value: a) : void {};

However we must not apply this function to Promises, because it might get us a temporal leak if we do.

function readFileAsync(): Promise<string>;
ignore(readFileAsync()); // <-- untracked promise, temporal leak

Unfortunately it is way too easy to get into a situation when a promise is passed to that function unintentionally as a result of refactoring:

// before
function readFileSync(): string;
ignore(readFileSync()); // typechecks, works as intended, no problem

// after refactoring
function readFileAsync(): Promise<string>; // <-- went async here
ignore(readFileAsync()); // typechecks, unintended temporal leak, big problem

Solution

The situation above could have been avoided if TypeScript allowed negating constraints:

function ignore<a unlike Promise<any>>(value: a): void {} // <-- hypothetical syntax

Comienza con la sintaxis unlike propuesta y la comparación del issue con las constraints extends existentes. Revisa el comportamiento de TypeScript con las constraints genéricas y la comprobación de tipos, y después define cómo debería funcionar la exclusión de Promise<any> en los casos de refactorización mostrados; el trabajo requiere un diseño acordado, además de implementación y pruebas, ya que no se nombran archivos ni puntos de entrada de pruebas.