Dependent interoperability

Abstract

In this paper we study the problem of interoperability -combining constructs from two separate programming languages within one program -in the case where one of the two languages is dependently typed and the other is simply typed. We present a core calculus called SD, which combines dependentlyand simply-typed sub-languages and supports user-defined (dependent) datatypes, among other standard features. SD has "boundary terms" that mediate the interaction between the two sub-languages. The operational semantics of SD demonstrates how the necessary dynamic checks, which must be done when passing a value from the simply-typed world to the dependently typed world, can be extracted from the dependent type constructors themselves, modulo user-defined functions for marshaling values across the boundary. We establish type-safety and other meta-theoretic properties of SD, and contrast this approach to others in the literature. Disciplines Disciplines Engineering Comments CommentsAbstract In this paper we study the problem of interoperability-combining constructs from two separate programming languages within one program-in the case where one of the two languages is dependently typed and the other is simply typed. We present a core calculus called SD, which combines dependentlyand simply-typed sub-languages and supports user-defined (dependent) datatypes, among other standard features. SD has "boundary terms" that mediate the interaction between the two sub-languages. The operational semantics of SD demonstrates how the necessary dynamic checks, which must be done when passing a value from the simply-typed world to the dependently typed world, can be extracted from the dependent type constructors themselves, modulo user-defined functions for marshaling values across the boundary. We establish type-safety and other meta-theoretic properties of SD, and contrast this approach to others in the literature.Lemma 19 (Substitution through types). If Γ T 1 : K and Γ t 2 ∼ = t 2 and y 2 ∈ dom (Γ), then Γ [t 2 /y 2 ]T 1 ≡ [t 2 /y 2 ]T 1 .Proof. Induction on the derivation of Γ, y:T 2 T 1 : K . The cases are Case wf dty arr: The rule looks like Γ T 1 : * Γ, y:T 1 T 2 : * Γ (y : T 1 ) → T 2 : * wf dty arrSince y is a bound variable we can pick it to be different from y 2 and push the substitution in, so we must show Γ (y :By eq dty pi it suffices to show Γ 1 , y :T 2 [t 2 /y 2 ]T 1 ≡ [t 2 /y 2 ]T 1 and Γ 1 [t 2 /y 2 ]T 2 ≡ [t 2 /y 2 ]T 2 , both of which follow by IH (noting again that y 2 = y).Case wf dty pair: Similar to the previous case.Case wf dty data: We must show Γ [t 2 /y 2 ]B ≡ [t 2 /y 2 ]B , that is to say, Γ B ≡ B . This follows by eq dty trefl.Case wf dty unit: Similar to the previous case. 41Case wf dty app: The rule looks like Γ T : T 1 ⇒ * Γ t : T 1 Γ T t : * wf dty app By distributing the substitution and using eq dty app, it suffices to show Γ [t 2 /y 2 ]T ≡ [t 2 /y 2 ]T (which is direct by IH) and Γ [t 2 /y 2 ]t ∼ = [t 2 /y 2 ]t (which is by eq dtm subst).Lemma 20 (Context conversion (types)). Suppose Γ T 1 ≡ T 2 and...

Approximate normalization for gradual dependent types

“…Tanter and Tabareau [2015] develop a cast framework for subset types in Coq, allowing one to assert a term of type A to have the subset type {a : A | P a} for any decidable (or checkable) property P. They use an axiom to represent cast errors. Osera et al [2012] present dependent interoperability as a multi-language approach to combine both typing disciplines, mediated by runtime checks. Building on the subset cast framework (reformulated in a monadic setting instead of using axiomatic errors), Dagand et al [2016Dagand et al [ , 2018 revisit dependent interoperability in Coq via typetheoretic Galois connections that allow automatic lifting of higher-order programs.…”

Foundations of dependent interoperability

“…As far as we know, the term dependent interoperability was originally coined by Osera et al (2012) as a particularly challenging case of multi-language semantics between a dependently-typed and a simply-typed language. The concept of multi-language semantics was initially introduced by Findler and Felleisen (2007) to capture the interactions between a simply-typed calculus and a uni-typed calculus (where all closed terms have the same unique type).…”

“…Compared to previous work on gradual typing, dependent interoperability is challenging because the properties captured by type indices can be semantically complex. Also, because indices are strongly tied to specific constructors, coercion requires marshaling (Osera et al, 2012). This contrasts with casts, which typically only check tags at first-order types and produce wrappers for function types.…”

“…The safe interaction between the simple and dependent type disciplines relies on a marshaling mechanism to convert values from one world to the other, as well as dynamic checks, to ensure that the properties stated by the dependent type system are respected by the simply-typed values injected in dependent types. 1 Following Osera et al (2012), we illustrate the typical use cases of dependent interoperability using the stereotypical example of simply-typed lists and dependently-typed vectors. For conciseness, we fix the element type of lists and vectors to natural numbers and use the type synonyms List N and Vec N n, where n denotes the length of the vector.…”

Fab ous Interoperability for ML and a Linear Language

“…Our multi-language semantics builds on the seminal work by Matthews and Findler [2009], who gave a formal semantics of interoperability between a dynamically and a statically typed language. Others have followed the Matthews-Findler approach of designing multi-language systems with fine-grained boundaries-for instance, formalizing interoperability between a simply and dependently typed language [Osera, Sjöberg, and Zdancewic, 2012]; between a functional and typed assembly language [Patterson, Perconti, Dimoulas, and Ahmed, 2017]; between an ML-like and an affinely typed language, where linearity is enforced at runtime on the ML side using stateful contracts [Tov and Pucella, 2010]; and between the source and target languages of compilation to specify compiler correctness [Perconti and Ahmed, 2014]. However, all these papers address only the question of soundness of the multi-language; we propose a formal treatment of usability and absence of abstraction leaks.…”