Richard S. Bird

An introduction to the theory of lists

In these lectures we introduce a notation and a calculus for specifying and manipulating computable functions over lists. The calculus is used to derive efficient solutions for a number of problems, including problems in text processing. Although programming per se is not the main topic, we indicate briefly how these solutions can be implemented in a purely functional programming language.

Lectures on Constructive Functional Programming

The subject of these lectures is a calculus of functions for deriving programs from their specifications. This calculus consists of a range of concepts and notations for defining functions over various data types — including lists, trees, and arrays — together with their algebraic and other properties. Each lecture begins with a specific problem, and the theory necessary to solve it is then developed. In this way we hope to show that a functional approach to the problem of systematically calculating programs from their specifications can take its place alongside other methodologies.

Using circular programs to eliminate multiple traversals of data

SummaryThis paper describes a technique for transforming functional programs that repeatedly traverse a data structure into more efficient alternatives that do not. The transformation makes essential use of lazy evaluation and local recursion (such as provided by letrec, or its equivalent) to build a circular program that, on one pass over the structure, determines the effects of the individual traversals and then combines them.

Tabulation Techniques for Recursive Programs

Many recursively defined functions specify redundant computations in that subsidiary function values may be evaluated more than once. Such recursions can be implemented more efficiently by a process of tabulation in which function values are computed at most once and then stored for later use. This tutorial paper examines a number of general strategies for introducing tabulation into recursive programs. The advantages of tabulation as a technique of recursion elimination are explored through various programming examples, and a simple theorem quantifying the potential increase in efficiency is presented.

Two−Dimensional Pattern Matching

The Knuth-Morris-Pratt algorithm [3] solves the following string matching problem: given a string of symbols p1 p2 l se pn, called the pattern, and a second string tl t2 l -e tm, called the text, to determine for each j whether or not ti,++ ! l -ti = plp2 l -p,. The KMP algorithm possesses the f4owing noteworthy properties: (1) its running time is O(n + m), where the coefficient of proportionality is small and independent of the size of the alphabet; (2) its space requirements are O(n), so no part of the text, which may be substantially longer than the pattern, need be kept in store; (3) its on-line nature, whereby the outcome for value i is determined before tj+ 1 is read. A natural generalisation of this problem is one in which the pattern is a two-dimensional array of syanbols PiI, 1 G i,] G n, and

de Bruijn notation as a nested datatype

ke text is a second array tij, 1 G i,j f m. In this case the problem is to determine where, if anywhere, the pattern occurs as a subarray of the text. Our purpose is to give an algorithm for thz! two dimensional case, one which follows the general approach of the KMP, and indeed uses the KMP as a subprogram. in particular, the algorithm has a running time of 0(n2 + m’), which is clearly optimal since both the pattern and the text have to be read and this takes O(rt’ + m2). The algorithm needs 0(n2 + m) space, and also works on-line (under the assumption that the text is read row by row). For reasons of space we assume some familiarity with

Generalised folds for nested datatypes

“I have no data yet. It is a capital mistake to theorise before one has data.” Sir Arthur Conan Doyle The Adventures of Sherlock Holmesde Bruijn notation is a coding of lambda terms in which each occurrence of a bound variable x is replaced by a natural number, indicating the ‘distance’ from the occurrence to the abstraction that introduced x. One might suppose that in any datatype for representing de Bruijn terms, the distance restriction on numbers would have to be maintained as an explicit datatype invariant. However, by using a nested (or non-regular) datatype, we can define a representation in which all terms are well-formed, so that the invariant is enforced automatically by the type system. Programming with nested types is only a little more difficult than programming with regular types, provided we stick to well-established structuring techniques. These involve expressing inductively defined functions in terms of an appropriate fold function for the type, and using fusion laws to establish their properties. In particular, the definition of lambda abstraction and beta reduction is particularly simple, and the proof of their associated properties is entirely mechanical.

Generic Functional Programming with Types and Relations

Abstract. Nested datatypes generalise regular datatypes in much the same way that context-free languages generalise regular ones. Although the categorical semantics of nested types turns out to be similar to the regular case, the fold functions are more limited because they can only describe natural transformations. Practical considerations therefore dictate the introduction of a generalised fold function in which this limitation can be overcome. In the paper we show how to construct generalised folds systematically for each nested datatype, and show that they possess a uniqueness property analogous to that of ordinary folds. As a consequence, generalised folds satisfy fusion properties similar to those developed for regular datatypes. Such properties form the core of an effective calculational theory of inductive datatypes.

Formal derivation of a pattern matching algorithm

A generic functional program is one which is parameterised by datatype. By installing specific choices, for example lists or trees, different programs are obtained that are, nevertheless, abstractly the same. The purpose of this paper is to explore the possibility of deriving generic programs. Part of the theory of lists that deals with segments is recast as a theory about ‘segments’ in a wide class of datatypes, and then used to pose and solve a generic version of a well-known problem.

Improving programs by the introduction of recursion

This paper is devoted to the synthesis of a functional version of the Knuth-MorrisPratt algorithm for pattern matching. This algorithm was first discussed by Knuth [6]; since then formal developments have been given by Dijkstra [4] and Dromey [5], among many others. The novel aspects of the present treatment are: (i) the result is expressed as a (very short) functional program; and (ii) the derivation makes use of the calculus of lists described by Bird [ 11. In order to make this paper as self-contained as possible, we shall indicate the concepts and notations of [l] used in our derivation as we go along. However, we do assume some familiarity with the basic ideas of functional programming. (For an introduction to functional programming, see Bird and Wadler [3].) The calculus of lists is based on the definition of lists as an algebraic structure (actually, a monoid) under the primitive operation of concatenation, denoted by the sign *. Thus