2006 Scheme and Functional Programming Papers, University of

More documents

Recommendations

Info

[34] J. C. Reynolds. Types, abstraction and parametric polymorphism. In R. E. A. Mason, editor, Information Processing 83, pages 513–523, Amsterdam, 1983. Elsevier Science Publishers B. V. (North-Holland). [35] J. Riely and M. Hennessy. Trust and partial typing in open systems of mobile agents. In POPL ’99: Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages, pages 93–104, New York, NY, USA, 1999. ACM Press. [36] M. Serrano. Bigloo: a practical Scheme compiler. Inria- Rocquencourt, April 2002. [37] A. Shalit. The Dylan reference manual: the definitive guide to the new object-oriented dynamic language. Addison Wesley Longman Publishing Co., Inc., Redwood City, CA, USA, 1996. [38] Z. Shao. Flexible representation analysis. In ICFP ’97: Proceedings of the second ACM SIGPLAN international conference on Functional programming, pages 85–98, New York, NY, USA, 1997. ACM Press. [39] J. Siek and W. Taha. Gradual typing: Isabelle/isar formalization. Technical Report TR06-874, Rice University, Houston, Texas, 2006. [40] S. Thatte. Quasi-static typing. In POPL ’90: Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages, pages 367–381, New York, NY, USA, 1990. ACM Press. [41] D. Volpano and G. Smith. Eliminating covert flows with minimum typings. In CSFW’97: 10th Computer Security Foundations Workshop, volume 00, page 156, Los Alamitos, CA, USA, 1997. IEEE Computer Society. [42] M. Wenzel. The Isabelle/Isar Reference Manual. TU München, April 2004. 92 Scheme and Functional Programming, 2006
Sage: Hybrid Checking for Flexible Specifications Jessica Gronski † Kenneth Knowles † Aaron Tomb † Stephen N. Freund ‡ Cormac Flanagan † † University of California, Santa Cruz ‡ Williams College Abstract Software systems typically contain large APIs that are informally specified and hence easily misused. This paper presents the Sage programming language, which is designed to enforce precise interface specifications in a flexible manner. The Sage type system uses a synthesis of the type Dynamic, first-class types, and arbitrary refinement types. Since type checking for this expressive language is not statically decidable, Sage uses hybrid type checking, which extends static type checking with dynamic contract checking, automatic theorem proving, and a database of refuted subtype judgments. 1. Introduction Constructing a large, reliable software system is extremely challenging, due to the difficulty of understanding the system in its entirety. A necessary strategy for controlling this conceptual complexity is to divide the system into modules that communicate via clearly specified interfaces. The precision of these interface specifications may naturally and appropriately evolve during the course of software development. To illustrate this potential variation, consider the following specifications for the argument to a function invertMatrix: 1. The argument can be any (dynamically-typed) value. 2. The argument must be an array of arrays of numbers. 3. The argument must be a matrix, that is, a rectangular (non-ragged) array of arrays of numbers. 4. The argument must be a square matrix. 5. The argument must be a square matrix that satisfies the predicate isInvertible. All of these specifications are valid constraints on the argument to invertMatrix, although some are obviously more precise than others. Different specifications may be appropriate at different stages of the development process. Simpler specifications facilitate rapid prototyping, whereas more precise specifications provide more correctness guarantees and better documentation. Traditional statically-typed languages, such as Java, C#, and ML, primarily support the second of these specifications. Dynamically-typed languages such as Scheme primarily support the first specification. Contracts [32, 13, 26, 21, 24, 28, 37, 25, 12, 8] provide a means to document and enforce all of these specifications, but violations are only detected dynamically, resulting in incomplete and late (possibly post-deployment) detection of defects. This paper presents the Sage programming language and type system, Proceedings of the 2006 Scheme and Functional Programming Workshop University of Chicago Technical Report TR-2006-06 which is designed to support and enforce a wide range of specification methodologies. Sage verifies correctness properties and detects defects via static checking wherever possible. However, Sage can also enforce specifications dynamically, when necessary. On a technical level, the Sage type system can be viewed as a synthesis of three concepts: the type Dynamic; arbitrary refinement types; and first-class types. These features add expressive power in three orthogonal directions, yet they all cooperate neatly within Sage’s hybrid static/dynamic checking framework. Type Dynamic. The type Dynamic [23, 1, 39] enables Sage to support dynamically-typed programming. Dynamic is a supertype of all types; any value can be upcast to type Dynamic, and a value of declared type Dynamic can be implicitly downcast (via a run-time check) to a more precise type. Such downcasts are implicitly inserted when necessary, such as when the operation add1 (which expects an Int) is applied to a variable of type Dynamic. Thus, declaring variables to have type Dynamic (which is the default if type annotations are omitted) leads to a dynamically-typed, Scheme-like style of programming. These dynamically-typed programs can later be annotated with traditional type specifications like Int and Bool. One nice aspect of our system is that the programmer need not fully annotate the program with types in order to reap some benefit. Types enable Sage to check more properties statically, but it is still able to fall back to dynamic checking whenever the type Dynamic is encountered. Refinement Types. For increased precision, Sage also supports refinement types. For example, the following code snippet defines the type of integers in the range from lo (inclusive) to hi (exclusive): { x:Int | lo
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 50 and 51: 50 Scheme and Functional Programmin
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 70 and 71: 70 Scheme and Functional Programmin
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 84 and 85: Before describing the run-time sema
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 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?