Abstract. Using equational logic as a specification language, we investigate the proof theory of behavioral subtyping for object-oriented abstract data types with immutable objects and deterministic methods that can use multiple dispatch. In particular, we investigate a proof technique for correct behavioral subtyping in which each subtype’s specification includes terms that can be used to coerce its objects to objects of each of its supertypes. We show that this technique is sound, using our previous work on the model theory of such abstract data types. We also give an example to show that the technique is not complete, even if the methods do not use multiple dispatch, and even if types specified are term-generated. In preparation for the results on equational subtyping we develop the proof theory of a richer form of equational logic that is suitable for dealing with subtyping and behavioral equivalence. This gives some insight into question of when our proof techniques can be make effectively computable, but in general behavioral consequence is not effectively computable. 1.

We present and analyze the semantics and static type system for BeCecil, a theoretical (core) language with multimethods. BeCecil is a simple and orthogonal version of object-oriented languages like Cecil, CLOS, and Dylan. BeCecil has a new, simple mechanism for information hiding, which allows subclassing and yet can preserve representation invariants. BeCecil is also block-structured; within a block, one can extend a generic function with new multimethods, which may come from other generic functions. The inheritance relationships of objects may be extended in any block, and are statically scoped. The type system separates classes from types, and inheritance from subtyping. Subtype relationships are also extensible and statically scoped. These features combine to make BeCecil unusually expressive, while still allowing static typechecking.

. Modern computer algebra systems (e. g. AXIOM) support a rich type system including parameterized data types and the possibility of implicit coercions between types. In such a type system it will be frequently the case that there are different ways of building coercions between types. An important requirement is that all coercions between two types coincide, a property which is called coherence. We will prove a coherence theorem for a formal type system having several possibilities of coercions covering many important examples. Moreover, we will give some informal reasoning why the formally defined restrictions can be satisfied by an actual system. 1 Introduction Modern computer algebra systems (e. g. AXIOM [12]) support many different types which correspond to mathematical structures. By the use of parameterized data types (also called type constructors) and of generic operators they can handle a variety of structures in a uniform way. If such a system is internally strongly typed...

this paper is an alternative to diagram chasing (4). The use of a standard notation for various unique arrows obviates in some cases the need for pictures for the purpose of naming (2). The need for a pictorial overview of the typing (1) is decreased to some extend by a consistent notation, in particular f ; g for composition (so that f : a ! b g: b ! c ) f

. This paper investigates some soundness conditions which have to be fulfilled in systems with coercions and generic operators. A result of Reynolds on unrestricted generic operators is extended to generic operators which obey certain constraints. We get natural conditions for such operators, which are expressed within the theoretic framework of category theory. However, in the context of computer algebra, there arise examples of coercions and generic operators which do not fulfil these conditions. We describe a framework --- relaxing the above conditions --- that allows distinguishing between cases of ambiguities which can be resolved in a quite natural sense and those which cannot. An algorithm is presented that detects such unresolvable ambiguities in expressions. 1 Introduction Reynolds [10] uses category theory to investigate the problems of the interaction of coercions (implicit conversions) and generic operators (also called overloaded operators) . He concludes with ...

This paper presents a careful analysis of the problem of reasoning about objectoriented programs. A solution to this problem allows new types to be added to a program without respecifying or reverifying unchanged modules --- if the new types are subtypes of existing types. The key idea is that subtype relationships must satisfy certain semantic constraints based on the types' specified behavior. Thus subtyping is not the same as inherit...

A model theory for correct behavioral subtyping for abstract data types (with immutable objects) is developed within the framework of the behavior-realization adjunction. To allow for incomplete specifications, proofs of correct behavioral subtyping are based on comparison to one of several paradigmatic models. For specifications that are not term-generated, these results are the first complete algebraic characterizations of behavioral subtyping.

Abstract. A general homomorphic overloading in a first-order type system is discussed. Type inference is applied within predefined classes each containing an arbitrary first-order subtyping hierarchy. We propose a computationally efficient type inference algorithm by converting the attendant constraint-satisfaction problem into the algebraic path problem for a constraint graph weighted with elements of a specially constructed non-commutative star semiring. The elements of the semiring are monotonic functions from integers to integers (including ±∞) with pointwise maximum and function composition as semiring operations. The computational efficiency of our method is due to Klene’s algebraic path method’s cubic complexity. Our algorithm is applicable to type inference in the presence of unknown external types and supports distributed type inference. 1

. We construct a representation of the institution of the algebraic

data types are employed in [86, 85]; their relation to classes is discussed earlier in [31]. Large languages are presented in [13, 11]. Slide 86 Type inference for simple subtyping is developed in [69, 102, 59, 74, 105, 55, 104]. Slide 88--94 Class inference is developed in [101, 45, 79, 76, 4]. Slide 96 ML modules are described in [67, 106]. Slide 97 Approaches to genericity are discussed in [63, 49, 61, 73, 83]. Annotated Bibliography 104 Slide 98 Multi-methods are presented in [53, 72, 24, 25]. Slide 99 The Self language is described in [108, 26, 27, 28, 48, 3]. References ...