Generic programming with fixed points for mutually recursive datatypes

Abstract

Many datatype-generic functions need access to the recursive positions in the structure of the datatype, and therefore adopt a fixed point view on datatypes. Examples include variants of fold that traverse the data following the recursive structure, or the Zipper data structure that enables navigation along the recursive positions. However, Hindley-Milner-inspired type systems with algebraic datatypes make it difficult to express fixed points for anything but regular datatypes. Many real-life examples such as abstract syntax trees are in fact systems of mutually recursive datatypes and therefore excluded. Using Haskell's GADTs and type families, we describe a technique that allows a fixed-point view for systems of mutually recursive datatypes. We demonstrate that our approach is widely applicable by giving several examples of generic functions for this view, most prominently the Zipper.

A pattern for almost homomorphic functions

“…Its case simply implements the obvious structural recursion. The only reason we cannot omit this case is because the Haskell language and existing generic programming techniques ( [3,9,12,24]) are blind to the correspondence between the Plus and PlusN constructors.…”

“…The void Var, Lam, and App types are considered auxiliary in instant-generics. They were later added (seemingly by Yakushev et al [24]) to the sum-of-products representation types only to define another class of generic values, such as show and read. We call these types constructor types.…”

“…This approach uses generalised algebraic data types (GADTs) [22] and rank-2 polymorphism to express the type of polymorphic functions that can be instantiated only for the data types comprising a given mutually recursive family. The technique is separated into more elementary components in the multirec generic programming approach [24]. The multirec approach uses GADTs to encode sets of types.…”

“…The homomorphic pattern, when used to define a function with the same domain and codomain type, is well understood and can be factored out with existing techniques [2,24]. This approach, however, only works for compositional functions, homomorphisms with equal domain and codomain.…”

Type-changing rewriting and semantics-preserving transformation

“…pattern functors[36], that can provide convenient folds for free. For the sake of simplicity, we present only the base-functor approach.…”