Blame and coercion: Together again for the first time

Abstract

C#, Dart, Pyret, Racket, TypeScript, VB: many recent languages integrate dynamic and static types via gradual typing. We systematically develop four calculi for gradual typing and the relations between them, building on and strengthening previous work. The calculi are as follows: $\lambda{B}$ , based on the blame calculus of Wadler and Findler (2009); $\lambda{C}$ , inspired by the coercion calculus of Henglein (1994); $\lambda{S}$ inspired by the space-efficient calculus of Herman, Tomb, and Flanagan (2006); and $\lambda{T}$ based on the threesome calculus of Siek and Wadler (2010). While $\lambda{B}$ and $\lambda{T}$ are little changed from previous work, $\lambda{C}$ and $\lambda{S}$ are new. Together, $\lambda{B}$ , $\lambda{C}$ , $\lambda{S}$ , and $\lambda{T}$ provide a coherent foundation for design, implementation, and optimization of gradual types. We define translations from $\lambda{B}$ to $\lambda{C}$ , from $\lambda{C}$ to $\lambda{S}$ , and from $\lambda{S}$ to $\lambda{T}$ . Much previous work lacked proofs of correctness or had weak correctness criteria; here we demonstrate the strongest correctness criterion one could hope for, that each of the translations is fully abstract. Each of the calculi reinforces the design of the others: $\lambda{C}$ has a particularly simple definition, and the subtle definition of blame safety for $\lambda{B}$ is justified by the simple definition of blame safety for $\lambda{C}$ . Our calculus $\lambda{S}$ is implementation-ready: the first space-efficient calculus that is both straightforward to implement and easy to understand. We give two applications: first, using full abstraction from $\lambda{C}$ to $\lambda{S}$ to establish an equational theory of coercions; and second, using full abstraction from $\lambda{B}$ to $\lambda{S}$ to easily establish the Fundamental Property of Casts, which required a custom bisimulation and six lemmas in earlier work.

How to evaluate the performance of gradual type systems

“…Highcost types may be a symptom of inefficiencies in the translation from types to dynamic checks. Recent calculi for space-efficient contracts (Herman et al, 2010;Garcia, 2013;Greenberg, 2015Greenberg, , 2016Siek et al, 2015a) may provide insight for eliminating proxies. Storing runtime type information in the heap may prove to be more efficient than encoding it with contracts (Rastogi et al, 2015;Siek et al, 2015b).…”

Space-Efficient Latent Contracts

“…Space efficiency for gradual types [24] (a/k/a contracts constrained to type tests) is well studied [14,15,25,9,23]; Greenberg [11] developed a space-efficient semantics for general, non-dependent contracts. He used a manifest calculus, conflating contracts and types; however, contracts are typically implemented in latent calculi, where contracts are distinct from whatever types may exist.…”

Gradual session types

“…The four subtyping relations are closely related. In previous work (Wadler & Findler, 2009;Siek et al, 2015a) one has that proper subtyping decomposes into positive and negative subtyping, which-after reversing the order on negative subtyping-recompose into naive subtyping. Here we have three-quarters of the previous result.…”