Type Universes as Allocation Effects

Abstract: In this paper, we explore a connection between type universes and memory allocation. Type universe hierarchies are used in dependent type theories to ensure consistency, by forbidding a type from quantifying over all types. Instead, the types of types (universes) form a hierarchy, and a type can only quantify over types in other universes (with some exceptions), restricting cyclic reasoning in proofs. We present a perspective where universes also describe \emph{where} values are allocated in the heap, and the choice of universe algebra imposes a structure on the heap overall. The resulting type system provides a simple declarative system for reasoning about and restricting memory allocation, without reasoning about reads or writes. We present a theoretical framework for equipping a type system with higher-order references restricted by a universe hierarchy, and conjecture that many existing universe algebras give rise to interesting systems for reasoning about allocation. We present 3 instantiations of this approach to enable reasoning about allocation in the simply typed $\lambda$-calculus: (1) the standard ramified universe hierarchy, which we prove guarantees termination of the language extended with higher-order references by restricting cycles in the heap; (2) an extension with an \emph{impredicative} base universe, which we conjecture enables full-ground references (with terminating computation but cyclic ground data structures); (3) an extension with \emph{universe polymorphism}, which divides the heap into fine-grained regions.

• The paper introduces a framework where type universes serve as a basis for declarative heap memory allocation, ensuring termination through acyclic references.
• The authors implement three models—ramified hierarchies, impredicative base, and universe polymorphism—to dynamically manage memory allocation in typed λ-calculus.
• The proposed system leverages step-indexed logical relations and stratified type levels to prevent cyclic dependencies and facilitate semantic garbage collection.

Type Universes as Allocation Effects

Introduction

The paper "Type Universes as Allocation Effects" discusses the association between type universe hierarchies and memory allocation effects in programming languages. The authors propose a novel perspective in which type universes not only serve to ensure logical consistency in dependent type theories but also define the allocation strategy on the heap. This framework offers a method to control memory allocation declaratively without explicitly reasoning about read and write operations.

Theoretical Framework

In traditional type systems, universes form a hierarchy, preventing types from quantifying over themselves, thus avoiding cyclic dependencies in proofs. However, this paper extends this concept by leveraging universes to influence memory management. The authors present a type system that prescribes where values are stored on the heap based on their universe levels. This approach introduces a method for managing higher-order references by imposing constraints via a universe hierarchy.

Implementation of the Type System

The authors detail three implementations of the framework within a simply typed $\lambda$-calculus:

1. Ramified Universe Hierarchy: Here, the universe hierarchy enforces an acyclic structure in the heap, ensuring termination by restricting cyclic dependencies typically arising in reference management.
2. Impredicative Base Universe: This variant introduces an impredicative base universe allowing for full-ground references while maintaining termination. This extension supports cyclic ground data structures without non-terminating execution paths.
3. Universe Polymorphism: This implementation distinguishes heap regions through universe polymorphism, allowing finer control over memory management by enabling static division of the heap into distinct regions.

Detailed Examination of Acyclic Heaps

To prevent heap cycles like those created by patterns such as Landin's Knot, the authors propose a hierarchy where references influence allocation. In this system, references cannot store functions that depend on themselves, effectively eliminating certain classes of cyclic dependencies. This stratified approach mirrors techniques in dependent type theories and provides a systematic way of reasoning about heap shapes.

Proof of Termination

The termination of programs within this type system is established through step-indexed logical relations, where the type-world circularity challenges are resolved by indexing types with universe levels instead of step indices. This syntactic stratification ensures that references do not form cycles, thereby guaranteeing termination. The authors also propose a form of semantic garbage collection managed via universe level metrics.

Interpretations and Extensions

The type universe hierarchy is proposed as a declarative region-based memory management system. This abstraction allows for easy reasoning about memory allocation and deallocation, potentially influencing future language design aimed at low-level memory management tasks. The stratified structure imposed by the universe hierarchy ensures clean separation of responsibilities across different memory regions.

Conclusion

The paper provides a valuable framework for using type universes to dictate memory allocation protocols in programming languages. This approach opens new avenues for developing type systems that enforce memory constraints directly through the language's type system, offering an innovative method to address memory safety and allocation issues. The proposed models could serve as a basis for further exploration and refinement in the area of memory management within programming languages.