Sean Leather

Libraries for generic programming in haskell

These lecture notes introduce libraries for datatype-generic programming in Haskell. We introduce three characteristic generic programming libraries: lightweight implementation of generics and dynamics, extensible and modular generics for the masses, and scrap your boilerplate. We show how to use them to use and write generic programs. In the case studies for the different libraries we introduce generic components of a medium-sized application which assists a student in solving mathematical exercises.

Type-safe diff for families of datatypes

The UNIX diff program finds the difference between two text files using a classic algorithm for determining the longest common subsequence; however, when working with structured input (e.g. program code), we often want to find the difference between tree-like data (e.g. the abstract syntax tree). In a functional programming language such as Haskell, we can represent this data with a family of (mutually recursive) datatypes. In this paper, we describe a functional, datatype-generic implementation of diff (and the associated program patch). Our approach requires advanced type system features to preserve type safety; therefore, we present the code in Agda, a dependently-typed language well-suited to datatype-generic programming. In order to establish the usefulness of our work, we show that its efficiency can be improved with memoization and that it can also be defined in Haskell.

Type-changing rewriting and semantics-preserving transformation

We have identified a class of regular, whole-program transformations that cannot be safely performed with typical transformation techniques because transformation requires changing the types of terms. In these transformations, we want to change typically large parts of a program from using one type to using another type while simultaneously preserving the original program semantics after transformation. In this paper, we present type-and-transform systems, an automated approach to the whole-program transformation of terms involving type A to terms involving the isomorphic type B using type-changing rewrite rules. Type-and-transform systems establish typing and semantics relations between all source and target subprograms such that a complete transformation can guarantee the equivalent semantics of a whole program. We describe the type-and-transform system for the lambda calculus with let-polymorphism and general recursion, including several examples from the literature and properties of the system.

Pull-ups, push-downs, and passing it around

Programs in languages such as Haskell are often datatypecentric and make extensive use of folds on that datatype. Incrementalization of such a program can significantly improve its performance by transforming monolithic atomic folds into incremental computations. Functional incrementalization separates the recursion from the application of the algebra in order to reduce redundant computations and reuse intermediate results. In this paper, we motivate incrementalization with a simple example and present a library for transforming programs using upwards, downwards, and circular incrementalization. Our benchmarks show that incrementalized computations using the library are nearly as fast as handwritten atomic functions.

A DSL for describing the artificial intelligence in real-time video games

Many games have computer-controlled agents that play against a player. The behavior of these computer-controlled agents is described by means of the artificial intelligence (AI) in the game. The AI is an important component of the game, and needs to be developed carefully, and adapted regularly. This paper introduces a novel language for describing the decision making process of the AI in real-time video games. We develop a declarative, domain-specific language (DSL) embedded in the functional programming language Haskell for real-time video games. We use the DSL to describe the AI of a prototype real-time video game.