In this second case, we only have Integer <: Number and Float <: Number, but Integer and Float are not subtypes of each other. The UML notation is used in this diagram, with open-headed arrows showing the direction and type of the relationship between the supertype and its subtypes.Īs a more practical example, a language might allow integer values to be used wherever floating point values are expected ( Integer <: Float), or it might define a generic type Number as a common supertype of integers and the reals. Conceptually, each of these is a variety of the basic type "bird" that inherits many "bird" characteristics but has some specific differences. The type "bird" has three subtypes "duck", "cuckoo" and "ostrich". (See § Function types below for details.)Įxample of subtypes: where bird is the supertype and all others are subtypes as denoted by the arrow in UML notationĪ simple practical example of subtypes is shown in the diagram, right. Because it must consider mutable objects, the ideal notion of subtyping defined by Liskov and Jeannette Wing, called behavioral subtyping is considerably stronger than what can be implemented in a type checker. In this context, the principle of safe substitution is often called the Liskov substitution principle, after Barbara Liskov who popularized it in a keynote address at a conference on object-oriented programming in 1987. The concept of subtyping has gained visibility (and synonymy with polymorphism in some circles) with the mainstream adoption of object-oriented programming. Reynolds in 1980 who used category theory to formalize implicit conversions, and Luca Cardelli (1985). The first formal treatments of subtyping were given by John C. The notion of subtyping in programming languages dates back to the 1960s it was introduced in Simula derivatives. In a number of object-oriented languages, subtyping is called interface inheritance, with inheritance referred to as implementation inheritance.
Subtyping should not be confused with the notion of (class or object) inheritance from object-oriented languages subtyping is a relation between types (interfaces in object-oriented parlance) whereas inheritance is a relation between implementations stemming from a language feature that allows new objects to be created from existing ones. It is also related to the concept of bounded quantification in mathematical logic (see Order-sorted logic). The concept of subtyping is related to the linguistic notions of hyponymy and holonymy. Various calculi that attempt to capture the theoretical properties of object-oriented programming may be derived from system F <. In a theoretical setting, it is desirable to study the interaction of the two features a common theoretical setting is system F <. Typically, functional programming languages also provide some, usually restricted, form of parametric polymorphism. Since functional programming languages, by definition, support function literals, which can also be stored in records, records types with subtyping provide some of the features of object-oriented programming. Because the resulting calculus allows terms to have more than one type, it is no longer a "simple" type theory. Consequently, simply typed lambda calculus extended with record types is perhaps the simplest theoretical setting in which a useful notion of subtyping may be defined and studied. In object-oriented programming the term 'polymorphism' is commonly used to refer solely to this subtype polymorphism, while the techniques of parametric polymorphism would be considered generic programming.įunctional programming languages often allow the subtyping of records. Subtyping is therefore a form of type polymorphism.
The type system of a programming language essentially defines its own subtyping relation, which may well be trivial, should the language support no (or very little) conversion mechanisms.ĭue to the subtyping relation, a term may belong to more than one type. The precise semantics of subtyping crucially depends on the particulars of what "safely used in a context where" means in a given programming language. If S is a subtype of T, the subtyping relation is often written S <: T, to mean that any term of type S can be safely used in a context where a term of type T is expected. In programming language theory, subtyping (also subtype polymorphism or inclusion polymorphism) is a form of type polymorphism in which a subtype is a datatype that is related to another datatype (the supertype) by some notion of substitutability, meaning that program elements, typically subroutines or functions, written to operate on elements of the supertype can also operate on elements of the subtype.
0 kommentar(er)
