Epigram prime: a demonstration

Abstract

It would not be too much of a stretch to imagine that dependent types will be the next big thing in programming language research. The key benefit is that by allowing types to be indexed by data, it is possible to expose more and more of the structure that lies behind the programs we write. This leads to many pay-offs, especially in refined program control and in program verification. The appearance of GADTs in Haskell has shown that there is an appetite for this kind of type discipline in the functional programming community; we believe, however, that the full benefits will only be seen with a language that is designed from the ground up around the idea of dependent types. The Epigram project has been at the fore-front of research in to dependently typed functional programming since 2004 [4]. While its initial prototype implementation proved to be as notorious as it was influential - It nonetheless provided inspiration for many features in the latest version of the Agda programming language [5], and beyond. After a long period of development hell, the Epigram team [2] are well on the way to being able to release a system that will finally put the toys that we've been working on in the hands of people who are impatient to have them, including ourselves. We hope that the real impact of Epigram 2 will, once again, be its influence on other, more mature, languages. The key motivation to Epigram remains that the solution to many of the challenges to writing programs in dependently typed languages lies with the types themselves. By explaining, using the type system, what the problem is, we can then use the system to help us find the solution - this is the power of dependent types at work. In this demonstration, I will introduce the current state of the system and will show off some of the new features, which we hope will be of interest the MSFP audience. Of the new elements, the most fundamental change is in the underlying Type Theory, which is based on Observational Type Theory (OTT) [1]. Thanks to OTT, Epigram 2 provides the ability to reason extensionally about programs, while for the first time maintaining decidable type checking. I will also demonstrate how it has been possible to extended the equality to allow certain algebraic properties, for instance the functor laws, to hold definitionally. Our Type Theory also implements a reflective approach to data types [3], we will see how we can use this to write generic programs inductively over the structure of data types.