Type systems (An introduction)

Transcription

1 Type systems (An introduction) Ralf Lämmel Software Language Engineering Team University of Koblenz-Landau

2 Dependencies: Tree-based abstract syntax Operational semantics

3 A type system is a syntax-driven, algorithmic means for rejecting programs that would go wrong at runtime. Abstract syntax of running example symbol true : æ expr ; // The Boolean "true" symbol false : æ expr ; // The Boolean "false" symbol zero : æ expr ; // The natural number zero symbol succ : expr æ expr ; // Successor of a natural number symbol pred : expr æ expr ; // Predecessor of a natural number symbol iszero : expr æ expr ; // Test for a number to be zero symbol if : expr expr expr æ expr ; // Conditional An ill-typed term: if(zero, false, succ(zero)). n N.B.: The expression language at hand is also referred to as BTL Basic TAPL Language where TAPL is a reference to Pierce s textbook Types and programming languages.

4 Well-typed versus ill-typed programs I typeof (Succ Zero) Just NatType The expression Succ Zero is of type NatType I typeof (Succ TRUE) Nothing The expression Succ TRUE is ill-typed. In the following illustration, we strive for a syste N.B.: We hint here at how we plan to implement a type system effectively as a type checker. This is comparable to implementing an operational semantics definition as an interpreter.

5 true : booltype false : booltype zero : nattype [t true] [t false] [t zero] e : nattype succ(e) : nattype e : nattype pred(e) : nattype e : nattype iszero(e) : booltype [t succ] [t pred] [t iszero] Type system for BTL s simple expressions e 0 : booltype e 1 : T e 2 : T if(e 0,e 1,e 2 ) : T [t if]

6 Typing derivations leaf nodes zero : nattype [t zero] [t iszero] zero : nattype [t zero] [t succ] iszero(zero) : booltype succ(zero) : nattype zero : nattype [t zero] [t if] if(iszero(zero), succ(zero), zero) : nattype pred(if(iszero(zero), succ(zero), zero)) : nattype root [t pred] N.B.: Subject to some modest constraints on the form of inference rules, these derivation trees can be constructed effectively, thereby typechecking' programs.

7 Type safety A crucial relationship of agreement between (small-step) operational semantics and type system. Preservation: If e : T and e e', then e' : T. Progress: if e : T, then e is either a value or there is an e such e e. N.B.: These properties need to be adapted for other languages.

8 Types of expressions data Type = NatType BoolType Well typedness of expressions welltyped :: Expr æ Bool welltyped e Just _ Ω typeof e = True welltyped e otherwise = False Types of expressions typeof :: Expr æ Maybe Type typeof TRUE = Just BoolType typeof FALSE = Just BoolType typeof Zero = Just NatType typeof (Succ e) Just NatType Ω typeof e = Just NatType typeof (Pred e) Just NatType Ω typeof e = Just NatType typeof (IsZero e) Just NatType Ω typeof e = Just BoolType typeof (If e0 e1 e2) Just BoolType Ω typeof e0, Just t1 Ω typeof e1, Just t2 Ω typeof e2, t1 == t2 = Just t1 typeof _ = Nothing A type checker for BTL s expressions N.B.: We implement typing rules in the same way as we previously implemented rules of an operational semantics,

9 Type system for simple imperative programs I//II (BIPL Basic Imperative Programming Language) Types of statements m e : T x /œ m m assign(x,e) : m[x æ T ] m e : T Èx,T Íœm m assign(x, e) : m N.B.: Variables are not declared in BIPL.Thus, types of variables are inferred. [t assign1] [t assign2] m 0 s 1 : m 1 m 1 s 2 : m 2 m 0 seq(s 1,s 2 ) : m 2 [t seq] m 1 e : booltype m 1 s 1 : m 2 m 1 s 2 : m 2 m 1 if(e,s 1,s 2 ) : m 2 [t if] m e : booltype m while(e, s) : m m s : m [t while]

10 Type system for simple imperative programs II//II (BIPL Basic Imperative Programming Language) m intconst(i) : inttype Types of expressions [t intconst] m(x) æ T m var(x) : T [t var] m e : T unary(uo,t) : T Õ m unary(uo,e) : T Õ [t unary] m e 1 : T 1 m e 2 : T 2 binary(bo,t 1,T 2 ) : T Õ m binary(bo,e 1,e 2 ) : T Õ [t binary] Signatures of operators unary(negate, inttype) : inttype [t negate] unary(not, booltype) : booltype binary(or booltype booltype) : booltype [t not] [t or]

11 Type system for simple functional programs I/III (BFPL Basic Functional Programming Language) Well-typedness of programs fs = Èf 1,...,f n Í fs f 1 fs f n fs, ÿ e : T Èfs,eÍ [t program] Well-typedness of functions fs,[x 1 æ T 1,...,x n æ T n ] e : T 0 fs Èx,ÈÈT 1,...,T n Í,T 0 Í,ÈÈx 1,...,x n Í,eÍÍ [t function]

12 Type system for simple functional programs II/III (BFPL Basic Functional Programming Language) fs,m intconst(i) : inttype Types of expressions [t intconst] fs,m boolconst(b) : booltype [t boolconst] Èx,T Íœm fs,m arg(x) : T [t arg] fs,m e 0 : booltype fs,m e 1 : T fs,m e 2 : T fs,m if(e 0,e 1,e 2 ) : T [t if] fs,m e : T unary(uo,t) : T Õ fs,m unary(uo,e) : T Õ [t unary] fs,m e 1 : T 1 fs,m e 2 : T 2 binary(bo,t 1,T 2 ) : T Õ fs,m binary(bo,e 1,e 2 ) : T Õ [t binary]

13 BFPL III/III Well-typedness of BFPL s function applications fs,m e 1 : T 1 fs,m e n : T n Èx,ÈÈT 1,...,T n Í,T 0 Í,ÈÈx 1,...,x n Í,eÍÍ œ fs fs,m apply(x,èe 1,...,e n Í) : T 0 [t apply] N.B.: Each function application is checked against the signature for the applied function. The body of a function, though, is checked as part of well-typedness of functions (I/III).

14 Online resources YAS GitHub repository contains all code. YAS (Yet Another SLR (Software Language Repository)) See languages BTL, BIPL, and BFPL. There are Haskell- and Prolog-based type checkers. The Software Languages Book The book discusses type systems in more detail. Other related subjects: lambda calculus.