Un ensemble formel de règles et de relations dans un langage de programmation qui attribue des types aux expressions et impose des contraintes sur la manière dont ces types peuvent être combinés, dans le but de détecter certaines classes d'erreurs et de permettre un raisonnement sûr sur le comportement du programme.

Principe

Définir une grammaire de types et des jugements de typage (règles) de sorte que chaque expression puisse être associée à un type (ou démontrée non typable) ; les règles de typage servent à faire respecter des invariants (par ex. ne pas appliquer un entier comme une fonction) et à soutenir les optimisations et la sécurité d'abstraction.

Démonstration

Un système de types statique avec sous-typage (par ex. langages orientés objet) impose qu'une valeur d'un sous-type peut être utilisée là où un supertype est attendu ; un système de type de style Hindley–Milner effectue une inférence de types pour assigner le type polymorphe le plus général aux expressions sans annotations explicites.

Mauvaise application

Supposer qu'un système de types garantit à lui seul la correction du programme sur tous ses aspects (il ne garantit que les propriétés démontrées par ses règles, par ex. la sécurité des types) ou confondre annotations de type syntaxiques et contrats sémantiques (des contrôles à l'exécution peuvent encore être nécessaires).

Conséquence

Appliqué correctement, un système de types empêche des classes d'erreurs (mésappariements de types, certaines erreurs mémoire), documente l'utilisation prévue via les types, permet une détection d'erreurs plus précoce et ouvre des opportunités d'optimisations du compilateur et d'API plus sûres.

Inversion

Une perspective non typée ou à typage dynamique traite les types comme des descripteurs à l'exécution ou de simples annotations de programmeur ; l'inversion met l'accent sur les vérifications à l'exécution et la composition flexible au prix de garanties statiques.

Limite

Se réfère aux règles de typage au niveau du langage et à leur métathéorie (sécurité, complétude, décidabilité) ; exclut les tailles de mot au niveau machine, les représentations de valeur à l'exécution et les propriétés de correction comportementale non exprimables dans le langage de types sauf si le système est étendu (types dépendants, types de raffinement).

Tension sémantique

Tension entre typage statique et dynamique, et entre systèmes de types expressifs (types dépendants/de raffinement) qui peuvent encoder plus de propriétés et systèmes plus simples, décidables et pratiques ; les compromis entre expressivité, décidabilité et ergonomie des programmeurs sont centraux.

Synthèse

Un système de types est le mécanisme formel qui classe les expressions par type et impose des règles de composition, permettant un raisonnement statique sur les programmes et réduisant certaines classes d'erreurs à l'exécution tout en conciliant expressivité, décidabilité et praticité.