scientific article; zbMATH DE number 3864476
[For the entire collection see Zbl 0534.00019.] There are two major ways of structuring data in programming languages. The first (and common) one, used for example in Pascal, can be said to derive from standard branches of mathematics. Data is organized in Cartesian products (i.e. record types), disjoint sums (i.e. unions or variant types) and function spaces (i.e. functions and procedures). The second method can be said to derive from biology and taxonomy. Data is organized in a hierarchy of classes and subclasses, and data at any level of the hierarchy inherits all the attributes of data higher up in the hierarchy. The top level of this hierarchy is usually called the class of all objects; every datum is an object and every datum inherits the basic properties of objects, like the ability to tell whether two objects are the same or not. Functions and procedures are also considered as local actions of objects, as opposed to global operations. These different ways of structuring data have generated distinct classes of programming languages, and induced different programming styles. Programming with taxonomically organized data is often called object- oriented programming, and has been advocated as an effective way of structuring programming environments, data bases, and large systems in general. Inheritance can be single or multiple. In the case of single inheritance the subclass hierarchy has the form of a tree, i.e. every class has a unique superclass. Exmples can be shown where a class can be indifferently considered a subclass of two incompatible superclasses; then an arbitrary decision has to be made to determine which superclass to use. This problem leads naturally to the idea of multiple inheritance. The scope of this paper is to present a clean semantics of multiple inheritance and to show that in the context of strongly-typed statically- scoped languages, a sound typechecking algorithm exists. Multiple inheritance is also interpreted in a broad sense: instead of being limited to objects, it is extended in a natural way to union types and to higher functional types. The first part of this paper is informal, and presents the basic notations and intuitions by means of examples. The second part is formal: it introduces a language, a semantics, a type inference system and a typechecking algorithm. The algorithm is proved sound with respect to the inference system, and the inference system is proved sound with respect to the semantics.
- On an algorithm determining direct superclasses in Java and similar languages with inner classes-its correctness, completeness and uniqueness of solutions
- Multiple inheritance in SIMULA-like languages
- An algebraic semantics approach to the effective resolution of type equations
- Pebble, a kernel language for modules and abstract data types
- A semantics of multiple inheritance
- Inheritance hierarchies: Semantics and unifications
- Unification theory
- Inheritance as implicit coercion
- Subtyping can have a simple semantics
- The data model of FAD, a database programming language
- Order-sorted algebra. I: Equational deduction for multiple inheritance, overloading, exceptions and partial operations
- Coherence and consistency in domains
- An algebraic semantics of higher-order types with subtypes
- An operational approach to the semantics of classes: Application to type checking
- Comparing object encodings.
- Objects and classes in Algol-like languages
- Denotational semantics of a simple model of Eiffel
- Multiple attribute grammar inheritance
- Twin -- a design pattern for modeling multiple inheritance
- A domain-theoretic model of nominally-typed object-oriented programming
- Family polymorphism
- Orthogonal subclasses and multiple inheritance of system predicate classes
- Incremental Reasoning for Multiple Inheritance
- Type extensions
- Multiple inheritance in the class automaton model
- Semantic types and approximation for Featherweight Java
- scientific article; zbMATH DE number 139982 (Why is no real title available?)
- Directly Sceptical Inheritance Cannot Capture the Intersection of Extensions
- Enhanced strict inheritance in TASSO-L
- scientific article; zbMATH DE number 1961884 (Why is no real title available?)
- Base class injection
- Subtyping constrained types
- Higher-order order-sorted algebras
- A record calculus with principal types
- Metamodeling semantics of multiple inheritance
- Consistency of inheritance in object-oriented languages and of static, ALGOL-like binding
- Separation Logic for Multiple Inheritance
- A categorical semantics of multiple inheritance
- A calculus with recursive types, record concatenation and subtyping
- Generator induction in order sorted algebras
- Compilation of extended recursion in call-by-value functional languages
- Semantics of types for database objects
- Modelling multiple inheritance with colimits
This page was built for publication:
Report a bug (only for logged in users!)Click here to report a bug for this page (MaRDI item Q3332229)