Abstract. Traditional combinatory logic is able to represent all Turing computable functions on natural numbers, but there are effectively calculable functions on the combinators themselves that cannot be so represented, because they have direct access to the internal structure of their arguments. Some of this expressive power is captured by adding a factorisation combinator. It supports structural equality, and more generally, a large class of generic queries for updating of, and selecting from, arbitrary structures. The resulting combinatory logic is structure complete in the sense of being able to represent pattern-matching functions, as well as simple abstractions. §1. Introduction. Traditional combinatory logic [21, 4, 10] is computationally equivalent to pure λ-calculus [3] and able to represent all of the Turing computable functions on natural numbers [23], but there are effectively calculable functions on the combinators themselves that cannot be so represented, as they examine the internal structure of their arguments.

Pattern calculus is able to represent a fixed system of classes by treating methods as pattern-matching functions, along with a powerful account of both quantified types and of subtypes. This paper adds class, and subclass declarations to support an evolving class hierarchy. Even though method meanings change as new classes are introduced, the properties of existing programs do not change. This provides a common foundation for functional and object-oriented languages in which new functions can be defined on existing data types and also new subclasses can inherit existing methods. 1.

Self-interpreters can be roughly divided into two sorts: self-recognisers that recover the input program from a canonical representation, and self-enactors that execute the input program. Major progress for statically-typed languages was achieved in 2009 by Rendel, Ostermann, and Hofer who presented the first typed selfrecogniser that allows representations of different terms to have different types. A key feature of their type system is a type:type rule that renders the kind system of their language inconsistent. In this paper we present the first statically-typed language that not only allows representations of different terms to have different types, and supports a self-recogniser, but also supports a selfenactor. Our language is a factorisation calculus in the style of Jay and Given-Wilson, a combinatory calculus with a factorisation operator that is powerful enough to support the pattern-matching functions necessary for a self-interpreter. This allows us to avoid a type:type rule. Indeed, the types of System F are sufficient. We have implemented our approach and our experiments support the theory.

Abstract. Pattern calculus is a new foundation for computation in which the tension between functions and data structures is resolved within pattern-matching functions. This removes one of the main drivers of programming language design, so that the bondi programming language is able to represent all of the main programming styles. The basic theory is in a forthcoming monograph on pattern calculus. This paper will use bondi to demonstrate some consequences. First, function extensions allow the addition of both new functions to old data types (in functional programming style) and also new data types to old functions (method specialisation). Second, the basic concepts of object-orientation: object, class, self, inheritance, specialisation and dynamic dispatch can all be expressed using the more fundamental concepts of data structure, algebraic type, recursion, pattern-matching, function extension and state.

Abstract. Concurrent pattern calculus drives interaction between processes by comparing data structures, just as sequential pattern calculus drives computation. By generalising from pattern matching to pattern unification, interaction becomes symmetrical, with information flowing in both directions. This provides a natural language for describing any form of exchange or trade. Many popular process calculi can be encoded in concurrent pattern calculi. 1

Pattern calculus treats all computation as pattern matching, which is, in turn, central to the implementation of programming languages. Hence, its realisation in the general-purpose language bondi provides a natural host in which to develop domain-specific languages (DSLs). bondi is a strongly typed language that supports mixing of all the programming styles required for language implementation, including imperative programming (for handling input streams), functional programming (for transforming abstract syntax trees), generic queries (for performing traversals) and object-orientation (for growing DSLs). The approach is illustrated by growing a small combinatory language in which each language feature, i.e. each production of each grammar, is isolated within a single object-oriented class that captures the rules for parsing, type inference, evaluation and printing. Further, growth is used to support lambda-abstraction and pattern matching, providing good evidence that this combinatory language could grow to support all of bondi. 1

Pure pattern calculus [4, 2] is a new foundation for computing based upon pattern-matching. Its terms are given by t:: = x | ˆx | t t | [θ] t → t. Variable symbols x are as usual, but matchable symbols ˆx are used both as binding symbols and as constructors. The sole reduction rule is ([θ] p → s) u − → {u/[θ] p}s which is to be understood as follows. Find a substitution whose domain is the sequence θ of binding symbols of the case [θ] p → s which maps p to u and then apply this substitution to the body s of the case.