2006 Scheme and Functional Programming Papers, University of

More documents

Recommendations

Info

Before describing the run-time semantics of λ ? → we compare our type system for λ ? → with an alternative design based on subtyping. 3. Comparison with Quasi-Static Typing Our first attempt to define a gradual type system was based on Thatte’s quasi-static types [40]. Thatte uses a standard subtyping relation
(GREF) (GDEREF1) (GDEREF2) (GASSIGN1) Figure 4. Type Rules for References Γ ⊢ G e : τ Γ ⊢ G ref e : ref τ Γ ⊢ G e : ? Γ ⊢ G !e : ? Γ ⊢ G e : ref τ Γ ⊢ G !e : τ Γ ⊢ G e 1 : ? Γ ⊢ G e 2 : τ Γ ⊢ G e 1 ← e 2 : ref τ Γ ⊢ G e : τ 5. Run-time semantics We define the semantics for λ ? → in two steps. We first define a cast insertion translation from λ ? → to an intermediate language with explicit casts which we call λ 〈τ〉 → . We then define a call-by-value operational semantics for λ 〈τ〉 → . The explicit casts have the syntactic form 〈τ〉e where τ is the target type. When e evaluates to v, the cast will check that the type of v is consistent with τ and then produce a value based on v that has the type τ. If the type of v is inconsistent with τ, the cast produces a CastError. The intuition behind this kind of cast is that it reinterprets a value to have a different type either by adding or removing type information. The syntax of λ 〈τ〉 → extends that of λ ? → by adding a cast expression. Syntax of the intermediate language. e ∈ λ 〈τ〉 → (GASSIGN2) Γ ⊢ G e 1 : ref τ Γ ⊢ G e 2 : σ σ ∼ τ Γ ⊢ G e 1 ← e 2 : ref τ Expressions e ::= . . . | 〈τ〉e 4. Gradual Typing and References It is often challenging to integrate type system extensions with imperative features such as references with assignment. In this section we extend the calculus to include ML-style references. The following grammar shows the additions to the syntax. Adding references to λ ? → Types τ ::= . . . | ref τ Expressions e ::= . . . | ref e | !e | e ← e The form ref e creates a reference cell and initializes it with the value that results from evaluating expression e. The dereference form !e evaluates e to the address of a location in memory (hopefully) and returns the value stored there. The assignment form e ← e stores the value form the right-hand side expression in the location given by the left-hand side expression. Figure 4 shows the gradual typing rules for these three new constructs. In the (GASSIGN2) we allow the type of the right-hand side to differ from the type in the left-hand’s reference, but require the types to be compatible. This is similar to the (GAPP2) rule for function application. We do not change the definition of the consistency relation, which means that references types are invariant with respect to consistency. The reflexive axiom τ ∼ τ implies that ref τ ∼ ref τ. The situation is analogous to that of the combination of references with subtyping [32]: allowing variance under reference types compromises type safety. The following program demonstrates how a covariant rule for reference types would allow type errors to go uncaught by the type system. let r1 = ref (λ y. y) in let r2 : ref ? = r1 in r2 ← 1; !r1 2 The reference r1 is initialized with a function, and then r2 is aliased to r1, using the covariance to allow the change in type to ref ?. We can then write an integer into the cell pointed to by r2 (and by r1). The subsequent attempt to apply the contents of r1 as if it were a function fails at runtime. 5.1 Translation to λ 〈τ〉 → . The cast insertion judgment, defined in Figure 5, has the form Γ ⊢ e ⇒ e ′ : τ and mimics the structure of our gradual typing judgment of Figure 2. It is trivial to show that these two judgments accept the same set of terms. We presented the gradual typing judgment separately to provide an uncluttered specification of well-typed terms. In Figure 5, the rules for variables, constants, and functions are straightforward. The first rule for application (CAPP1) handles the case when the function has type ? and inserts a cast to τ 2 → ? where τ 2 is the argument’s type. The second rule for application (CAPP2) handles the case when the function’s type is known and the argument type differs from the parameter type, but is consistent. In this case the argument is cast to the parameter type τ. We could have instead cast the function; the choice was arbitrary. The third rule for application (CAPP3) handles the case when the function type is known and the argument’s type is identical to the parameter type. No casts are needed in this case. The rules for reference assignment are similar to the rules for application. However, for CASSIGN2 the choice to cast the argument and not the reference is because we need references to be invariant to preserve type soundness. Next we define a type system for the intermediate language λ 〈τ〉 → . The typing judgment has the form Γ|Σ ⊢ e : τ. The Σ is a store typing: it assigns types to memory locations. The type system, defined in Figure 6, extends the STLC with a rule for explicit casts. The rule (TCAST) requires the expression e to have a type consistent with the target type τ. The inversion lemmas for λ 〈τ〉 → are straightforward. Lemma 1 (Inversion on typing rules.). 1. If Γ | Σ ⊢ x : τ then Γ x = ⌊τ⌋. 2. If Γ | Σ ⊢ c : τ then ∆ c = τ. 3. If Γ | Σ ⊢ λ x:σ. e : τ then ∃ τ ′ . τ = σ → τ ′ . 4. If Γ | Σ ⊢ e 1 e 2 : τ ′ then ∃ τ. Γ | Σ ⊢ e 1 : τ → τ ′ ∧ Γ | Σ ⊢ e 2 : τ. 5. If Γ | Σ ⊢ 〈σ〉 e : τ then ∃ τ ′ . Γ | Σ ⊢ e : τ ′ ∧ σ = τ ∧ τ ′ ∼ σ. 6. If Γ | Σ ⊢ ref e : ref τ then Γ | Σ ⊢ e : τ. 7. If Γ | Σ ⊢ !e : τ then Γ | Σ ⊢ e : ref τ. 8. If Γ | Σ ⊢ e 1 ← e 2 : ref τ then Γ | Σ ⊢ e 1 : ref τ ∧ Γ | Σ ⊢ e 2 : τ. Scheme and Functional Programming, 2006 85
Page 1:
Scheme and Functional Programming 2
Page 4 and 5:
4 Scheme and Functional Programming
Page 6 and 7:
6 Scheme and Functional Programming
Page 8 and 9:
• A web browser that plays the ro
Page 10 and 11:
and requests. When a client request
Page 12 and 13:
above prevents pages from these dom
Page 14 and 15:
14 Scheme and Functional Programmin
Page 16 and 17:
2. Explaining Macros Macro expansio
Page 18 and 19:
For completeness, here is the macro
Page 20 and 21:
onment is extended in the original
Page 22 and 23:
expand-term(term, env, phase) = emi
Page 24 and 25:
Derivation ::= (make-mrule Syntax S
Page 26 and 27:
True derivation (before macro hidin
Page 28 and 29:
We assume that the reader has basic
Page 30 and 31:
the value of the %eax register by 4
Page 32 and 33:
Code generation for the new forms i
Page 34 and 35: we introduced in 3.11. The only dif
Page 36 and 37: the user code from interfering with
Page 38 and 39: 38 Scheme and Functional Programmin
Page 40 and 41: mization and on creating efficient
Page 42 and 43: (a) stage (b) fifo (c) split (d) me
Page 44 and 45: This tagging is used later in the c
Page 46 and 47: (let ((clo_25 (%closure (lambda (y)
Page 48 and 49: nb. cycles per element 1400 1200 10
Page 52 and 53: a ∗ ❅ left right · b ❅ a S
Page 54 and 55: T ([spec], w) = { {w}, if w ∈ L([
Page 56 and 57: A([spec]): ✓✏ (where L([spec])
Page 58 and 59: construction commands. It is possib
Page 60 and 61: ; Regular expression for Scheme num
Page 62 and 63: References [1] A. V. Aho, R. Sethi,
Page 64 and 65: (let ((n (cond ((char? var0) ) ((sy
Page 66 and 67: 3. Survey An incomplete survey of a
Page 68 and 69: case monster 10 literals 100 litera
Page 72 and 73: modest programming requirements, an
Page 74 and 75: development of incomplete subsystem
Page 76 and 77: the previous request. This method a
Page 78 and 79: could be run indefinitely. This fun
Page 80 and 81: programmers reject Scheme without r
Page 82 and 83: (define interp (λ (env e) (case e
Page 86 and 87: Figure 5. Cast Insertion Figure 6.
Page 88 and 89: Figure 7. Evaluation Figure 8. Eval
Page 90 and 91: catching type errors, as we do here
Page 92 and 93: [34] J. C. Reynolds. Types, abstrac
Page 94 and 95: let id (T:*) (x:T) : T = x; The tra
Page 96 and 97: Figure 3: Regular Expressions and N
Page 98 and 99: Figure 5: Evaluation Rules Evaluati
Page 100 and 101: 5. Exact Substitution: E, (x = v :
Page 102 and 103: Figure 9: Subtyping Algorithm Algor
Page 104 and 105: for most type variables, and that m
Page 106 and 107: 2. miniKanren Overview This section
Page 108 and 109: 3. Pseudo-Variadic Relations Just a
Page 110 and 111: Replacing run 10 with run ∗ cause
Page 112 and 113: As might be expected, we could use
Page 114 and 115: Of course there are still infinitel
Page 116 and 117: To ensure that streams produced by
Page 118 and 119: 118 Scheme and Functional Programmi
Page 120 and 121: On the other hand, we can use a hig
Page 122 and 123: (ev* (Q (lambda (x) (+ x 1)))) # >
Page 124 and 125: (term ’lam (lambda (x) (if (equal
Page 126 and 127: a message: there is no guarantee th
Page 128 and 129: (! (self) 3) (?) =⇒ 1 (?? odd?) =
Page 130 and 131: (define new-server (spawn (lambda (
Page 132 and 133: The abstraction shown in this secti
Page 134 and 135:
Erlang Termite List length (µs) (
Page 136 and 137:
136 Scheme and Functional Programmi
Page 138 and 139:
page of j contains the URL of the p
Page 140 and 141:
4. Solution The failed attempts abo
Page 142 and 143:
· ; · ; · :: Store × Frame Stac
Page 144 and 145:
logically creates a sub-session of
Page 146 and 147:
on this work, including Ryan Culpep
Page 148 and 149:
ing application operation. 1 As a r
Page 150 and 151:
such as image glyphs corresponding
Page 152 and 153:
Phone For clarity, this code pr
Page 154 and 155:
A. Porting TinyScheme to Qualcomm B
Page 156 and 157:
156 Scheme and Functional Programmi
Page 158 and 159:
ware installers have to install any
Page 160 and 161:
defines a module named circle-lib i
Page 162 and 163:
Figure 2. Sometimes special cases a
Page 164 and 165:
Considering all of these issues tog
show all

2006 Scheme and Functional Programming Papers, University of

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?