Typing rule

From The Right Wiki
Jump to navigationJump to search

In type theory, a typing rule is an inference rule that describes how a type system assigns a type to a syntactic construction.[1]: 94  These rules may be applied by the type system to determine if a program is well-typed and what type expressions have. A prototypical example of the use of typing rules is in defining type inference in the simply typed lambda calculus, which is the internal language of Cartesian closed categories.[2]

Notation

Typing rules specify the structure of a typing relation that relates syntactic terms to their types.[1]: 92  Syntactically, the typing relation is usually denoted by a colon, so for example e:τ denotes that an expression e has type τ. The rules themselves are usually specified using the notation of natural deduction.[1]: 26  For example, the following typing rules specify the typing relation for a simple language of booleans:[1]: 93 

true:Boolfalse:Boole1:Boole2:τe3:τife1thene2elsee3:τ

Each rule states that the conclusion below the line may be derived from the premises above the line. The first two rules have no premises above the line, so they are axioms. The third rule has premises above the line (specifically, three premises), so it is an inference rule. In programming languages, the type of a variable depends on where it is bound, which necessitates context-sensitive typing rules. These rules are given by a typing judgment, usually written Γe:τ, which states that an expression e has type τ under a typing context Γ that relates variables to their types. Typing contexts are occasionally supplemented by the types of individual variables; for example, Γ,x:τ1e:τ2 can be read as "the context Γ supplemented by the information that the expression x has type τ1 yields the judgement that expression e has type τ2". This notation can be used to give typing rules for variable references and lambda abstraction in the simply typed lambda calculus:[1]: 101–102 

x:τΓΓx:τΓ,x:τ1e:τ2Γ(λx:τ1.e):τ1τ2

Similarly, the following typing rule describes the let construct of Standard ML:

Γe1:τ1Γ,x:τ1e2:τ2Γletx=e1ine2end:τ2

Not all systems of typing rules directly specify a type checking algorithm. For example, the typing rule for applying a parametrically polymorphic function in the Hindley–Milner type system requires "guessing" the appropriate type at which the function should be instantiated.[3] Adapting a declarative rule system to a decidable algorithm requires the production of a separate, algorithmic system that can be proven to specify the same typing relation.[4]

See also

References

  1. 1.0 1.1 1.2 1.3 1.4 Pierce, Benjamin C. (2002). Types and Programming Languages (1st ed.). Cambridge, Mass.: MIT Press. ISBN 0262162091.
  2. Baez, John. "The n-Category Café". golem.ph.utexas.edu. Retrieved 30 September 2022.
  3. Clément, Dominique; Despeyroux, Thierry; Kahn, Gilles; Despeyroux, Joëlle (8 August 1986). "A simple applicative language: Mini-ML". Proceedings of the 1986 ACM conference on LISP and functional programming - LFP '86 (PDF). Association for Computing Machinery. pp. 13–27. doi:10.1145/319838.319847. ISBN 0897912004. S2CID 5126579.
  4. Dunfield, Jana; Krishnaswami, Neel (23 May 2021). "Bidirectional Typing". ACM Computing Surveys. 54 (5): 98:19. arXiv:1908.05839. doi:10.1145/3450952. ISSN 0360-0300. S2CID 201058734.

Further reading