A type of higher-order two-dimensional sketch is defined which has models in suitable 2-categories. It has as special cases the ordinary sketches of Ehresmann and certain previously defined generalizations of one-dimensional sketches. These sketches allow the specification of constructions in 2-categories such as weighted limits, as well as higher-order constructions such as exponential objects and subobject classifiers, that cannot be sketched by limits and colimits. These sketches are designed to be the basis of a category-based methodology for the description of functional programming languages, complete with rewrite rules giving the operational semantics, that is independent of the usual specification methods based on formal languages and symbolic logic. A definition of ‘path grammar’, generalizing the usual notion of grammar, is given as a step towards this goal.

It is the contention of the author that there is a preferred categorical structure appropriate for the analysis of imperative programming languages, namely the existence of finite sums and products and a distributive law of products over sums. An imperative language based on these operations is described.

A compositional semantics characterizing bisimulation equivalence is derived from transition system specifications in the SOS style, satisfying certain syntactic syntactic conditions. We use Aczel's nonstandard set theory for solving a recursive equation for a domain fo processes. It contains non-well-founded elements modelling possibly infinite behaviour. Semantic interpretations of syntactic operators are obtained by defining the operational semantics for terms consisting of both syntactic and semantic (processes)entities. Finally, we return to standard set theory by observing that a similar, though less general, result can be obtained with the use of complete metric spaces.

This paper investigates the transformation of λν-terms into continuation-passing style (CPS). We show that by appropriate η-expansion of Fisher and Plotkin's two-pass equational specification of the CPS transform, we can obtain a static and context-free separation of the result terms into “essential” and “administrative” constructs. Interpreting the former as syntax builders and the latter as directly executable code, We obtain a simple and efficient one-pass transformation algorithm, easily extended to conditional expressions, recursive definitions, and similar constructs. This new transformation algorithm leads to a simpler proof of Plotkin's simulation and indifference results.

We go on to show how CPS-based control operators similar to, more general then, Scheme's call/cc can be naturally accommodated by the new transformation algorithm. To demonstrate the expressive power of these operators, we use them to present an equivalent but even more concise formulation of the efficient CPS transformation algorithm. Finally, we relate the fundamental ideas underlying this derivation to similar concepts from other work on program manipulation; we derive a one-pass CPS transformation of λn-terms; and we outline some promising areas for future research.

Based on a categorical semantics for impredicative calculi of dependent types we prove several dependence and independence results. Especially we prove that there exists a model where all usual syntactical concepts can be interpreted with only one exception: in the model the strong sum of a family of propositions indexed over a proposition need not be isomorphic to a proposition again.

The method of proof consists of restricting the set of propositions in the well known PERw model due to E. Moggi. The subsets of PERw considered in this paper are inspired by the subset ExpO of PERw introduced by Freyd et al.

Finally we show that a weak and a strong notion of sub-locally-cartesian-closed-category coincide under rather mild completeness conditions.

Erwin Engeler was born in Schaffhausen on 13 February 1930 a citizen of Wagenhausen (Thurgovia). He attended school in Diessenhofen (TG) and Schaffhausen and looks back on his various schools warmly as having provided a conducive environment. His schoolwork also left him time for other activities. For one, he pursued a career as a boy scout which he crowned by attaining the position of Rover Commissary of all Thurgovia. For another, he was an avid client of the municipal library of Schaffhausen. One book which he found there was Hilbert-Bernays' ‘Grundlagen der Mathematik’. One wonders what Erwin would have said if a soothsayer had told him that the author's own copy would one day be passed on to him by the late Bernays' family.

We tackle the problems of correctness and efficiency of paralled implementations of functional languages. We present a compilation technique described in terms of program transformations in the functional framework. The original functional expression is transformed into a functional term, which can be seen as traditional machine code. The main feature of the parallel implementation is the use of continuations. We introduce a parallel abstract machine describing lazy task creation in terms of exportation of continuations. The advantages of the approach are twofold: (1)correetness proofs are made simpler and (2) the implementation is efficient because the use of continuations reduces the task management overhead.

A subtyping relation ≤ between types is often accompanied by a typing rule, called subsumption: if a term a has type T and T≤U, then a has type U. In presence of subsumption, a well-typed term does not codify its proof of well typing. Since a semantic interpretation is most naturally defined by induction on the structure of typing proofs, a problem of coherence arises: different typing proofs of the same term must have related meanings. We propose a proof-theoretical, rewriting approach to this problem. We focus on F≤, a second-order lambda calculus with bounded quantification, which is rich enough to make the problem interesting. We define a normalizing rewriting system on proofs, which transforms different proofs of the same typing judgement into a unique normal proof, with the further property that all the normal proofs assigning different types to a given term in a given environment differ only by a final application of the subsumption rule. This rewriting system is not defined on the proofs themselves but on the terms of an auxiliary type system, in which the terms carry complete information about their typing proof. This technique gives us three different results:

— Any semantic interpretation is coherent if and only if our rewriting rules are satisfied as equations.

— We obtain a proof of the existence of a minimum type for each term in a given environment.

— From an analysis of the shape of normal form proofs, we obtain a deterministic typechecking algorithm, which is sound and complete by construction.

In this paper we study partial equivalence relations (PERs) over graph models of the λcalculus. We define categories of PERs that behave like predomains, and like domains. These categories are small and complete; so we can solve domain equations and construct polymorphic types inside them. Upper, lower and convex powerdomain constructions are also available, as well as interpretations of subtyping and bounded quantification. Rather than performing explicit calculations with PERs, we work inside the appropriate realizability topos: this is a model of constructive set theory in which PERs, can be regarded simply as special kinds of sets. In this framework, most of the definitions and proofs become quite smple and attractives. They illustrative some general technicques in ‘synthetic domain theory’ that rely heavily on category theory; using these methods, we can obtain quite powerful results about classes of PERs, even when we know very little about their internal structure.

This paper exhibits accurate encodings of the λ-calculus in the π-calculus. The former is canonical for calculation with functions, while the latter is a recent step (Milner et al. 1989) towards a canonical treatment of concurrent processes. With quite simple encodings, two λ-calculus reduction strategies are simulated very closely; each reduction in λ-calculus is mimicked by a short sequence of reductions in π-calculus. Abramsky's precongruence of applicative bisimulation (Abramsky 1989) over λ-calculus is compared with that induced by the encoding of the lazy λ-calculus into π-calculus; a similar comparison is made for call-by-value λ-calculus.

We consider the problem of mechanically constructing abstract machines from operational semantics, producing intermediate-level specifications of evaluators guaranteed to be correct with respect to the operational semantics. We construct these machines by repeatedly applying correctness-preserving transformations to operational semantics until the resulting specifications have the form of abstract machines. Though not automatable in general, this approach to constructing machine implementations can be mechanized, providing machine-verified correctness proofs. As examples, we present the transformation of specifications for both call-by-name and call-by-value evaluation of the untyped λ-calculus into abstract machines that implement such evaluation strategies. We also present extensions to the call-by-value machine for a language containing constructs for recursion, conditionals, concrete data types, and built-in functions. In all cases, the correctness of the derived abstract machines follows from the (generally transparent) correctness of the initial operational semantic specification and the correctness of the transformations applied.

The partially ordered models of linear logic, a logical system developed by J. Y. Girard, turn out to be a class of quantales called Girard quantales. The notion of a quantaloid is a natural categorical generalization of a quantale and is one possible way of keeping track of types. In this paper, Girard quantales are generalized to Girard quantaloids. The general theory is developed and several key examples are studied. Turning our attention to the theory of categories enriched in a bicategory, it is then shown that if G is a Girard quantaloid, then the quantaloids Bim(G), Matr(G), and Mon(G), consisting of G-bimodules, G-matrices and G-monads respectively, are also Girard quantaloids.

We apply the categorical properties of polymorphic functions to compile-time analysis, specifically projection-based strictness analysis. First we interpret parameterised types as functors in a suitable category, and show that they preserve monics and epics. Then we define “strong” and “weak” polymorphism, the latter admitting certain projections that are not polymorphic in the usual sense. We prove that, under the right conditions, a weakly polymorphic function is characterised by a single instance. It follows that the strictness analysis of one simple instance of a polymorphic function yields results that apply to all. We show how this theory may be applied. In comparison with earlier polymorphic strictness analysis methods, ours can apply polymorphic information to a particular instance very simply. The categorical approach simplifies our proofs, enabling them to be carried out at a higher level, and making them independent of the precise form of the programming language to be analysed. The major limitation of our results is that they apply only to first-order functions.

Unfold/fold transformations have been used in logic programming for some years to transform programs into more efficient ones. We describe recent work on the extent to which these transformations produce programs which are equivalent to the original one. Various notions of equivalence are considered: same success set; finite failure set; least Herbrand model; completion. This is used to illustrate the rather unsatisfactory relationship between logic programming and logic shown by the wide variety of different declarative semantics proposed for logic programs.

Category theorists invented monads in the 1960's to express concisely certain aspects of universal algebra. Functional programmers invented list comprehensions in the 1970's to express concisely certain programs involving lists. This paper shows how list comprehensions may be generalised to an arbitrary monad, and how the resulting programming feature can express concisely in a pure functional language some programs that manipulate state, handle exceptions, parse text, or invoke continuations. A new solution to the old problem of destructive array update is also presented. No knowledge of category theory is assumed.

The notions of weak Cartesian closed category and very weak CCC are introduced by dropping the extensionality (and the naturality) requirements in the adjunction defining the closed structure of a CCC. A number of specific examples of these categories are given. The weak notions are shown to be equivalent from both the semantic and syntactic standpoint to the typed non-extensional lambda-calculus and to the typed Combinatory Logic, extended with surjective pairs. Type-free models are characterized as reflexive objects in wCCCs. Finally, categorical models for the second-order non-extensional calculus are defined, by introducing a simple generalization of the notion of PL-category.

This paper uses concepts from sheaf theory to explain phenomena in concurrent systems, including object, inheritance, deadlock, and non-interference, as used in computer security. The approach is very; general, and applies not only to concurrent object oriented systems, but also to systems of differential equations, electrical circuits, hardware description languages, and much more. Time can be discrete or continuous, linear or branching, and distribution is allowed over space as well as time. Concepts from categpru theory help to achieve this generality: objects are modelled by sheaves; inheritance by sheaf morphisms; systems by diagrams; and interconnection by diagrams of diagrams. In addition, behaviour is given by limit, and the result of interconnection by colimit. The approach is illustrated with many examples, including a semantics for a simple concurrent object-based programming language.