Late Data Layout: Unifying Data Representation Transformations
Values need to be represented differently when interacting with certain language features. For example, an integer needs to take an object-like representation when interacting with erased generics, although, for performance reasons, it normally uses the direct representation. In order to simplify the work of programmers, languages like ML and Scala expose the high-level concept (the integer) and let the compiler handle representation and conversion.
This pattern appears in multiple language features such as value classes, specialization and multi-stage programming mechanisms: they all expose a concept which they later refine into multiple representations. Yet, their implementations are ad-hoc and entangle the core mechanism with assumptions about the alternative representation and the implementation of generics, thus losing sight of the general principle.
In this paper we present an elegant and minimalistic type-driven generalization that subsumes and improves the state-of-the-art representation transformations. In doing so, we make two key observations: (1) annotated types conveniently capture the semantics of using alternative representations and (2) local type inference can be used to automatically, reliably and optimally introduce the necessary conversions.
We validated our approach by implementing three language features in the Scala compiler: value classes, specialization via miniboxing and a simplified multi-stage programming mechanism. An encouraging result was that we were able to reimplement and extend value class functionality in the Scala compiler with the equivalent of two man-weeks of work, without reusing any code from the previous implementation.