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

Inizia con la sintassi unlike proposta e con il confronto dell’issue con i constraint extends esistenti. Esamina il comportamento di TypeScript per quanto riguarda i constraint generici e il controllo dei tipi, quindi definisci come dovrebbe funzionare l’esclusione di Promise<any> nei casi di refactoring mostrati; il lavoro richiede un design concordato, oltre all’implementazione e ai test, poiché non sono indicati file né punti di ingresso dei test.