There are two ways to present this work; the most efficient is of course to start with the main syntactical definitions, and to end with semantics: this is the presentation that we follow in the body of the text: section 1, syntex; section 2, semantics. Another possibility is to follow the order of discovery of the concepts, which (as expected) starts with the semantics and ends with the syntex; we adopt this second way for our introduction, hoping that this orthogonal look at the same object will help to apprehend the concepts.

Category theory offers a unified mathematical framework for the study of specifications and programs in a variety of styles, such as procedural, functional and concurrent. One way that these different languages may be treated uniformly is by generalising the definitions of some standard categorical concepts. In this paper we reproduce in the generalised theory analogues of some standard theorems on isomorphism, and outline their applications to programming languages.

We define a simple collection of operations for creating and manipulating record structures, where records are intended as finite associations of values to labels. A second-order type system over these operations supports both subtyping and polymorphism. We provide typechecking algorithms and limited semantic models.

Our approach unifies and extends previous notions of records, bounded quantification, record extension, and parametrization by row-variables. The general aim is to provide foundations for concepts found in object-oriented languages, within a framework based on typed lambda-calculus.

We present a result of C.C. Squier relating two topics:

— the canonical rewriting systems, which have been widely studied by computer scientists as a tool for solving word problems,

— the homology of groups (more generally of monoids), which belongs to the core of pure mathematics, on the borders of algebra and topology.

The subject of linear logic has recently become very important in theoretical computer science. It is apparent that the *-autonomous categories studied at length in by Barr (1979) are a model for a large fragment of linear logic, although not quite for the whole thing. Since the main reference is out of print and since large parts of that volume are devoted to results highly peripheral to the matter at hand, it seemed reasonable to provide a short introduction to the subject.

We combine the principles of the Floyd-Warshall-Kleene algorithm, enriched categories, and Birkhoff arithmetic, to yield a useful class of algebras of transitive vertex-labeled spaces. The motivating application is a uniform theory of abstract or parametrized time in which to any given notion of time there corresponds an algebra of concurrent behaviors and their operations, always the same operations but interpreted automatically and appropriately for that notion of time. An interesting side application is a language for succinctly naming a wide range of datatypes.

In the literature ther are two main notins of model for the second order λ-calculus: one by Bruce, Meyer and Mitchell (the BMM-model, for short) in set-theoretical formulation and one category-theoretical by Seely. Here we generalise Seely's notion, using semifunctors and semi-adjunctions from Hayashi, and introduce λ2-algebras, λη2-algebras, λ2-models and λη-models, similarly to the untyped λ-calculus. Non-extensional abstraction of both term and type variables is described by semi-adjunctions (essentially as in Martini's thesis). We show that also for second order sume, the β-(and commutation!) conversions correspond to semi-functoriality and that the (additional) η-conversion corresponds to ordinary fuctioriality.

In the above framework various examples – well known ones and variations – are described. Also, we determine the place of the BMM-models; an earlier version of the latter has been reported by Jacobs.

This paper tries to explain why and how category theory is useful in computing science, by giving guidelines for applying seven basic categorical concepts: category, functor, natural transformation, limit, adjoint, colimit and comma category. Some examples, intuition, and references are given for each concept, but completeness is not attempted. Some additional categorical concepts and some suggestions for further research are also mentioned. The paper concludes with some philosophical discussion.

High-level replacement systems are formulated in an axiomatic algebraic framework based on categories pushouts. This approach generalizes the well-known algebraic approach to graph grammars and several other types of replacement systems, especially the replacement of algebraic specifications which was recently introduced for a rule-based approach to modular system design.

in this paper basic notions like productions, derivations, parellel and sequential independence are introduced for high-level replacement syetms leading to Church-Rosser, Parallelism and concurrency Theorems previously shown in the literature for special cases only. In the general case of high-level replacement systems specific conditions, called HLR1- and HLR2-conditions, are formulated in order to obtain these results.

Several examples of high-level replacement systems are discussed and classified w.r.t. HLR1- and HLR2-conditions showing which of the results are valid in each case.

Various Theories of Types are introduced, by stressing the analogy ‘propositions-as-types’: from propositional to higher order types (and Logic). In accordance with this, proofs are described as terms of various calculi, in particular of polymorphic (second order) λ-calculus. A semantic explanation is then given by interpreting individual types and the collection of all types in two simple categories built out of the natural numbers (the modest sets and the universe of ω-sets). The first part of this paper (syntax) may be viewed as a short tutorial with a constructive understanding of the deduction theorem and some work on the expressive power of first and second order quantification. Also in the second part (semantics, §§6–7) the presentation is meant to be elementary, even though we introduce some new facts on types as quotient sets in order to interpret ‘explicit polymorphism’. (The experienced reader in Type Theory may directly go, at first reading, to §§6–8).

Linear logic has recently been introduced by Girard as a logic of actions that seems well suited for concurrent computation. In this paper, we establish a systematic correspondence between Petri nets, linear logic theories, and linear categories. Such a correspondence sheds new light on the relationships between linear logic and concurrency, and on how both areas are related to category theory. Categories are here viewed as concurrent systems the objects of which are states, and the morphisms of which are transitions. This is an instance of the Lambek-Lawvere correspondence between logic and category theory that cannot be expressed within the more restricted framework of the Curry-Howard correspondence.

The type-theoretic explanation of modules proposed to date (for programming languages like ML) is unsatisfactory, because it does not capture that the evaluation of type-expressions is independent from the evaluation of program expressions. We propose a new explanation based on ‘programming languages as indexed categories’ and illustrate how ML can be extended to support higher order modules, by developing a category-theoretic semantics for a calculus of modules with dependent types. The paper also outlines a methodology, which may lead to a modular approach in the study of programming languages.