The π-calculus offers an attractive basis for concurrent programming. It is small, elegant, and well studied, and supports (via simple encodings) a wide range of high-level constructs including data structures, higher-order functional programming, concurrent control structures, and objects. Moreover, familiar type systems for the -calculus have direct counterparts in the π-calculus, yielding strong, static typing for a high-level language using the π-calculus as its core. This paper describes Pict, a strongly-typed concurrent programming language constructed in terms of an explicitly-typed-calculus core language.

. Algebraic structures which are generated by a collection of constructors--- like natural numbers (generated by a zero and a successor) or finite lists and trees--- are of well-established importance in computer science. Formally, they are initial algebras. Induction is used both as a definition principle, and as a proof principle for such structures. But there are also important dual "coalgebraic" structures, which do not come equipped with constructor operations but with what are sometimes called "destructor" operations (also called observers, accessors, transition maps, or mutators). Spaces of infinite data (including, for example, infinite lists, and non-well-founded sets) are generally of this kind. In general, dynamical systems with a hidden, black-box state space, to which a user only has limited access via specified (observer or mutator) operations, are coalgebras of various kinds. Such coalgebraic systems are common in computer science. And "coinduction" is the appropriate te...

Recent years have seen the development of several foundational models for statically typed object-oriented programming. But despite their intuitive similarity, di erences in the technical machinery used to formulate the various proposals have made them di cult to compare. Using the typed lambda-calculus F! as a common basis, we nowo er a detailed comparison of four models: (1) a recursive-record encoding similar to the ones used by Cardelli [Car84],

We introduce simple object calculi that support method override and object subsumption. We give an untyped calculus, typing rules, and equational rules. We illustrate the expressiveness of our calculi and the pitfalls that we avoid. 1.

The coalgebraic perspective on objects and classes in object-oriented programming is elaborated: objects consist of a (unique) identifier, a local state, and a collection of methods described as a coalgebra; classes are coalgebraic (behavioural) specifications of objects. The creation of a "new" object of a class is described in terms of the terminal coalgebra satisfying the specification. We present a notion of "totally specified" class, which leads to particularly simple terminal coalgebras. We further describe local and global operational semantics for objects. Associated with the local operational semantics is a notion of bisimulation (for objects belonging to the same class), expressing observational indistinguishability. AMS Subject Classification (1991): 18C10, 03G30 CR Subject Classification (1991): D.1.5, D.2.1, E.1, F.1.1, F.3.0 Keywords & Phrases: object, class, (terminal) coalgebra, coalgebraic specification, bisimulation 1. Introduction Within the object-oriente...

We present an interpretation of typed object-oriented concepts in terms of well-understood, purely procedural concepts. More precisely, we give a compositional subtypepreserving translation of a basic object calculus supporting method invocation, functional method update, and subtyping, into the polymorphic -calculus with recursive types and subtyping. The translation techniques apply also to an imperative version of the object calculus which includes inplace method update and object cloning. Finally, the translation easily extends to "Self types" and other interesting object-oriented constructs. 1 Introduction Object-oriented programming languages have introduced numerous ideas, structures, and techniques. Although these contributions are not always conceptually clear (or even sound), they are often original and useful. One of the most basic contributions is the notion of self; the operations associated with an object (its methods) can refer to the object as self, and invoke other op...

The statement S T in a -calculus with subtyping is traditionally interpreted as a semantic coercion function of type [[S]]![[T ]] that extracts the "T part" of an element of S. If the subtyping relation is restricted to covariant positions, this interpretation may be enriched to include both the coercion and an overwriting function put[S; T ] 2 [[S]]![[T ]]![[S]] that updates the T part of an element of S.

Abstract. A relation between recursive object types, called matching, has been proposed as a generalization of subtyping. Unlike subtyping, matching does not support subsumption, but it does support inheritance of binary methods. We argue that matching is a good idea, but that it should not be regarded as a form of F-bounded subtyping (as was originally intended). We show that a new interpretation of matching as higher-order subtyping has better properties. Matching turns out to be a third-order construction, possibly the only one to have been proposed for general use in programming.

this paper (Compagnoni, Intersection Types and Bounded Polymorphism 3 1994; Compagnoni, 1995) has been used in a type-theoretic model of object-oriented multiple inheritance (Compagnoni & Pierce, 1996). Related calculi combining restricted forms of intersection types with higher-order polymorphism and dependent types have been studied by Pfenning (Pfenning, 1993). Following a more detailed discussion of the pure systems of intersections and bounded quantification (Section 2), we describe, in Section 3, a typed -calculus called F ("Fmeet ") integrating the features of both. Section 4 gives some examples illustrating this system's expressive power. Section 5 presents the main results of the paper: a prooftheoretic analysis of F 's subtyping and typechecking relations leading to algorithms for checking subtyping and for synthesizing minimal types for terms. Section 6 discusses semantic aspects of the calculus, obtaining a simple soundness proof for the typing rules by interpreting types as partial equivalence relations; however, another proof-theoretic result, the nonexistence of least upper bounds for arbitrary pairs of types, implies that typed models may be more difficult to construct. Section 7 offers concluding remarks. 2. Background

We propose a conservative extension of the polymorphic lambda calculus (F ! ) as an intermediate language for compiling languages with name-based class and interface hierarchies. Our extension enriches standard F ! with recursive types, existential types, and row polymorphism, but only ordered records with no subtyping. Basing our language on F ! makes it also a suitable target for translation from other higher-order languages; this enables the safe interoperation between class-based and higher-order languages and the reuse of common type-directed optimization techniques, compiler back ends, and runtime support. We present the formal semantics of our intermediate language and illustrate its features by providing a formal translation from a subset of Java, including classes, interfaces, and private instance variables. The translation preserves the name-based hierarchical relation between Java classes and interfaces, and allows access to private instance variables of parameters of ...