Deriving interpretations of the gradually-typed lambda calculus

Abstract

Siek and Garcia (2012) have explored the dynamic semantics of the gradually-typed lambda calculus by means of definitional interpreters and abstract machines. The correspondence between the calculus's mathematically described small-step reduction semantics and the implemented big-step definitional interpreters was left as a conjecture. We prove and generalise Siek and Garcia's conjectures using program transformation. We establish the correspondence between the definitional interpreters and the reduction semantics of a closure-converted gradually-typed lambda calculus that unifies and amends various versions of the calculus. We use a layered approach and two-level continuation-passing style so that the correspondence is parametric on the subsidiary coercion calculus. We have implemented the whole derivation for the eager errordetection policy and the downcast blame-tracking strategy. The correspondence can be established for other choices of error-detection policies and blame-tracking strategies, by plugging in the appropriate artefacts for the particular subsidiary coercion calculus.

Parameterized cast calculi and reusable meta-theory for gradually typed lambda calculi

“…Researchers have discovered many choices regarding the design and formalization of gradually typed languages. For example, a language designer can choose between runtime casts that provide lazy, eager, or even partially eager semantics (Siek et al, 2009;García-Pérez et al, 2014). Alternatively, the designer might apply the methodology of Abstracting Gradual Typing (AGT) to derive the semantics (Garcia et al, 2016).…”

On Computational Small Steps and Big Steps: Refocusing for Outermost Reduction

“…By now the syntactic and functional correspondences have been independently used for discovery (when the result of the derivation is new), for rediscovery (when the result of the derivation turns out to be known already), or as a springboard (when the result of the derivation improves on something known or leads somewhere else): Anton and Thiemann used them to derive type systems and implementations for coroutines [5]; Danvy and Johannsen used them to derive the same abstract machine out of the small-step and big-step semantics of Abadi and Cardelli's calculus of objects [36]; Pirog and Biernacki used the functional correspondence to derive the STG machine out of Launchbury's natural semantics for lazy evaluation [96]; Sergey and Clarke used them to inter-derive type checking by reduction and type checking by evaluation [113]; Van Horn and Might use them to obtain the abstract machines they abstract to do static analysis [128]; Ariola et al used them to assess the unity of semantic artifacts for call-by-need sequent calculi [7]; Puech used the functional correspondence to connect natural deduction and the sequent calculus [101]; Jedynak et al used them to provide an operational foundation for the tactic language of Coq [72]; Simmons and Zerny presented a logical analogue of the functional correspondence to connect natural semantics and abstract machines [117]; Danvy and Zerny used them to connect syntactic theories of call by need and the Krivine machine with memo-thunks [45], and to connect Barendregt et al's term graph rewriting and Turner's abstract machine for combinatory graph reduction [46]; García-Pérez et al used them to derive interpretations of the gradually-typed λ-calculus [62]; and Bach Poulsen and Mosses used them to derive pretty-big-step semantics from small-step semantics [8].…”