Tracking Captured Variables in Types

TL;DR

This paper introduces a new type system extension, CF<:, that tracks variable references and escape behavior to improve safety guarantees in programming languages, with formal proofs and practical implications.

Contribution

It presents CF<:, a conservative extension of System F<: that tracks captured variables and references, enabling enhanced safety reasoning.

Findings

Embedded System F<: terms in CF<:

Expressiveness for capturing variable escape behaviors

Mechanized soundness proofs in Coq

Abstract

Type systems usually characterize the shape of values but not their free variables. However, there are many desirable safety properties one could guarantee if one could track how references can escape. For example, one may implement algebraic effect handlers using capabilities -- a value which permits one to perform the effect -- safely if one can guarantee that the capability itself does not escape the scope bound by the effect handler. To this end, we study the $\textrm{CF}_{<:}$ calculus, a conservative and lightweight extension of $\textrm{System F}_{<:}$, to track how values and their references can be captured and escape. We show that existing terms in $\textrm{System F}_{<:}$ embed naturally in our calculus, and that many natural problems can be expressed in a system that tracks variable references like we do in $\textrm{CF}_{<:}$. We also give mechanized proofs of the soundness properties of $\textrm{CF}_{<:}$ in Coq. The type system presented in $\textrm{CF}_{<:}$ is powerful enough to reason about safety in the context of many natural extensions of $\textrm{CF}_{<:}$ such as region-based memory-management, non-local returns, and effect handlers.