Foundations of path-dependent types

Abstract

A scalable programming language is one in which the same concepts can describe small as well as large parts. Towards this goal, Scala unifies concepts from object and module systems. An essential ingredient of this unification is the concept of objects with type members, which can be referenced through path-dependent types. Unfortunately, path-dependent types are not well-understood, and have been a roadblock in grounding the Scala type system on firm theory. We study several calculi for path-dependent types. We present DOT which captures the essence - DOT stands for Dependent Object Types. We explore the design space bottom-up, teasing apart inherent from accidental complexities, while fully mechanizing our models at each step. Even in this simple setting, many interesting patterns arise from the interaction of structural and nominal features. Whereas our simple calculus enjoys many desirable and intuitive properties, we demonstrate that the theory gets much more complicated once we add another Scala feature, type refinement, or extend the subtyping relation to a lattice. We discuss possible remedies and trade-offs in modeling type systems for Scala-like languages.

Codata in Action

“…Our work follows in spirit of Amin et al's [3] desire to provide a minimal theory that can model type parameterization, modules, objects and classes. Another approach to combine type parameterization and modules is also offered by 1ML [36], which is mapped to System F. Amin et al's work goes one step further by translating System F to a calculus that directly supports objects and classes.…”

Decidable subtyping for path dependent types

“…The Dependent Object Types (DOT) calculus [Amin 2016;Amin et al , 2012Amin et al , 2014] is a core calculus that is intended to be the theoretical basis for Dotty 3 , itself a basis for the upcoming Scala 3. In DOT, a broad array of expressiveness arises from the core features of path dependent, intersection, recursive and dependent function types.…”

“…Type members were first introduced in BETA [ Kristensen et al 1987;Madsen and Moller-Pedersen 1989;Torgersen 1998], were briefly considered as an alternative to Generics in Java [Igarashi and Pierce 2002;Thorup 1997], and have gained additional prominence due to their inclusion in the Scala language [Odersky et al 2004; . Recently Amin et al have studied the Dependent Object Types (DOT) calculus as a sound core calculus for Scala [Amin et al 2012[Amin et al , 2014. The DOT calculus includes type members to model parametric polymorphism as well as a notion of nominality.…”

Type soundness proofs with definitional interpreters

“…The DOT (Dependent Object Types) calculus [6,7,5,45] has been proposed as a new type-theoretic foundation for blending functional and object-oriented programming, as well as ML modules, based on path-dependent types. Historically, DOT was designed as a formal model of Scala [6], based on various rewriting semantics, but very little progress was made towards a soundness proof.…”

“…This setting is very similar to issues that arise with path-dependent types in Scala and DOT, but here it surprisingly arises already when just looking at the runtime semantics of F<:. Since proving transitivity becomes much harder, we adopt a strategy from previous DOT developments [7]: admit transitivity as an axiom, but prove a 'pushback' lemma that allows to push uses of the axiom further up into a subtyping derivation, so that the top level becomes invertible. We denote this as precise subtyping T1 <!…”