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

Beginne mit der vorgeschlagenen unlike-Syntax und dem Vergleich des Issues mit vorhandenen extends-Constraints. Untersuche das Verhalten von TypeScript bei generischen Constraints und der Typprüfung und definiere anschließend, wie das Ausschließen von Promise<any> in den gezeigten Refactoring-Fällen funktionieren soll; als abgeschlossen gilt die Aufgabe erst, wenn ein abgestimmtes Design sowie Implementierung und Tests vorhanden sind, da keine Dateien oder Test-Einstiegspunkte genannt werden.