Simple Type Extensions

Transcription

1 Simple Type Extensions Type Systems, Lecture 4 Jevgeni Kabanov Tartu,

2 PREVIOUSLY ON TYPE SYSTEMS Lambda Calculus Embedded Booleans and Arithmetical expressions Fixpoints and Recursion Simple Types Safety = Progress + Preservation Normalization 1

3 LAMBDA WITH CONSTANTS All typing and evaluation rules are inherited: t ::=... lambda terms + true false if t then t else t constant true constant false conditional 0 constant zero succ t pred t iszero t successor predecessor zero test 2

4 DERIVED FORMS Derived forms (also syntactic sugar) are syntactic constructs that are substituted by their full forms during evaluation or type derivation. Wildcard is a derived form: λ :S.t := λx:s.t, where x / FV(t) Further we will introduce some derived forms along with other constructions and rules. 3

5 Base type A. TRIVIAL EXTENSIONS Unit type Unit, Γ unit : Unit. Ascription t as T : T-ASCRIBE Γ t : T Γ t as T : T 4

6 LET BINDING Let expressions are commonly used to give names to some common subexpressions. Syntax: t ::=... let x = t in t terms: let binding Evaluation: let x = v in t [x v]t t 1 t 1 let x = t 1 in t 2 let x = t 1 in t 2 (E-LetV) (E-Let) 5

7 LET BINDING Let typing: Γ t 1 : T 1 Γ, x:t 1 t 2 : T 2 Γ let x = t 1 in t 2 : T 2 (T-Let) Note that we do not have to type x! Let expressions can also be defined as derived forms let x = t 1 in t 2 := (λx:t 1.t 2 ) t 1, but type inference is needed to determine T 1. 6

8 LET BINDING EXAMPLES let x = unit in λy :T 1.x : T 1 Unit (λy :T 1.x)[x unit] λy :T 1.unit let x = 0 in succ(succ(succ x)) : Nat (succ(succ(succ x)))[x 0] succ(succ(succ 0)) 7

9 PAIRS Pair type values are pairs of values: t ::=... {t, t} terms: pair t.1 first projection t.2 second projection v ::=... {v, v} T ::=... T T values: pair values types: product type 8

10 PAIRS Pair evaluation: E-PAIRBETA1 {v 1, v 2 }.1 v 1 E-PAIRBETA2 {v 1, v 2 }.2 v 2 E-PROJ1 t 1 t 1 t 1.1 t 1.1 E-PAIR1 t 1 t 1 {t 1, t 2 } {t 1, t 2 } E-PROJ1 t 1 t 1 t 1.2 t 1.2 E-PAIR2 t 2 t 2 {v 1, t 2 } {v 1, t 2} 9

11 PAIRS Pair typing: T-PAIR Γ t 1 : T 1 Γ t 2 : T 2 Γ {t 1, t 2 } : T 1 T 2 Γ t : T 1 T 2 Γ t.1 : T 1 Γ t : T 1 T 2 Γ t.2 : T 2 Pairs can be naturally extended to tuples of n values, but we are not going to do this. 10

12 PAIR EXAMPLES {pred 4, if true then false else false}.1 : Nat {3, if true then false else false}.1 {3, false}.1 3 (λx:nat Nat. x.2) {pred 4, pred 5} : Nat (λx:nat Nat. x.2) {3, pred 5} (λx:nat Nat. x.2) {3, 4} {3, 4}

13 RECORDS Record type values are records of labelled values: t ::=... terms: t.l v ::=... T ::=... {l i = t i i 1..n } record projection values: {l i = v i i 1..n } record values types: {l i :T i 1..n i } type of records Example: {x = true, y = 0} : {x:bool, y :Nat} 12

14 RECORDS Record evaluation: E-PROJRCD {l i = v i i 1..n }.l j v j E-PROJ t t t.l t.l E-RCD t j t j {..., l j = t j,...} {..., l j = t j,...} Note that records are very eager. We evaluate the whole record even if we need just one value. 13

15 RECORDS Record typing: T-RCD for each i: Γ t i : T i Γ {l i = t i i 1..n } : {l i :T i i 1..n } T-PROJ Γ t : {l i :T i i 1..n } Γ t.l j : T j Eventhough it looks scary, the rules are essentialy same as with pairs. 14

16 RECORD USAGE Our records are a bit more powerful than usual, since they may contain functions. Thus we can define very simple objects: MyObject = {state: MyState, method1: MyState {Nat, MyState}, method2:mystate Nat {Bool, MyState}, method3: MyState {String, MyState}} Of course to use such objects we would have to every time give them the state, and then update it (pseudocode): x.state = (x.method2 (x.state) 8).2 15

17 TUPLES Now we can define tuples as derived forms: {t i i 1..n } := {i = t i i 1..n } so for example {1, true, λx:nat. x} := {1 = 1, 2 = true, 3 = λx:nat. x} : {1 = Nat, 2 = Bool, 3 = Nat Nat} Of course in this case tuple type will be a special case of record type. 16

18 VARIANTS AND SUMS Variant types have several alternatives. Typically such a type comes with tagging functions and case expression. In Haskell data VarType = VarBool Bool VarInt Int VarString String case x of VarBool b -> tointeger b VarInt i -> i VarString s -> length s In XML Schema variants correspond to <xsd:choice> element. 17

19 SUM SYNTAX Sum type values are one of two alternative types: t ::=... inl t inr t case t of (inl x 1 ) t (inr x 2 ) t v ::=... inl v inr v T ::=... T + T terms: left tag right tag case values: left tagged value right tagged value types: sum type 18

20 SUM EXAMPLES OptionalNat = Unit + Nat div = λm:nat. λn:nat. if n = 0 then (inl unit) else (inr m/n ) 19

21 SUM EVALUATION Sum evaluation: E-CASEINL case (inl v 1 ) of (inl x 1 ) t 1 (inr x 2 ) t 2 [x 1 v 1 ]t 1 E-CASEINL case (inr v 2 ) of (inl x 1 ) t 1 (inr x 2 ) t 2 [x 2 v 2 ]t 2 E-CASE t 0 t 0 case t 0 of (inl x 1 ) t 1 (inr x 2 ) t 2 case t 0 of (inl x 1 ) t 1 (inr x 2 ) t 2 E-INL t t inl t inl t E-INR t t inr t inr t 20

22 SUM TYPING Sum typing: T-INL Γ t : T 1 Γ inl t : T 1 + T 2 T-INR Γ t : T 2 Γ inr t : T 1 + T 2 T-CASE Γ t 0 : T 1 + T 2 Γ, x 1 :T 1 t 1 : T Γ, x 2 :T 2 t 2 : T Γ case t 0 of (inl x 1 ) t 1 (inr x 2 ) t 2 : T 21

23 SUM USAGE Booleans: Bool = Unit + Unit true = inl unit false = inr unit ifthenelse = λb:bool.λl :Nat.λr :Nat. case b of (inl x 1 ) l (inr x 2 ) r l and r types are a bit too specific at the moment. Optional type (Maybe in Haskell): OptionalNat = Unit + Nat 22

24 SUM TYPES, REVISITED Although sum types are useful, we have lost the uniqueness of typing: inl 0 : Nat + T, for any T To remedy this we will require ascription: inl 0 as Nat + Bool : Nat + Bool t ::=... inl t as T inr t as T terms: left tag right tag The only change in the rules is that typing will assume ascription types. 23

25 VARIANT SYNTAX Variant type values are one of many alternative types: t ::=... terms: l = t as T left tag i 1..n case t of l i = x i t i v ::=... T ::=... case values: l j = v j as T right tagged value types: l i : T i i 1..n variant type Essentially sums extended to many alternatives. 24

26 VARIANT EXAMPLES Student = student = String, masterstudent = String, doctorstudent = String student = Toomas Römer as Student masterstudent = Jevgeni Kabanov as Student doctorstudent = Vesal Vojdani as Student studentname = λx:student. case x of student = x 1 x 1 masterstudent = x 2 x 2 doctorstudent = x 3 x 3 25

27 VARIANT EVALUATION Variant evaluation: E-CASEVARIANT case ( l j = v j as T ) of l i = x i t i i 1..n t j [x j v j ] E-CASE t 0 t 0 case t 0 of l i = x i t i i 1..n case t 0 of l i = x i t i i 1..n E-VARIANT t j t j l j = t j as T l j = t j as T Essentially same as with sums. 26

28 VARIANT TYPING Variant typing: T-VARIANT Γ t j : T j Γ l j = t j as l i : T i i 1..n : l i : T i i 1..n T-CASE Γ t 0 : l i : T i i 1..n for each i: Γ, x i :T i t i : T Γ case t 0 of l i = x i t i i 1..n : T 27

29 VARIANT USAGE Variant use cases: Enumerations: Weekday = monday:unit, tuesday:unit, wednesday:unit, thursday:unit, friday:unit, Single-field variants: Euros = euros:float Dollars = dollars: Float euros2dollars : Euros Dollars 28

30 FIXPOINT AND RECURSION Since we broke fixpoints when typing lambda, let s bring them back as a language construct: t ::=... fix t terms: fixed point of t Fixpoint evaluation: E-FIXBETA fix (λf :T 1.t) [f (fix (λf :T 1.t))]t E-FIX t t fix t fix t Fixpoint typing: E-FIX Γ t 1 : T 1 T 1 Γ fix t 1 : T 1 29

31 FIXPOINT AND RECURSION However programming with fixpoints is not very comfortable, we d like to do this: letrec factorial :Nat Nat = λn:nat.if n = 0 then 1 else n factorial (n 1) in {factorial 10, factorial 21} Turns out we can finally do this by defining a derived form: letrec x:t 1 = t 1 in t 2 := let x = fix (λx:t 1.t 1 ) in t 2 30

32 FIXPOINT EXAMPLE letrec factorial :Nat Nat = λn:nat.if n = 0 then 1 else n factorial (n 1) in {factorial 10, factorial 21} = let factorial = fix (λ(factorial):nat Nat. λn:nat.if n = 0 then 1 else n factorial (n 1)) in {factorial 10, factorial 21} 31