Repr Types: One Abstraction to Rule Them All

TL;DR

This paper introduces a universal, extensible approach to data type representations using a single built-in type and overloading, enabling high-level optimizations and often resulting in faster program performance.

Contribution

It proposes a novel, flexible representation framework with a single type and overloading, allowing extensible data types without compiler modifications.

Findings

Programs with repr types are often faster than idiomatic representations.

The approach enables efficient high-level optimizations.

Compiler analysis finds optimized solutions quickly.

Abstract

The choice of how to represent an abstract type can have a major impact on the performance of a program, yet mainstream compilers cannot perform optimizations at such a high level. When dealing with optimizations of data type representations, an important feature is having extensible representation-flexible data types; the ability for a programmer to add new abstract types and operations, as well as concrete implementations of these, without modifying the compiler or a previously defined library. Many research projects support high-level optimizations through static analysis, instrumentation, or benchmarking, but they are all restricted in at least one aspect of extensibility. This paper presents a new approach to representation-flexible data types without such restrictions and which still finds efficient optimizations. Our approach centers around a single built-in type $\texttt{repr}$ and function overloading with cost annotations for operation implementations. We evaluate our approach (i) by defining a universal collection type as a library, a single type for all conventional collections, and (ii) by designing and implementing a representation-flexible graph library. Programs using $\texttt{repr}$ types are typically faster than programs with idiomatic representation choices -- sometimes dramatically so -- as long as the compiler finds good implementations for all operations. Our compiler performs the analysis efficiently by finding optimized solutions quickly and by reusing previous results to avoid recomputations.