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

Commencez par la syntaxe unlike proposée et par la comparaison de l’issue avec les contraintes extends existantes. Examinez le comportement de TypeScript concernant les contraintes génériques et la vérification des types, puis définissez comment l’exclusion de Promise<any> devrait fonctionner dans les cas de refactorisation présentés ; le travail n’est considéré comme terminé qu’avec un design approuvé, ainsi qu’une implémentation et des tests, puisque aucun fichier ni point d’entrée de test n’est indiqué.