Inheritance

A class may list any number of superclasses. If none are listed, the class is taken to be a subclass of Any. Any is the root of the class system. It defines only the fixed slot self, providing a reference to self. Subclass declarations extend the scopes of their superclasses. The declared class structure determines the type structure for links. The type of a link referencing instances of a class is a subtype of superclass link types.

Subclass declarations extend those of their superclasses. All stated properties (slot definitions and constraints) in superclasses are preserved in subclasses. Additions may not invalidate superclass properties. Detected conflicts may be trapped as programming errors by a translator, but it is not specified whether or how conformance is enforced.

Subclass declarations take two forms, adding new slots and adding (strengthening) features to those listed in superclasses. Additions are conjoined to the corresponding superclass declarations. Full redeclarations are unnecessary except in those cases where features cannot otherwise be expressed (e.g., when adding qualifiers). When a new slot has the same name as one in the superclass, or when two or more superclasses have slots of the same name, the following rules apply:

Multiple Declaration.

Two declarations with the same slot type (operation, procedure, function, local), number of arguments, argument types and qualifiers denote the same slot. All other aspects of the declarations are coalesced as one.

Versioning.

Two non-local, non-functional declarations differing in the declared link type of one or more argument fields, or differing in outer when guards are considered to be variant versions of the same slot.

Overloading.

Two declarations differing in number of arguments, or in the types of one or more argument in the case where those types are incommensurate (e.g., int versus real, any non-link type versus a link type), or where only one is declared as local, are taken to be two unrelated slots that may coexist (i.e., as a case of ad hoc overloading). Variants with and without opt qualifiers on one or more arguments are similarly treated as overloaded.

Unsupported.

Two declarations differing in any other way (e.g., fn versus op, qualifiers) are disallowed because invocation forms of the different cases cannot be distinquished in ODL.

The first two cases are instances of adding features to existing slots. The following additions are permitted. Analogous rules apply when merging the declarations of two or more superclasses.

• Adding a concrete definition to an existing slot.
• Adding a new clause to an existing effect.
• Adding a nonconflicting inv constraint. All inv clauses in the class and superclasses are interpreted as a single conjoined expression (with subclass clauses prepended to superclass clauses) that must be satisfiable.
• Adding a nonconflicting init constraint.
• Adding a constraint to a functional slot. The type of a function may be strengthened by replacing the result type declared in the superclass with a subtype thereof, adding common, unique and/or fixed, or removing opt. However, these may not conflict with other superclass constraints or definitions. For example, it is illegal to add a fixed qualifier if a fn value varies within a superclass operation.
• Adding a constraint to a procedure result. Result types and qualifiers of anonymous replies may be added in the same manner as for functions. Also, a constraint that one or more alternate named replies are not issued may be indicated by omitting them in the redeclaration. (The converse case of adding alternate named replies is not allowed.)
• Adding or subdividing an outer when clause into two or more subconditions in order to add a new operation or another version of an operation under one or more of them.
• Adding or subdividing an inner when clause into two or more subconditions in order to add a new clause to an effect and/or add a concrete definition under one or more of them. Effects and result types of all versions must meet all applicable superclass constraints.

These rules apply whenever a subclass adds a new version of a slot or two superclass versions exist. All declarations of different versions are interpreted as if they were different arms of a single operation with multiple when guards. A translator may fabricate guards (and/or perform equivalent transformations) in any way consistent with the declarations. For example, in:

class A ... end
class B is A ... end
class C ... end;

class D
  op m(a: A) ==> ea end;
  op m(b: B) ==> eb end;
  op m(c: C) ==> ec end;
end

The declarations of m in D may be transformed into a single operation, with all argument types recast in terms of their nearest common superclasses (here, just Any):

  op m(x: Any)
    when      x in B ==> eb
    elsewhen  x in A ==> ea
    elsewhen  x in C ==> ec
    else pend  end

The implicit negation of preceding guards in when clauses transforms consistency issues to ordering issues in the equivalent ODL code. For example, this may also be transformed as:

  op m(x: Any)
    when      x in C ==> ec
    elsewhen  x in B ==> eb
    elsewhen  x in A ==> ea
    else pend  end

In both cases, the version for B specializes that for A. However, class C bears no subclass or superclass relation to the others, so the clause may be considered in either fashion, at the discretion of the translator. For example, if the operation were invoked with an argument of type AC (a subclass of both A and C) then either version might trigger. While not disallowed, such non-determinism should be avoided.

The results of different versions of procedural operations may also vary. The combination rules are the same as would apply if each reply were considered as an operation proper. The base version is constructed by conjoining all cases as multiple replies, while merging (as the nearest common superclass) the types of identically named (or nameless) replies in those cases where fields differ only in link type. For example:

class E
  op p(a: A) f: A ;
  op p(b: B) g: B ;
  op p(c: C) h: int;
  op p(d: D)  ok(), bad(i: int)
end

class E
  op p(a: Any) fg: A, h: int, ok(), bad(i: int);
end

Subclass Restrictions

A constraint of the form C = oneOf(S1, S2, ... Sn) limits the declarable subclasses of C to those listed under OneOf. Stylistically, OneOf is used to indicate that the listed subclasses are the only ones logically possible. For example, a class with a fixed bool slot might be partitioned into two subclasses with it set to true versus false. Also, subclasses defined via OneOf serve as analogs of enumeration types found in other languages. A translator may enforce and exploit the facts that partitioning constraints place fixed bounds on the number of subclasses and/or that partitioned siblings may never have a common subclass.

Defeasible Inheritance

A class may list another ``base'' class in an opens clause to indicate that it shares all but specifically redeclared features with this base. The rules are the same as those under normal inheritance except that any feature may be redeclared in any way -- declarative constraints in the base declaration are ignored. Additionally, any unguarded base slot may be redeclared as local. The class listed in opens is not a superclass; link types of the derived class are not subtypes of those for the base.