Types for References, Exceptions and Continuations. Review of Subtyping. Γ e:τ τ <:σ Γ e:σ. Annoucements. How s the midterm going?

Transcription

1 Types for References, Exceptions and Continuations Annoucements How s the midterm going? Meeting 21, CSCI 5535, Spring One-Slide Summary Review of Subtyping If τ is a subtype of σ then any expression of type τ can be used in a context that expects a σ; this is called subsumption. 4 Subsumption Formalize the requirements on subtyping Rule of subsumption If τ <: σ then an expression of type τ has type σ Γ e:τ τ <:σ Γ e:σ But now type safety may be in danger: If we say that int <: (int int) Then we can prove that 11 8 is well typed! There is a way to construct the subtyping relation to preserve type safety 5 Defining Subtyping The formal definition of subtyping is by inference rules for the judgment τ <: σ We start with subtyping on the base types e.g. int <: real or nat <: int These rules are language dependent and are typically based directly on types-as-sets arguments We then make subtyping a preorder (reflexive and transitive) τ 1 <:τ 2 τ 2 <:τ 3 τ <:τ τ 1 <:τ 3 Then we build-up subtyping for larger types 6 1

2 Subtyping for Functions Try τ <:σ τ <:σ So what do τ τ <:σ σ you think of Example Use: this rule? rounded_sqrt : R Z actual_sqrt : R R Since Z <: R, rounded_sqrt <: actual_sqrt So if I have code like this: float result = rounded_sqrt(5); // 2 I can replace it like this: float result = actual_sqrt(5); // 2.23 and everything will be fine. 7 Subtyping for Functions This rule is unsound Let Γ = f : int bool (and assume int <: real) We show using the above rule that Γ f 5.0 : bool But this is wrong since 5.0 is not a valid argument of f Γ f :int bool τ <:σ τ <:σ τ τ <:σ σ int<:real bool<:bool int bool<:real bool Γ f :real bool Γ f 5.0:bool Γ 5.0:real 8 Correct Function Subtyping We say that is covariant in the result type and contravariant in the argument type Informal correctness argument: Pick f : τ τ σ<:τ τ <:σ τ τ <:σ σ f expects an argument of type τ It also accepts an argument of type σ <: τ f returns a value of type τ Which can also be viewed as a σ (since τ <: σ ) End of Review On to Midterm Hints: References Hence f can be used as σ σ 9 Types for Imperative Features So far: types for pure functional languages Now: types for imperative features Such types are used to characterize non-local effects assignments exceptions Contextual semantics is useful here Just when you thought it was safe to forget it 11 References Such types are used for mutable memory cells Syntax (as in ML) e ::=... ref e : τ e 1 := e 2! e τ ::=... τ ref ref e : τ - evaluates e, allocates a new memory cell, stores the value of e in it and returns the address of the memory cell like malloc + initialization in C, or new in C++ and Java e 1 := e 2, evaluates e 1 to a memory cell and updates its value with the value of e 2! e - evaluates e to a memory cell and returns its contents 12 2

3 Global Effects, Reference Cells A reference cell can escape the static scope where it was created (λf:int int ref.!(f 5)) (λx:int. ref x : int) The value stored in a reference cell must be visible from the entire program The result of an expression must now include the changes to the heap that it makes (cf. IMP s opsem) To model reference cells we must extend the evaluation model 13 Modeling References A heap is a mapping from addresses to values h ::= h, a v : τ a Addresses, tag the heap cells with their types Types are useful only for static semantics. They are not needed for the evaluation, that is, are not a part of the implementation We call a program an expression with a heap p ::= heap h in e The initial program is heap in e Heap addresses act as bound variables in the expression This is a trick that allows easy reuse of properties of local variables for heap addresses e.g., we can rename the address and its occurrences at will 14 Static Semantics of References Contextual Semantics for References Rules for expressions: Γ e:τ Γ (refe:τ):τ ref Γ e 1 :τ ref Γ e 2 :τ Γ e 1 :=e 2 :unit Γ e:τ ref Γ!e:τ Rules for programs (new judgment): Γ v i :τ i (i=1...n) Γ e:τ heaphine:τ whereγ=a 1 :τ 1 ref,...,a n :τ n ref andh=a 1 v 1 :τ 1,...,a n v n :τ n 15 Addresses are values: v ::=... a New contexts: H ::= ref H H 1 := e 2 a 1 := H 2! H No new local reduction rules But some new global reduction rules heap h in H[ref v : τ] heap h, a v : τ in H[a] where a is fresh (this models allocation the heap is extended) heap h in H[! a] heap h in H[v] where a v : τ h (heap lookup can we get stuck?) heap h in H[a := v] heap h[a v] in H[*] where h[a v] means a heap like h except that the part a v 1 : τ in h is replaced by a v : τ (memory update) Global rules are used to propagate the effects of a write to the entire program (eval order matters!) 16 Contextual Semantics for References Example with References Addresses are values: v ::=... a New contexts: H ::= ref H H 1 := e 2 a 1 := H 2! H No new local reduction rules But some new global reduction rules heap h in H[ref v : τ] heap h, a v : τ in H[a] where a is fresh (this models allocation the heap is extended) heap h in H[! a] heap h in H[v] where a v : τ h (heap lookup can we get stuck?) heap h in H[a := v] heap h[a v] in H[*] where h[a v] means a heap like h except that the part a v 1 : τ in h is replaced by a v : τ (memory update) Global rules are used to propagate the effects of a write to the entire program (eval order matters!) 17 Consider these (the redex is underlined) heap in (λf:int int ref.!(f 5)) (λx:int. ref x : int) heap in!((λx:int. ref x : int) 5) heap in!(ref 5 : int) heap a = 5 : int in!a heap a = 5 : int in 5 The resulting program has a useless memory cell An equivalent result would be heap in 5 This is a simple way to model garbage collection 18 3

4 Subtyping for References? τ ref<:τ ref Midterm Exercise 5 Give a sound subtyping rule or explain why OR Say there is no sound rule and show potential rules are unsound Exceptions and Continuations 19 One-Slide Summary Exceptions are like non-local gotos; they are used to propagate errors. We will use contextual semantics to model them. Continuations allow you to take a snapshot of the current execution and store it for later use. They are often used for threads or backtracking. We will use contextual semantics to model them. Exceptions A mechanism that allows non-local control flow Useful for implementing the propagation of errors to caller Exceptions ensure* that errors are not ignored Compare with the manual error handling in C Languages with exceptions: C++, ML, Modula-3, Java, C#, We assume that there is a special type exn of exceptions exn could be int to model error codes In Java or C++, exn are special object types 21 * Supposedly. 22 Modeling Exceptions Syntax e ::=... raise e try e 1 handle x e 2 τ ::=... exn We ignore how exception values are created In examples we will use integers as exception values The handler binds x in e 2 to the actual exception value The raise expression never returns to the immediately enclosing context 1 + raise 2 is well-typed if (raise 2) then 1 else 2 is also well-typed (raise 2) 5 is also well-typed What should be the type of raise? 23 Example with Exceptions A (strange) factorial function let f = λx:int.λres:int. if x = 0 then raise res else f (x - 1) (res * x) in try f 5 1 handle x x The function returns in one step from the recursion The top-level handler catches the exception and turns it into a regular result 24 4

5 Typing Exceptions New typing rules Γ raisee:τ Γ trye 1 handlex= e 2 :τ 25 Typing Exceptions New typing rules Γ e:exn Γ raisee:τ Γ e 1 :τ Γ,x:exn e 2 :τ Γ trye 1 handlex= e 2 :τ A raise expression has an arbitrary type This is a clear sign that the expression does not return to its evaluation context The type of the body of try and of the handler must match Just like for conditionals 26 Dynamics of Exceptions Contexts for Exceptions For big-step, the result of evaluation can be an uncaught exception Evaluation answers: a ::= v uncaught v uncaught v has an arbitrary type remember HW2 For small-step, it is convenient to use contextual semantics Exceptions propagate through some contexts but not through others We distinguish the handling contexts that intercept exceptions (this will be new) 27 Contexts H :: = H e v H raise H try H handle x e Propagating contexts Contexts that propagate exceptions to their own enclosing contexts P ::= P e v P raise P (New) Decomposition theorem If e is not a value and e is well-typed then it can be decomposed in exactly one of the following ways: H[(λx:τ. e) v] (normal lambda calculus) H[try v handle x e] (handle it or not) H[try P[raise v] handle x e] (propagate!) P[raise v] (uncaught exception) 28 Exceptional Commentary The addition of exceptions preserves type soundness Exceptions are like non-local goto However, they cannot be used to implement recursion Thus we still cannot write (well-typed) nonterminating programs There are a number of ways to implement exceptions (e.g., zero-cost exceptions) 29 Continuations Some languages have a mechanism for taking a snapshot of the execution and storing it for later use Later the execution can be reinstated from the snapshot Useful for implementing threads, for example Examples: Scheme, LISP, ML, C (yes, really!) 30 5

6 Continuations Consider the expression: e 1 + e 2 in a context C How to express a snapshot of the execution right after evaluating e 1 but before evaluating e 2 and the rest of C? Idea: as a context C 1 = C [ + e 2 ] Alternatively, as λx 1. C [ x 1 + e 2 ] When we finish evaluating e 1 to v 1, we fill the context and continue with C[v 1 + e 2 ] But the C 1 continuation is still available and we can continue several times, with different replacements for e 1 31 Continuation Uses in Real Life You re walking and come to a fork in the road You save a continuation right for going right But you go left (with the right continuation in hand) You encounter Bender. Bender coerces you into joining his computer dating service. You save a continuation bad-date for going on the date. You decide to invoke the right continuation So, you go right (no evil date obligation, but with the baddate continuation in hand) A train hits you! On your last breath, you invoke the bad-date continuation 32 For Next Time Optional reading: Goodenough s classic paper on exception handling 33 6