Intrinsically-typed definitional interpreters for linear, session-typed languages

Rouvoet, Arjen; Poulsen, Casper Bach; Krebbers, Robbert; Visser, Eelco

doi:10.1145/3372885.3373818

Cited by 26 publications

(31 citation statements)

References 32 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The typing guarantees from these definitional interpreters ensure syntactic type safety of reduction with respect to the classic type systems for the languages they study. More recently, Rouvoet et al (2020) give an intrinsically typed definitional interpreter for a linearly typed language, which bears some resemblance (owing to its linearity) to the structure of our interpreter for CSL. Our approach is similar to both these works in spirit, with two notable differences.…”

Section: Related Workmentioning

confidence: 99%

SteelCore: an extensible concurrent separation logic for effectful dependently typed programs

Swamy

Rastogi

Fromherz

et al. 2020

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Much recent research has been devoted to modeling effects within type theory. Building on this work, we observe that effectful type theories can provide a foundation on which to build semantics for more complex programming constructs and program logics, extending the reasoning principles that apply within the host effectful type theory itself. Concretely, our main contribution is a semantics for concurrent separation logic (CSL) within the F ★ proof assistant in a manner that enables dependently typed, effectful F ★ programs to make use of concurrency and to be specified and verified using a full-featured, extensible CSL. In contrast to prior approaches, we directly derive the partial-correctness Hoare rules for CSL from the denotation of computations in the effectful semantics of non-deterministically interleaved atomic actions. Demonstrating the flexibility of our semantics, we build generic, verified libraries that support various concurrency constructs, ranging from dynamically allocated, storable spin locks, to protocol-indexed channels. We conclude that our effectful semantics provides a simple yet expressive basis on which to layer domainspecific languages and logics for verified, concurrent programming.

show abstract

Section: Related Workmentioning

confidence: 99%

SteelCore: an extensible concurrent separation logic for effectful dependently typed programs

Swamy

Rastogi

Fromherz

et al. 2020

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…While context splitting relates more closely with the model (Section 4) and other presentations of linear and session calculi, leftovers allow for simpler mechanizations. Rouvoet et al [27] describe a technique inspired by separation logic to specify and verify in Agda interpreters using linear resources. Among the case studies they discuss is a linearly-typed lambda calculus with primitives for session communications.…”

Section: Related Workmentioning

confidence: 99%

A Dependently Typed Linear π-Calculus in Agda

Ciccone

Padovani

2020

Proceedings of the 22nd International Symposium on Principles and Practice of Declarative Programming

View full text Add to dashboard Cite

Session types have consolidated as a formalism for the specification and static enforcement of communication protocols. Many different theories of dependent session types have been proposed, some enabling refined specifications on the content of messages, others allowing the structure of the protocols to depend on data exchanged in the protocol itself. In this work we continue a line of research studying the foundations of binary session types. In particular, we propose a variant of the linear π-calculus whose type structure encompasses virtually all dependent session types using just two type constructors: linear channel types and linear dependent pairs. We use Agda not only to formalize the metatheory of the calculus and obtain machine-checked proofs of type soundness, but also as host language in which we implement data-dependent protocols.

show abstract

“…The costs consist of the burden that the proof imposes on the programmer and on the readability of the program. Previous work on intrinsically typed interpreters (for example [Augustsson and Carlsson 1999;Benton et al 2012;Poulsen et al 2018;Rouvoet et al 2020a]) has shown that intrinsically typed interpreters can sometimes achieve a favorable cost-benefit balance. In this paper we extend the state of the art to the definition of intrinsically typed compilers that target a low-level representation of bytecode with labels.…”

Section: Introductionmentioning

confidence: 99%

“…The co-context of the composition is simply the union of the exports and imports. Our representation is inspired by the nameless co-de-Bruijn representation of lexical binding by McBride [2018], and the nameless representation of linear references by Rouvoet et al [2020a].…”

Section: Introductionmentioning

confidence: 99%

“…This proof-relevant relation appears everywhere and is hard to manipulate by hand. To avoid this, we show that this relation forms a proof-relevant separation algebra (PRSA) [Rouvoet et al 2020a], which allows us to build an embedded separation logic to abstract over co-contexts and their compositions. This separation logic allows us to implement an intrinsically typed version of the compiler in Fig.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Intrinsically typed compilation with nameless labels

Rouvoet

Krebbers

Visser

2021

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

To avoid compilation errors it is desirable to verify that a compiler is type correct —i.e., given well-typed source code, it always outputs well-typed target code. This can be done intrinsically by implementing it as a function in a dependently typed programming language, such as Agda. This function manipulates data types of well-typed source and target programs, and is therefore type correct by construction. A key challenge in implementing an intrinsically typed compiler is the representation of labels in bytecode. Because label names are global, bytecode typing appears to be inherently a non-compositional, whole-program property. The individual operations of the compiler do not preserve this property, which requires the programmer to reason about labels, which spoils the compiler definition with proof terms. In this paper, we address this problem using a new nameless and co-contextual representation of typed global label binding, which is compositional. Our key idea is to use linearity to ensure that all labels are defined exactly once. To write concise compilers that manipulate programs in our representation, we develop a linear, dependently typed, shallowly embedded language in Agda, based on separation logic. We show that this language enables the concise specification and implementation of intrinsically typed operations on bytecode, culminating in an intrinsically typed compiler for a language with structured control-flow.

show abstract

Intrinsically-typed definitional interpreters for linear, session-typed languages

Cited by 26 publications

References 32 publications

SteelCore: an extensible concurrent separation logic for effectful dependently typed programs

SteelCore: an extensible concurrent separation logic for effectful dependently typed programs

A Dependently Typed Linear π-Calculus in Agda

Intrinsically typed compilation with nameless labels

Contact Info

Product

Resources

About