Organization of Programming Languages (Midterm Review) Hongwei Xi 2/16/2019 Hongwei Xi

Inductive Reasoning Mathematical Induction Base step: establishing P(0) Inductive Step: establishing that P(n) implies P(n+1) for every natural number n Conclusion: P(n) holds for every natural number n 2/16/2019 Hongwei Xi

Inductive Reasoning Inductive definition Rule based Each rule has one conclusion and finitely many (possibly zero) premisses 2/16/2019 Hongwei Xi

Inductive Reasoning Structural Induction Proving properties on inductively defined structures Inductive step: establishing P for a term t while assuming that P holds for each *immediate* substructure of t 2/16/2019 Hongwei Xi

UFPL An Untyped Functional Programming Language Booleans b := true | false Integers i := . . . | -2 | -1 | 0 |1 | 2 | . . . Expressions e := x | b | I | op (e1,…, en) | if e then e1 else e2 fi | <> | <e1, e2> | fst(e) | snd (e) | fun f(x) is e | app(e1, e2) | let x = e1 in e2 end 2/16/2019 Hongwei Xi

UFPL Free variables: FV(e) Bound variables: Substitution: fun f(x) is e let x = e1 in e2 end Substitution: Protect bound variables from being substituted for Avoid capturing free variables 2/16/2019 Hongwei Xi

UFPL alpha-conversion fun f(x) is e  fun f’(x’) is e[f->f’][x->x’] let x = e1 in e2 end  let x’ = e1 in e2[x->x’] end Values v := x | b | i | <> | <v, v> | fun f(x) is v 2/16/2019 Hongwei Xi

UFPL Dynamic Semantics Evaluation Semantics (big-step) Presentation is straightforward Cannot distinguish non-termination from type errors Not suitable for compilation Reduction Semantics (small-step) Presentation is more involved Can distinguish non-termination from type errors Can lead to efficient implementation 2/16/2019 Hongwei Xi

UFPL: Evaluation Semantics Evaluation Rules ------- ----- b | b i | i e1 | v1 … en | vn op (v1,…,vn) = v ----------------------------------- op (e1,…,en) | v 2/16/2019 Hongwei Xi

UFPL: Evaluation Semantics Evaluation Rules e | true e1 | v --------------------------- if e then e1 else e2 fi | v e | false e2 | v --------------------------- if e then e1 else e2 fi | v 2/16/2019 Hongwei Xi

UFPL: Evaluation Semantics Evaluation Rules e1 | v1 e2 | v2 -------- ------------------ <> | <> <e1, e2> | <v1, v2> e | <v1, v2> e | <v1, v2> ------------ ------------ fst(e) | v1 snd(e) | v2 2/16/2019 Hongwei Xi

UFPL: Evaluation Semantics Evaluation Rules -------------------------------- fun f(x) is e | fun f(x) is e e1 | fun f(x) is e e2 | v2 e[f -> fun f(x) is e, x -> v2] ------------------------------- app(e1, e2) | v 2/16/2019 Hongwei Xi

UFPL: Evaluation Semantics Evaluation Rules e1 | v1 e2[x -> v1] --------------------------- let x = e1 in e2 end | v 2/16/2019 Hongwei Xi

UFPL: Reduction Semantics Redexes: op(v1,…,vn) -> v (v is the result of op(v1,…,vn)) if true then e1 else e2 fi -> e1 if false then e1 else e2 fi -> e2 fst(<v1, v2>) -> v1 snd(<v1, v2>) -> v2 2/16/2019 Hongwei Xi

UFPL: Reduction Semantics Redexes: app(fun f(x) is e, v) -> e[f -> fun f(x) is e, x -> v] let x = v in e end -> e[x -> v] 2/16/2019 Hongwei Xi

UFPL: Reduction Semantics Evaluation Contexts E := [] | op (v,…,v,E, e1,…,en) | if E then e else e | <E, e> | <v, E> | fst(E) | snd(E) | app(E, e) | app(v, E) | let x=E in e end e1 -> e2 if e1 = E[r] and e2 = E[e], where e is the reduction of r. 2/16/2019 Hongwei Xi

UFPL: Reduction Semantics Splitting: (E, r) is a splitting of e if E[r] = e. A value cannot have a splitting Each expression can have at most one splitting Many-step reduction ->*: e | v if and only if e ->* v 2/16/2019 Hongwei Xi

TFPL Typed functional programming language Types tau := bool | int | unit | tau * tau | tau -> tau Expressions e := … | fun f(x:tau):tau is e Type erasure: |e| is the result from erasing all the types in e 2/16/2019 Hongwei Xi

TFPL Dynamic Semantics Types are needed to be carried around during evaluation and reduction Types are indifferent to evaluation and reduction: e | v if and only if |e| | |v| e ->* v if and only if |e| ->* |v| 2/16/2019 Hongwei Xi

TFPL: Static Semantics Typing rules: ---------------------- Gamma |- b : bool --------------------- Gamma |- i : int Gamma(x) = tau ---------------------- Gamma |- x : tau 2/16/2019 Hongwei Xi

TFPL: Static Semantics Typing rules: Sigma(op) = tau1 * … * taun -> tau Gamma |- e1: tau1 … Gamma |- en : taun --------------------------------------------- Gamma |- op(e1,…,en) : tau ----------------- Gamma |- <> : 1 2/16/2019 Hongwei Xi

TFPL: Static Semantics Typing rules: Gamma |- e: bool Gamma |- e1: tau Gamma |- e2: tau --------------------------------------------- Gamma |- if e then e1 else e2 fi: tau Gamma |- e1: tau1 Gamma |- e2: tau2 ----------------------------------------------- Gamma |- <e1, e2>: tau1 * tau2 2/16/2019 Hongwei Xi

TFPL: Static Semantics Typing rules: Gamma |- e: tau1 * tau2 ------------------------------- Gamma |- fst(e): tau1 Gamma |- e: tau1 * tau2 ------------------------------- Gamma |- snd(e): tau2 2/16/2019 Hongwei Xi

TFPL: Static Semantics Typing rules: Gamma, f:tau1 -> tau2, x: tau1 |- e: tau2 -------------------------------------------- Gamma |- fun f(x) is e: tau1 -> tau2 Gamma |- e1: tau1 -> tau2 Gamma |- e2: tau1 ----------------------------------------------- Gamma |- app(e1, e2): tau2 2/16/2019 Hongwei Xi

TFPL: Static Semantics Typing rules: Gamma |- e1: tau1 Gamma, x: tau1 |- e2: tau2 ----------------------------------------------- Gamma |- let x = e1 in e2 end: tau2 2/16/2019 Hongwei Xi

TFPL Subject Reduction: If Gamma |- e1: tau is derivable and e1 -> e2 holds, then Gamma |- e2: tau is also derivable. Type Preservation: If Gamma |- e: tau is derivable and e | v holds, then Gamma |- v: tau is also derivable. 2/16/2019 Hongwei Xi

TFPL Progress Theorem: Suppose that |- e: tau is derivable. Then e is either a value or e -> e’ holds for some e’. Milner’s Slogan: Well-typed Programs can never go wrong! 2/16/2019 Hongwei Xi