NOOP: A Domain-Theoretic Model of Nominally-Typed OOP

by   Moez AbdelGawad, et al.
Rice University

The majority of industrial-strength object-oriented (OO) software is written using nominally-typed OO programming languages. Extant domain-theoretic models of OOP developed to analyze OO type systems miss, however, a crucial feature of these mainstream OO languages: nominality. This paper presents the construction of NOOP as the first domain-theoretic model of OOP that includes full class/type names information found in nominally-typed OOP. Inclusion of nominal information in objects of NOOP and asserting that type inheritance in statically-typed OO programming languages is an inherently nominal notion allow readily proving that type inheritance and subtyping are completely identified in these languages. This conclusion is in full agreement with intuitions of developers and language designers of these OO languages, and contrary to the belief that "inheritance is not subtyping," which came from assuming non-nominal (a.k.a., structural) models of OOP. To motivate the construction of NOOP, this paper briefly presents the benefits of nominal-typing to mainstream OO developers and OO language designers, as compared to structural-typing. After presenting NOOP, the paper further briefly compares NOOP to the most widely known domain-theoretic models of OOP. Leveraging the development of NOOP, the comparisons presented in this paper provide clear, brief and precise technical and mathematical accounts for the relation between nominal and structural OO type systems. NOOP, thus, provides a firmer semantic foundation for analyzing and progressing nominally-typed OO programming languages.


page 1

page 2

page 3

page 4


Induction, Coinduction, and Fixed Points in PL Type Theory

Recently we presented a concise survey of the formulation of the inducti...

Induction, Coinduction, and Fixed Points: A Concise Survey

In this survey paper (which hitherto is an ongoing work-in-progress) we ...

Induction, Coinduction, and Fixed Points: A Concise Comparative Survey (and Tutorial)

In this survey paper (which hitherto is an ongoing work-in-progress) we ...

Partial Cartesian Graph Product

In this paper we define a new product-like binary operation on directed ...

Java Generics: An Order-Theoretic Approach (Abridged Outline)

The mathematical modeling of generics in Java and other similar nominall...

On consistency types for lattice-based distributed programming languages

Distributed systems address an increasing demand for fast access to reso...

Java Generics: An Order-Theoretic Approach (Detailed Outline)

Generics have been added to Java so as to increase the expressiveness of...

1. Introduction

To evolve and improve the type systems of mainstream object-oriented programming languages such as Java (Gosling et al., 2014), C# (2015), C++ (2011), and Scala (Odersky, 2014), which utilize class name information in defining object types and OO subtyping, a precise mathematical model of these languages is needed. A precise model of nominally-typed OOP allows accurate reasoning and analysis of these mainstream OO programming languages. Imprecise models, on the other hand, lead to inaccurate conclusions.

An object in nominally-typed OO languages is associated with its class111The term ‘type’ is overloaded. In this paper, the term has mainly two related but distinct meanings. The first meaning, mainly used by OO software developers, is a syntactic one, that directly translates to the expression ‘class, interface, or trait’ (in OO programming languages that support these constructs). In this sense, each class, interface, or trait is a type. The second meaning for ‘type,’ mainly used by mathematicians and programming languages researchers, is a semantic meaning referring to the set of instances of a corresponding class/interface/trait. In this sense, each class, interface, or trait corresponds to a type. Usually the context makes clear which sense of the two is meant, but, to emphasize, sometimes we use the term ‘class’ for the syntactic meaning. As such, unless otherwise noted the term ‘class’ in this paper should be translated in the mind of the reader to ‘class, interface or trait.’ name and the class names of its superclasses, as part of the meaning of the object. Class names, in turn, are associated with class contracts, which are usually expressed, informally, in code documentation. Class contracts are thus implicitly encoded in class names.

In nominally-typed OOP, two objects with the same structure but that have different class name information are different objects, and they have different types. The different class name information inside the two objects implies the two objects maintain different class contracts, and thus that the objects are behaviorally dissimilar. The two objects are thus considered semantically unequal. Further, in nominally-typed OO languages—where types and the subtyping relation make use of class names and of the explicitly-specified type inheritance relation between classes—instances of two classes that are not in the inheritance hierarchy may not be replaced by each other (i.e., are not ‘assignment-compatible’) since they may not offer the degree of behavioral substitutability intended by developers of the two classes.

Despite its clear semantic importance, class name information (henceforth, ‘nominal information’) that is embedded inside objects of many mainstream OO programming languages is not included in the most recognized denotational models of OOP that exist today. Models of OOP that lack nominal information of mainstream OO languages are structural models of OOP, not nominal ones. Examples of structurally-typed OO languages include O’Caml (Leroy et al., n.d.) (see (MacQueen, 2002)) and research languages such as Modula-3 (Cardelli et al., 1989), Moby (Fisher & Reppy, 1999), Strongtalk (Bracha & Griswold, 1993), and PolyTOIL (Bruce et al., 2003). Structural models of OOP have led PL researchers to make some conclusions about OOP that contradict the intuitions of the majority of mainstream OO developers and language designers. For example, the agreement of type inheritance, at the syntactic (i.e., program code) level, and subtyping, at the semantic (i.e., program meaning) level, is a fundamental intuition of OO developers using nominally-typed OO languages. However, extant denotational models of OOP led to the inaccurate conclusion that “inheritance is not subtyping.”

Type inheritance, in class-based mainstream OO languages, is an inherently nominal notion, due to the informal association of class names with inherited class contracts. Hence the discrepancy between conclusions regarding inheritance that are based on a structural view of OOP and the intuitions of the majority of mainstream OO developers, who adopt a nominal view of OOP. This discrepancy motivated considering the inclusion of nominal information in mathematical models of OOP.

This paper presents the construction of a mathematical model of OOP, called , that includes full nominal information of mainstream OO programming languages. was first presented in (AbdelGawad, 2012) and its construction was summarized in (AbdelGawad, 2014a).

Having a model of OOP that includes nominal information of nominally-typed OOP should enable progress in the design of type systems of current and future mainstream OO languages. Some features of the type systems of these languages (e.g., generics) crucially depend on nominal information. Accurately understanding and analyzing these features, for the purposes of extending the languages or designing new languages that include them, has proven to be hard when using operational models of OOP or using structural denotational models of OOP, which lack nominal information found in nominally-typed OO languages. Having a nominal domain-theoretic model of OOP should make the analysis of features of these languages that depend on nominal information easier and more accurate. From the point of view of OO software development, having better mainstream OO languages should result in greater productivity for software developers and in them producing robust high-quality software.

This paper is organized as follows. Section 2 presents a list of research related to this paper. Section 3 presents in brief the value of nominal typing to mainstream OO developers. Section 4 then starts the formal presentation of by presenting a new records domain constructor, called ‘rec,’ that is used in constructing . Section 5 presents class signatures and other related signature constructs, which are syntactic constructs used to embody the nominal information found in nominally-typed OOP. Section 6 presents the construction of , using ‘rec’ and signature constructs, then it presents a proof of the identification of inheritance and subtyping in nominally-typed OOP. Section 7 then presents in brief a comparison of to the most well-known domain-theoretic models of OOP, namely the two structural models developed by Cardelli and by Cook. Section 8 presents the main conclusions we reached based on developing and on comparing it to other domain-theoretic models of OOP. Section 9 concludes this paper by presenting further research that can be developed based on .

2. Related Research

is a domain-theoretic model of nominally-typed OOP. Dana Scott invented and developed—with others including Gordon Plotkin—the fields of domain theory and denotational semantics (e.g., see  Scott, 1976; Stoy, 1977; Smyth & Plotkin, 1982; Scott, 1983; Gunter & Scott, 1990; Gierz et al., 2003; Cartwright et al., 2016). The development of denotational semantics has been motivated by researching the semantics of functional programming languages such as Lisp (McCarthy, 1963, 1996) and ML (Gordon et al., 1978; Milner et al., 1997).

Research on the semantics of OOP has taken place subsequently. Cardelli built the first widely known denotational model of OOP (Cardelli, 1984, 1988a). Cardelli’s work was pioneering, and naturally, given the research on modeling functional programming extant at that time, the model Cardelli constructed was a structural denotational model of OOP that lacked nominal information.222Significantly, Cardelli in fact also hinted at looking for investigating nominal typing (on page 2 of (Cardelli, 1988b)). Cardelli’s hint, unfortunately, went largely ignored for years. Cook and his colleagues built on Cardelli’s work to separate the notions of inheritance and subtyping (Cook, 1989; Cook & Palsberg, 1989; Cook et al., 1990). Later, other researchers (such as  (Bruce, 2002) and  (Simons, 2002)) promoted Cardelli and Cook’s structural view of OOP, and promoted conclusions based on this view.

Martin Abadi, with Luca Cardelli, later presented operational models of OOP (Abadi & Cardelli, 1994, 1996). These models also had a structural view of OOP. Operational models with a nominal view of OOP got later developed however. In their seminal work, Atsushi Igarashi, Benjamin Pierce, and Philip Wadler presented Featherweight Java (FJ) (Igarashi et al., 2001) as an operational model of a nominally-typed OO language. Even though not the first operational model of nominally-typed OOP (for example, see (Drossopoulou et al., 1999)(Nipkow & Von Oheimb, 1998) and (Flatt et al., 1998, 1999)), FJ is the most widely-known operational model of (a tiny core subset of) a nominally-typed OO language, namely Java.333It is worthy to mention that —as a more foundational domain-theoretic model of nominally-typed OO languages (including Java)—provides a denotational justification for the inclusion of nominal information in Featherweight Java.

Other research that is similar to one presented here, but that had different research interests and goals, is that of Reus and Streicher (Reus, 2002; Reus & Streicher, 2002; Reus, 2003). In (Reus, 2003), an untyped denotational model of class-based OOP is developed. Type information is largely ignored in this work (object methods and fields have no type signatures) and some nominal information is included with objects only to analyze OO dynamic dispatch. The model of (Reus, 2003) was developed to analyze mutation and imperative features of OO languages and for developing specifications of OO software and the verification of its properties. Analyzing the differences between structurally-typed and nominally-typed OO type systems was not a goal of Reus and Streicher’s research, and in their work the identification of inheritance and subtyping was, again (as in FJ), assumed rather than proven as a consequence of nominality and nominal typing.

3. The Value of Nominal-Typing in OOP

In this section we briefly present the value of nominal-typing and nominal-subtyping to OO software developers and OO language designers. More details on the value of nominal-typing and nominal-subtyping can be found in (AbdelGawad, 2016b).

As hinted to in the Introduction (Section 1), the main semantic value of nominal-typing to mainstream OOP lies in the association of type (i.e., class/interface/trait) names with behavioral contracts that are part of the public interface of objects, making typing and subtyping in nominally-typed OO languages closer to semantic typing and semantic subtyping than structural-typing and structural-subtyping are. Designing their software based on having public behavioral contracts allows OO developers to design robust software (Bloch, 2008).

The semantic value of nominal type information leads nominally-typed and structurally-typed OO languages to have different views of type names, where type names in nominally-typed OOP have fixed meanings (tied to the public contracts) while in structurally-typed OOP (in agreement with the tradition in functional programming) type names are viewed as mere ‘shortcuts for type expressions’ that can thus change their meanings, e.g., upon inheritance. This difference in viewing type names leads OO developers using structurally-typed OO languages to face problems—such as spurious subtyping, missing subsumption, and spurious binary methods (see (AbdelGawad, 2016b))—that are not found in nominally-typed OO languages.

Further, the identification of type inheritance with OO subtyping (‘inheritance is subtyping’) resulting from nominal-typing (which we prove in this paper) enables nominally-typed OO languages to present OO developers with a simple conceptual model during the OO software design process.

Finally, due to the ubiquity of the need for objects in OOP to be “autognostic” (self-aware, i.e. recursive, see (Cook, 2009)) and given that recursive data values can be typed using recursive types (MacQueen et al., 1986), the ease by which recursive types can be expressed in nominally-typed OO languages is a decided benefit nominal-typing offers to OO software developers and designers (Pierce, 2002). More details on the benefits of nominal-typing can be found in (AbdelGawad, 2016b).

Without further ado, we now start the presentation of as a model of OOP that includes full nominal information found in many mainstream OO languages.

4. ‘Rec’ (), A New Records Domain Constructor

For the purpose of constructing , we introduce a new domain constructor. In addition to including nominal information of mainstream OOP, models records as tagged finite functions rather than infinite functions, as another improvement over extant domain-theoretic models of OOP (particularly that of Cardelli and other models built directly on top of it, such as Cook’s.)

Due to the finiteness of the shape of an object (the shape of an object is the set of names/labels of its fields and methods), and due to the flatness of the domain of labels when labels are formulated as members of a computational domain, modeling objects in motivates defining a new domain constructor that is similar to but somewhat different from conventional functional domain constructors. This domain constructor, , called ‘rec,’ constructs tagged finite functions, which we call record functions. Record functions are explicitly finite mathematical objects.

A domain , constructed using , is the domain of record functions modeling records with labels from a flat domain of labels to an arbitrary domain of values. Below we present the records domain constructor, , then we discuss its mathematical properties. The definition of makes use of standard definitions of basic domain theory (See, for example, (Cartwright et al., 2016). A summary of domain theory notions used to construct is presented in (AbdelGawad, 2014b) and in Appendix A of (AbdelGawad, 2012, 2013a).)

4.1. Record Functions

A record can be viewed as a finite mapping from a set of labels (as member names) to fields or methods. Thus, we model records using explicitly finite record functions. A record function is a finite function paired with a tag representing the input domain of the function. The tag of a record function modeling a record represents the set of labels of the record. In agreement with the definition of shapes of objects, we similarly call the set of labels of a record the shape of the record. The tag of a record function thus tells the shape of the record.

4.2. Definition of

Let be the flat domain containing all record labels plus an extra improper bottom label, , that makes be a domain. (All computational domains must have a bottom element.) Let be an arbitrary domain, with approximation ordering and bottom element . Domain contains the values that members of records are mapped to.

Let denote the subdomain relation (see Definition 6.2 in (Cartwright et al., 2016).) If we let range over arbitrary finite subdomains of (all subdomains contain ), then we define the domain as the domain of record functions from to , where the universe, , of domain is defined by the equation


with sets defined as


and where is a function that maps the shape corresponding to a domain to a unique tag in a countable set of tags (whose exact format does not need to be specified), and where is the standard domain of strict continuous functions from into . Tags are needed in record functions to ensure that the records domain constructor is a continuous, in fact computable, domain constructor.

To illustrate, using a record is modeled by a record function . It should be noted that allows constructing the (unique) record function

that models the empty record (one with an empty set of labels, for which .)

The approximation ordering, , over elements of is defined as follows. The bottom element approximates all elements of the domain . Non-bottom elements and in with unequal tags are unrelated to one another. On the other hand, elements and with the same tag are ordered by their embedded functions (which must be elements of the same domain.) Formally, for two non-bottom record functions in that are defined over the same , where , if


where and are elements in , then we define

Having defined the records domain constructor , we now discuss its mathematical properties.

Theorem 4.1.

Given a flat countable domain of labels and an arbitrary domain , is a domain.


See Appendix B. ∎

Because in the construction of we use to construct domains as least fixed points of functions over domains, where the constructed domains need to be subdomains of Scott’s universal domain, , we need to ascertain that has the domain-theoretic properties needed for it to be used inside these functions. We thus need to prove that is a continuous function over its input domain , i.e., that, as a function over domains, is monotonic with respect to the subdomain relation, , and that preserves least upper bounds of domains under that relation.

Theorem 4.2.

Domain constructor is a continuous function over flat domains and arbitrary domains .


See Appendix B. ∎

5. Class Signatures

In this section we present formal definitions for class signatures and related constructs. Class signatures and other signature constructs are syntactic constructs that capture nominal information found in objects of mainstream OO software. Embedding class signature closures (formally defined below) in objects of makes them nominal objects, thereby making objects more precise models of objects in mainstream OO languages such as Java, C#, C++, and Scala.

Class signatures formalize the notion of object interfaces. A class signature corresponding to a class in nominally-typed mainstream OOP is a concrete expression the interface of the class, i.e., of how instances of the class should be viewed and interacted with by other objects (“the outside world”).444Object interfaces are also discussed in (AbdelGawad, 2016b),  (AbdelGawad, 2013b) and Ch. 2 of (AbdelGawad, 2013a).

To capture nominal information of nominally-typed mainstream OOP, we define three syntactic signature constructs: (1) class signatures, (2) class signature environments, and (3) class signature closures. Additionally, fields and methods, respectively, have (4) field signatures and (5) method signatures.

5.1. Class Signatures

If is the set of all class names, and is the set of all member (i.e., field and method) names, we define a set that includes all class signatures by the equation


where and are the cross-product and finite-sequences set constructors, respectively, is the set of field signatures, and is the set of method signatures.

The equation for expresses that a class signature corresponding to a certain class is composed of four components:

  1. The class name (also used as a signature name for the class signature),

  2. A finite sequence of names of immediate supersignatures of the signature, i.e., of signatures corresponding to immediate superclasses of the class,

  3. A finite sequence of field signatures corresponding to class fields, and

  4. A finite sequence of method signatures corresponding to class methods.

The use of signature names (members of ) inside signatures characterizes class signatures as nominal constructs, where two signatures with different names but that are otherwise equal are different signatures.

The second component of a signature, a (possibly empty) sequence of signature names (i.e., a member of ), is the immediate supersignature names component of the class signature. Having names of immediate supersignatures of a class signature explicitly included as a component of the class signature is an essential and critical feature in the modeling of nominal subtyping in nominally-typed OOP. Explicitly specifying the supersignatures of a class signature identifies the nominal structure of the class hierarchy immediately above the named class. This also agrees with the inheritance of the contract associated with class names, which is a crucial semantic component of what is intended to be inherited in nominally-typed mainstream OOP.

The equation for field signatures expresses that a field signature is a pair of a field name (a member of ) and a class signature name. Similarly, the equation for method signatures expresses that a method signature is a triple of a method name, a sequence of class signature names (for the method parameters), and a signature name (for the method result).

Not all members of set are class signatures. To agree with our intuitions about describing the interfaces of classes and their instances, a member of is a class signature if its supersignature names component, its field signatures component and its method signatures component (i.e., the second, third and fourth components of ) have no duplicate signature names, field names, and method names, respectively (For simplicity, method overloading is not modeled in our model of OOP.) It should be noted, however, that field names and method names are in separate name spaces and thus we allow a field and a method to have the same name.

Information in class signatures is derived from the text of classes of OO programs. Given that interfaces of objects are the basis for defining types in OO type systems, class signatures are the formal basis for nominally-typed OO type systems, so as to confirm that objects are used consistently and properly within a program ((AbdelGawad, 2016b), Ch. 2 of (AbdelGawad, 2013a), and (AbdelGawad, 2013b), give more details on types and typing in OOP.)

5.2. Signature Environments

A signature environment is a finite set of class signatures that has unique class names, where each signature name is associated with exactly one class signature in the environment. (Accordingly, function application notation can be used to refer to particular class signatures in a signature environment. If is a signature name guaranteed to be the name of some class signature in a signature environment , we use function application notation, , to refer to this particular class signature.) In addition to requiring the uniqueness of signature names, a finite set of class signatures needs to satisfy certain consistency conditions to function as a signature environment. A signature environment specifies two relations between signature names: an immediate supersignature relation and a direct-reference (adjacency) relation (The first relation is a subset of the second.) These two relations can be represented as directed graphs. The consistency conditions on a signature environment constrain these two relations and their corresponding graphs.

As such, a finite set of class signatures is a signature environment if and only if (i) A class signature, with the right signature name, belongs to for each signature reference in each class signature of , (ii) The graph for the supersignatures relation for is an acyclic graph (This constraint forces any signature environment to have at least one class signature that has no supersignatures, i.e., its second component is the empty sequence), and (iii) The set of field signatures and method signatures of each class signature in is a superset of the set of field signatures and method signatures of each supersignature named by the supersignatures component of .

In agreement with inheritance in mainstream OO languages, the last condition makes class signatures in signature environments reflect the explicit inheritance information in class-based OOP, by requiring a class signature to only extend (i.e., add to) the set of members supported by an explicitly-specified supersignature. Requiring the members of a class signature to be a superset of the members of all of its supersignatures means that exact matching of member signatures is required. This requirement thus enforces an invariant subtyping rule for field and method signatures, mimicking the rule used in mainstream OO languages (such as Java and C#) before the addition of generics. This condition can be relaxed but we do not do so in this paper. More details are available in (AbdelGawad, 2012).

5.3. Signature Closures

Inside a class signature, class names can be viewed as “pointers” that refer to other class signatures. Without bindings of class names to corresponding class signatures, a single class signature that has name references to other class signatures is not a closed entity on its own. This motivates the notion of a signature closure. A closure of a class signature is a set of class signatures (a signature environment, in particular) that offers bindings to class names referred to in all elements of the set, such that the whole set has no “dangling pointers” in its references to other class signatures (i.e., is referentially-closed) and has no redundant class signatures relative to some main class signature in the set (called the root class signature of the closure.) A signature closure thus “closes” the root class signature by providing bindings for all class names referenced, directly or indirectly, in the signature. This motivates the following formal definition of signature closures.

A signature closure is a pair of a signature name and a signature environment. A pair of a signature name and a signature environment is a signature closure if and only if there exists a class signature in with signature name and if the direct-reference (adjacency) relation corresponding to is referentially-closed relative to , and if this relation is the smallest such relation. Class signature is then called the root class signature of . Relative to the root class signature, a signature environment is minimal, i.e., contains no unnecessary class signatures. This minimality condition ensures that all class signatures in the signature environment of a signature closure are accessible via paths in the adjacency graph of the signature environment starting from (the node in the graph corresponding to) the root signature name, i.e., that the signature environment has no redundant class signatures unnecessary for the root class signature.

Similar to a single class signature, when viewed as a “closed class signature” a signature closure has a name: namely, that of its root class signature; has member signatures: namely, field and method signatures of its root class signature; has a fields shape and a methods shape: namely, those of its root class signature; and it has immediate supersignature names: namely, those of its root class signature. A signature closure, not just a class signature, is the full formal expression of the notion of object interfaces. Each class in a class-based OOP program has a corresponding class signature and a corresponding class signature closure. The nominal information in a class signature closure is an invariant of all instances of the class (including the behavioral contracts associated with class names.)

5.4. Relations on Signatures

For class signatures and , we define where is an equivalence relation on sequences that ignores the order (and repetitions) of elements of a sequence. For two field signatures and , Similarly, for two method signatures and , (Here, sequence equality, not sequence equivalence, is used. For method parameter signature names, order and repetitions do matter.)

Two signature environments are equal if and only if they are equal as sets. Two signature closures are equal if and only if they are equal as pairs. Equal signature closures have the same root class signature name and equal signature environments.

Finally, a relation between signature environments that is needed when we discuss inheritance is the extension relation on signature environments. A signature environment extends a signature environment (written ) if binds the names defined in to exactly the same class signatures as does. Viewed as sets, is a superset of . Thus,

5.5. Subsigning and Inheritance

The supersignatures component of class signatures defines an ordering relation between signature closures. We call this relation between signature closures subsigning. The subsigning relation between class signature closures models the inheritance relation between classes in class-based OOP.

A signature closure is an immediate subsignature () of a signature closure if the signature environment (i.e., the second component) of is an extension () of the signature environment of and the signature name of is a member of the supersignature names component of the root class signature of , i.e.,

The subsigning relation, , between signature closures is the reflexive transitive closure of the immediate subsigning relation (). To illustrate the definitions given in this section, Appendix A presents a few examples of signature constructs, and presents examples of signature closures that are in the subsigning relation.

The inclusion of class contracts in deciding the subsigning relation makes the subsigning relation a more accurate reflection of a true “is-a” (substitutability) relationship than the structural subtyping relation used in structurally-typed OOP. This makes subsigning capture the fact that subtyping in nominally-typed OOP is more semantically accurate than structural subtyping, as mentioned earlier, and as is explained in more detail in (AbdelGawad, 2016b).

6. : A Model of Nominal OOP

Using the records domain constructor () presented in Section 4 and signature constructs presented in Section 5, in this section we now present the construction of as a more precise model of nominally-typed mainstream OOP.

The construction of proceeds in two steps. First, the solution of a simple recursive domain equation defines a preliminary domain of raw objects, where an object in contains (1) a signature closure that encodes nominal information of nominally-typed OOP, and contains bindings for object members in two separate records: (2) a record for fields of the object, and (3) a record for methods of the object.

A simple recursive definition of objects with signature information does not force signature information embedded in objects to conform with their member bindings. Accordingly, in the second step of the construction of , invalid objects in the constructed preliminary domain of objects are “filtered out” producing a domain of proper objects that model nominal objects of mainstream OO software. Invalid objects are ones where the signature information is inconsistent with member bindings in the member records. The filtering of the preliminary domain is done by defining a projection function on the preliminary domain .

We call the model having the preliminary domain defined by the domain equation ‘’. Our target model, , is the one containing the image domain resulting from applying the filtering function on the preliminary domain of .

6.1. Construction of

The domain equation defining , and thence , uses two flat domains and . Domain is the flat domain of labels, and domain is the flat domain of signature closures (Section 5).

The domain equation that describes is


where the main domain defined by the equation, , is the domain of raw objects, is the strict product domain constructor, and is the records domain constructor (Section 4). Equation (4) states that every raw object (i.e., every element in ) is a triple of:

  1. A signature closure (i.e., a member of ),

  2. A fields record (i.e., a member of ), and

  3. A methods record (i.e., a member of where is the strict continuous functions domain constructor, and is the finite-sequences domain constructor.)

Domain of is the solution of Equation (4). Applying the iterative least-fixed point (LFP) construction method from domain theory (Cartwright et al., 2016), the construction of proceeds in iterations, driven by the structure of the right-hand side (RHS) of Equation (4). The RHS of the equation is viewed as a continuous function over domains (given the continuity of all used domain constructors, and that constructor composition preserves continuity.) Details of the iterative construction of are presented in (AbdelGawad, 2012).

The second step in constructing is the definition of a projection/filtering function, filter, to map domain of to the domain of valid objects modeling objects of nominally-typed OOP. For this, first, we define an object in to be valid as follows.

Definition 6.1.

An object in is valid if it is the bottom object , or if it is a non-bottom object such that

  • The fields shape and the methods shape of are exactly the same as (i.e., equal to) the shape of and the shape of , respectively,

  • Non-bottom valid objects bound to field names in have signature closures that subsign the signature closures for corresponding fields in , and

  • Non-bottom functions bound to method names in conform to corresponding method signatures in , where by conformance the functions are required to

    • take in sequences of valid objects whose embedded signature closures subsign (component-wise) the corresponding sequences of method parameter signature closures in , prepended with itself (for the implicit parameter self/this), and

    • return valid objects with signature closures that subsign the corresponding return value signature closures specified in the method signatures in .

As a direct translation of Definition 6.1, the function filter mapping into ( is a proper subdomain of ) is defined using the following three recursive function definitions, presented using lazy functional language pseudo-code.

  • fun filter(o:):

    match o with ((nm,se), fr, mr)

    if (sf-shp(se(nm)) != rec-shp(fr)) 

    (sm-shp(se(nm)) != rec-shp(mr))

    return  // non-matching shapes

    else // lazily construct closest valid object to o

    match se(nm), fr, mr with

    (_, _, [() | i=1,,m ],

    [() | j=1,,n]),

    (fr-tag, {   | i=1,,m}),
           (mr-tag, {   | j=1,,n})

    let si = se_clos(se, )

    let misj = map(se_clos(se), [nm::])

    // nm is prepended to  to  handle ‘this’

    let mosj = se_clos(se, )

    return ((nm,se),

    (fr-tag, {  filter-obj-sig(si,) | i=1,,m}),

    (mr-tag, {  filter-meth-sig(misj, mosj, )

    | j=1,,n})) 

    fun filter-obj-sig(ss:, o:):

    match o with (s, _, _)

    if (s  ss)

    return filter(o) // closest valid object to o


    return  // no subsigning 

    fun filter-meth-sig(in_s:, out_s:, m:):

    return (let vos = map2(filter-obj-sig, in_s, )

                 in filter-obj-sig(out_s, m(vos)))

In the definition of filter, functions sf-shp and sm-shp compute field and method shapes of signatures, while function rec-shp computes shapes of records. Function se_clos(se,nm) computes a signature closure corresponding to signature name nm whose first component is nm and whose second component is the minimal subset of signature environment se that makes se_clos(se,nm) a signature closure. To handle this/self a “curried” version of se_clos is passed to the map function. Additionally, domain is the domain of non-empty sequences of signature closures (non-empty because methods are always passed in the object this/self), and domains and are auxiliary domains of raw methods and methods, respectively. The function map2 is the two-dimensional version of map (i.e., takes a binary function and two input lists as its arguments.)

In words, the definition of the filtering function filter states that the function takes an object of and returns a corresponding valid object of . If the object is invalid because of non-matching shapes in the signature closure of and its member records, filter returns the bottom object (in domain , is the closest valid object to an invalid object with non-equal shapes in its signature and records.) Otherwise, has matching signature and record shapes but may have objects bound to its fields, or taken in or returned by its methods, whose signature closure does not subsign the corresponding signature closures in the signature closure of . In this case, filter lazily constructs and returns the closest valid object in domain to , where all non-bottom fields and non-bottom methods of are guaranteed (via functions filter-obj-sig and filter-meth-sig, respectively) to have signature closures that subsign the corresponding signature closures in the signature closure of .

Function filter-obj-sig checks if its input object o has a signature closure s that subsigns a required declared signature closure ss. If s is not a subsignature of ss, filter-obj-sig returns . If it is, the function calls filter on o, thereby returning the closest valid object to o.

For methods, when filter-meth-sig is applied to a method m it returns a valid method that when applied to the same input as m, returns the closest valid object to the output object of m that subsigns the declared output signature closure out_s corresponding to the sequence of valid objects closest (component-wise) to that (again, component-wise) subsigns the declared sequence of input signature closures in_s prepended with the signature closure of the object enclosing m (to properly filter the first argument object in , which is the value for this/self.)

Having defined the filtering function filter, the proof that domain , as defined by filter, is a well-defined computable subdomain of is presented in Appendix B.

6.2. Class Types

As constructed, is a nominal model of OOP, because objects of domain of include signatures specifying the associated class contracts maintained by the objects (including inherited contracts.) This nominal information encoded in signatures provides a framework for naturally partitioning the domain of objects into sets defining class types, where a type is a set of similar objects.

First, we define exact class types. The exact class type corresponding to a class C is the set of all objects tagged with the signature closure for C.555In Java, for example, objects in the exact type for a class C are precisely those for which the getClass() method returns the class object for C. Next, it should be noted that a cardinal principle of nominally-typed mainstream OOP is that objects from subclasses of a class C conform to the contract of class C and can be used in place of objects constructed using class C (i.e., in place of objects in the exact class type of C.) Hence, the natural type associated with class C, called the class type corresponding to or designated by C, consists of the objects in class C plus the objects in all subclasses of class C. In nominally-typed OO languages, the class type designated by class C is not the exact class type for C but the union of all exact types corresponding to classes that subclass (i.e., inherit from) class C, including class C itself.

Motivated by this discussion, we define class types in as interpretations of signature closures. For a signature closure , its interpretation is a subdomain of domain , having the same underlying approximation ordering of domain and whose universe is defined by the equation


In other words, the class type designated by a class is the interpretation of the signature closure corresponding to the class, which, in turn, is the set of all objects in domain of with a signature closure that subsigns , or the bottom object . Given that subsigning in models OO inheritance, the definition of class types is in full agreement with intuitions of mainstream OO developers.

Having defined class types, it should be noted that a class type is always a non-empty domain (i.e., always has some non-bottom object) because the object

(where is the fields shape of and is the methods shape of ) is always a valid constructed object (i.e., is an object of domain of that passes filtering to domain of .) This object is a member of by Equation (5). The non-emptiness of class types is used in the proof of the identification of inheritance and subtyping.

6.3. Inheritance is Subtyping

After we constructed , and after we defined class types in agreement with intuitions of mainstream OO developers, we can now easily see what it means for nominally-typed OO type systems to completely identify inheritance and subtyping. We express this statement formally as follows: Two signature closures corresponding to two classes are in the subsigning relation if and only if the class types denoted by the two signature closures are in the subset relation (i.e., the two classes are in the inheritance relation if and only if the corresponding class types are in the nominal subtyping relation.) We prove the correspondence between inheritance and subtyping in the following theorem.

Theorem 6.1.

For two signature closures and denoting class types and , we have


Based on Equation (5), and the non-emptiness of class types, the proof of this theorem is simple.

Case: The (only if) direction:

If , by applying the definition of (i.e., Equation (5)) all elements of belong to (the variable in Equation (5) is instantiated to , and is a common member in all class types.) Thus, .

Case: The (if) direction:

By the non-emptiness of there exists a non-bottom object of with signature closure . If , then . By Equation (5) all non-bottom members of must have a signature closure that subsigns . When applied to we thus have . ∎

We should notice in the proof above that it is the nominality of objects of (i.e., the embedding of signature closures into objects) that makes being a superset of imply that has as one of its supersignatures, and vice versa. The simplicity of the proof is a clear indication of the naturalness of the definitions for class signatures and class types.

7. Compared to Structural Models of OOP

Having presented , in this section we briefly compare to the most well-known structural domain-theoretic models of OOP, namely the model of Cardelli, which we call , and that of Cook, which we call .

Comparing to and reveals that includes full class name information while and totally ignore this information, based on the different views of type names adopted by each of the models. Objects in and are viewed as mere (plain) records, while in they are viewed as records that maintain contracts, which are referred to via nominal information, with nominal information being part of the identity of objects.

, and also have different views of types, type inheritance and subtyping, where behavioral contracts (via type name information) are part of the identity of types in , and thus are respected in type inheritance and subtyping, but contracts are ignored in and . In addition, and model recursive types, while does not. This leads (due to nominality) and (due to lack of recursive types) to identify type inheritance with OO subtyping while breaks that identification.

More details on the differences and similarities between , and can be found in (AbdelGawad, 2016a).

8. Conclusions

Based on realizing the semantic value of nominal-typing, in this paper we presented as a model of OOP that includes nominal information found in nominally-typed mainstream OO software. The inclusion of nominal information as part of the identity of objects and class types in led us to readily prove that type inheritance, at the syntactic level, and subtyping, at the semantic level, completely agree in nominally-typed OOP. A comparison of to structural models of OOP revealed nominal and structural models of OOP have different views on fundamental notions of OOP. It is necessary, we thus believe, to include nominal information in any accurate model of nominally-typed mainstream OOP. By its inclusion of nominal information, offers a chance to understand and advance OOP and current OO languages based on a firmer semantic foundation.

9. Future Work

One immediate possible future work that can be built on top of research presented in this paper is to define a minimal nominally-typed OO language, e.g., in the spirit of FJ (Igarashi et al., 2001), then, in a standard straightforward manner, give the denotational semantics of program constructs of this language in . The type safety of this language can then be proven using the given denotational semantics.

Generics add to the expressiveness of type systems of nominally-typed OO programming languages (Bank et al., 1996; Bracha et al., 1998; Cartwright & Steele, 1998; Langer, 2015; Bloch, 2008; Gosling et al., 2014; CSh, 2015; Sca, 2014). Another possible future work that can be built on top of is to produce a denotational model of generic nominally-typed OOP. Such a model may provide a chance for a better analysis of features of generics in nominally-typed mainstream OO languages and thus provide a chance for suggesting improvements and extensions to the type systems of these languages.


The authors are thankful to Benjamin Pierce for the feedback he offered on motivating and presenting .

Appendix A Class Signature Examples

To illustrate the definitions of signature constructs given in Section 5, in this appendix we present a few examples of signature constructs. Assuming the following OO class definitions (in Java-like pseudo-code),

  class Object {
    Boolean equals(Object o){  }
  class Boolean extends Object {
    Boolean equals(Object b){  }
     // other members of class Boolean
  class Pair extends Object {
    Object first, second;
    Boolean equals(Object p){  }
    Pair swap(){ return new Pair(second, first); }

we define the corresponding class signatures

(Object, [], [], [(equals, [Object], Boolean)]),

(Boolean, [Object], …), and

(Pair, [Object], [(first, Object), (second, Object)],
            [(equals, [Object], Boolean), (swap, [], Pair)])
and, hence, define signature environments {, }, and
{, , }, and the signature closures (Object, ), and = (Pair, ).

We can immediately see, using the definition of extension and the definitions of immediate subsigning and subsigning in Section 5, that , , and . The last conclusion expresses the fact that class Pair inherits from class Object, and the second to last conclusion expresses that class Pair is an immediate subclass of class Object (The reader is encouraged to find other similar conclusions based on the definitions of classes Object, Boolean and Pair given above.)

Appendix B Proofs

In this appendix we present proofs of main theorems in this paper, pertaining to the properties of the records domain constructor , and to the filtering of to . These proofs ascertain the well-definedness of and of the filtering, and thus their appropriateness for being used in constructing .

b.1. The Domain of Record Functions has an Effective Presentation

It is straightforward to confirm that constructs a domain. To prove that constructs domains given an arbitrary domain and a domain (with a fixed interpretation as a flat domain of labels), we build an effective presentation of the finite elements of , assuming an effective presentation of the finite elements of and . We prove that these finite elements form a finitary basis of the records domain. Since has a fixed interpretation, domain constructor can be considered as being parametrized only by domain .

Given an effective presentation of where , we define, for all , the finite sequences

where , and


The size , of , is the number of ones in the binary expansion of , and thus with equality only when is one less than a power of 2. only when , and in this case (the empty label sequence)666The definition of is patterned after a similar construction presented in Dana Scott’s “Data Types as Lattices” (Scott, 1976). Unlike the case in Scott’s construction, here, in the LHS of Equation (7), is doubled—i.e., the binary expansion of is “shifted left” by one position—to guarantee , and thus guarantee that is never an element of .. It is easy to confirm that there is a one-to-one correspondence between the set of natural numbers and the set of distinct finite label sequences .

Given an effective presentation of the finite elements of , an effective presentation of the finite elements of , the domain of (non-strict) sequences of length () of elements of , is

where, for ,

is the one-to-one -tupling function (also called the Cantor tupling function), and

is the one-to-one Cantor pairing function.

Now, let

where, again, is the number of ones in the binary expansion of , and

The sequence of the finite elements of can then be presented as , and for ,

Given the decidability of the consistency () and lub () relations for finite elements of , the presentation of the finite elements of is effective, since, for record functions and as defined in Section 4.2, under the approximation ordering defined by Equation 4.2, the consistency relation


is decidable (given the finiteness of records), and the lub relation


is recursive (handling or in the definitions of and is obvious. All record functions are consistent with , and the lub of a record function and is .)

Lemma B.1 ( constructs domains).

Under , elements of form a finitary basis of .


Given the countability of and of the finite elements of , elements of are countable. A consistent pair of elements , according to Equation (8), has a lub defined by Equation (9). Given that is a domain, the lub of all consistent pairs of finite elements , in exists, thus the lub also exists. ∎

Lemma B.1 actually proves that is a computable function that maps a pair of a flat domain and a domain to the corresponding record domain. The presumption is that no effective presentation is necessary for the flat domain because distinct indices for elements of will simply mean distinct labels . If is a flat countably infinite domain (which implies it has an effective presentation) and is an arbitrary domain, then the lemma asserts that is a domain with an effective presentation that is constructible from the effective presentations for and .

b.2. Domain Constructor is Continuous

Lemma B.2 ( is monotonic).

For domains and , and a flat domain of labels ,


First, we prove that is monotonic with respect to the subset relation on the universe of its input, i.e., that . Then, given that the approximation ordering on (as a subdomain of ) is the restriction of the approximation ordering on , we prove that the elements of (as members of ) form a domain under the approximation ordering of , and thus that is a subdomain of .

Since , then . For arbitrary where , we thus have

Thus, . Accordingly, for sets (the elements of with tag ) and (the elements of with tag ), as defined in Equation 2 of Section 4.2, we have . Thus,



Next, since is a subdomain of when restricted to elements of , we know: (i) the approximation relation on is the approximation relation on restricted to ; (ii) consistent pairs of are consistent pairs in ; and (iii) lubs, in , of consistent pairs of elements of are also their lubs in . Thus, for , , and

Hence, according to the definition of the approximation, consistency and lub relations for (Equations (4.2), (8) and (9)), the lub, in , of a consistent pair of records is also their lub in . That is, respectively, for , we have




From equations (10), (11), (12), (13), and the fact that is the bottom element of both and , we can conclude using Definition 6.2 in (Cartwright et al., 2016) that

In addition to being monotonic, continuity of a domain constructor asserts that the lub of domains it constructs using a chain of input domains is the domain it constructs using the lub of the chain of input domains (i.e., that, for , the lub of a chain of input domains gets mapped by to the lub, say domain , of the chain of output domains .)

Lemma B.3 ( preserves lubs.).

For a chain of domains , if , , and , then .


Let be the lub of the chain of domains (’s form a chain by the monotonicity of .) Domain is thus the union of domains , i.e., .

Domain is equal to because each element in ( is a record function) is an element of a domain for some . Given is a subset of , will also appear in .

Similarly, a record function in is an element of a domain for some , because every finite subset of has to appear in one (given that is a chain of domains.) Thus, by the definition of , is also a member of .

This proves that . ∎

Lemmas B.2 and B.3 prove that is computable given effective presentations for and (or, equivalently, an effective presentation for .)

b.3. Filtering is a Finitary Projection

In this section we prove that function filter, as defined in Section 6.1, is indeed a finitary projection, and thus that the domain of valid objects (Definition 6.1 in Section 6.1) defined by the filtering function is a subdomain of Scott’s universal domain , and thus is indeed a domain.

To do so, we first prove a number of auxiliary propositions regarding domain .

Proposition B.1.

In domain , higher-ranked objects do not approximate lower-ranked ones, i.e., implies


By strong induction on rank of objects. ∎

To prove that filter defines a projection, in the sequel we use the inductively-defined predicate valid (as defined by Definition 6.1 in Section 6.1) that applies to objects of . Note that, in addition to , objects with empty field and method records provide base cases for the definition of valid.

Lemma B.4 (filter returns the closest valid object that approximates its input object).

For an object of , filter() valid(filter()) ( valid() filter())


By strong induction on rank of objects, noting that, for the base case, filter(o) diverges (i.e., “returns” ) for the rank 0 input object , and if an object of rank 1 is invalid then filter(o) also returns (no distinct objects of rank 1 approximate each other.) Proposition B.1 is used for the inductive case.∎

Theorem B.1.

filter is a finitary projection.


We prove that filter is a finitary projection, on four steps.

  1. filter is a retraction: filter(filter(o)) = filter(o)


    Obvious from definition of filter, and that, by Lemma B.4, function filter returns a valid object (i.e., valid(filter(o))). ∎

  2. filter approximates identity: filter(o) o


    By Lemma B.4. ∎

  3. filter is a continuous function


    Direct, from the continuity of functions used to define filter (such as rec-shp, map, se_clos, etc.), and noting the closure of continuous functions under composition and lambda abstraction. ∎

  4. filter is finitary


    The condition in point 2 of Theorem 8.5 in (Cartwright et al., 2016), namely

    can be rewritten for the filtering function filter as


    Objects of domain are in one-to-one correspondence with principal ideals over their finitary basis. The filtering function filter returns, as its output, the closest valid object to its input object (The object returned is a well-defined object, and it is a fixed point of the filtering function.) Thus, given that objects correspond to strong ideals in the finitary basis of , they correspond to downward-closed sets. Condition (14) is thus true for all objects in .∎

Based on the definition of finitary projections, function filter is thus a finitary projection.∎


  • CPP (2011) 2011. ISO/IEC 14882:2011: Programming Languages: C++.
  • Sca (2014) 2014. The Scala Programming Language.
  • CSh (2015) 2015. C# Language Specification, Version 5.0.
  • Abadi & Cardelli (1994) Abadi, Martin, & Cardelli, Luca. 1994. A Semantics of Object Types. In: Proc. LICS’94.
  • Abadi & Cardelli (1996) Abadi, Martin, & Cardelli, Luca. 1996. A Theory of Objects. Springer-Verlag.
  • AbdelGawad (2012) AbdelGawad, Moez A. 2012. NOOP: A Mathematical Model of Object-Oriented Programming. Ph.D. thesis, Rice University.
  • AbdelGawad (2013a) AbdelGawad, Moez A. 2013a. NOOP: A Nominal Mathematical Model Of Object-Oriented Programming. Scholar’s Press.
  • AbdelGawad (2013b) AbdelGawad, Moez A. 2013b. An Overview of Nominal-Typing versus Structural-Typing in Object-Oriented Programming (with code examples). Tech. rept. [cs.PL].
  • AbdelGawad (2014a) AbdelGawad, Moez A. 2014a. A Domain-Theoretic Model of Nominally-Typed Object-Oriented Programming. Electronic Notes in Theoretical Computer Science (ENTCS), 301, 3–19.
  • AbdelGawad (2014b) AbdelGawad, Moez A. 2014b. Domain Theory for Modeling OOP: A Summary. Tech. rept. [cs.PL].
  • AbdelGawad (2016a) AbdelGawad, Moez A. 2016a. A Comparison of NOOP to Structural Domain-Theoretic Models of Object-Oriented Programming. Preprint available at
  • AbdelGawad (2016b) AbdelGawad, Moez A. 2016b. Why Nominal-Typing Matters in OOP. Preprint available at
  • Bank et al. (1996) Bank, Joseph A., Liskov, Barbara, & Myers, Andrew C. 1996. Parameterized types and Java. Tech. rept.
  • Bloch (2008) Bloch, Joshua. 2008. Effective Java. Prentice Hall PTR.
  • Bracha & Griswold (1993) Bracha, G., & Griswold, D. 1993. Strongtalk: typechecking Smalltalk in a production environment. Pages 215–230 of: OOPSLA’93.
  • Bracha et al. (1998) Bracha, Gilad, Odersky, Martin, Stoutamire, David, & Wadler, Philip. 1998. Making The Future Safe For The Past: Adding Genericity to The Java Programming Language. Pages 183–200 of: Chambers, Craig (ed), ACM Symposium on Object-Oriented Programming: Systems, Languages and Applications (OOPSLA), vol. 33. Vancouver, BC: ACM SIGPLAN, for ACM.
  • Bruce et al. (2003) Bruce, K., Schuett, A., van Gent, R., & Fiech., A. 2003. PolyTOIL: A type-safe polymorphic object-oriented language. ACM Transactions on Programming Languages and Systems, 25(2), 225–290.
  • Bruce (2002) Bruce, Kim B. 2002. Foundations of Object-Oriented Languages: Types and Semantics. MIT Press.
  • Cardelli (1984) Cardelli, Luca. 1984. A semantics of multiple inheritance. Pages 51–67 of: Proc. of the internat. symp. on semantics of data types, vol. 173. Springer-Verlag.
  • Cardelli (1988a) Cardelli, Luca. 1988a. A Semantics of Multiple Inheritance. Inform. and Comput., 76, 138–164.
  • Cardelli (1988b) Cardelli, Luca. 1988b. Structural Subtyping and the Notion of Power Type. In: ACM Proceedings of POPL.
  • Cardelli et al. (1989) Cardelli, Luca, Donahue, James, Glassman, Lucille, Jordan, Mick, Kalsow, Bill, & Nelson, Greg. 1989. Modula-3 Report (Revised). Vol. 52. Digital Systems Research Center.
  • Cartwright & Steele (1998) Cartwright, Robert, & Steele, Guy L., Jr. 1998. Compatible Genericity with Run-time Types for the Java Programming Language. Pages 201–215 of: Chambers, Craig (ed), ACM Symposium on Object-Oriented Programming: Systems, Languages and Applications (OOPSLA), vol. 33. Vancouver, BC: ACM SIGPLAN, for ACM.
  • Cartwright et al. (2016) Cartwright, Robert, Parsons, Rebecca, & AbdelGawad, Moez A. 2016. Domain Theory: An Introduction. Preprint available at
  • Cook (1989) Cook, William R. 1989. A Denotational Semantics of Inheritance. Ph.D. thesis, Brown Univ.
  • Cook (2009) Cook, William R. 2009. On Understanding Data Abstraction, Revisited. vol. 44. ACM.
  • Cook & Palsberg (1989) Cook, William R., & Palsberg, Jens. 1989. A Denotational Semantics of Inheritance and Its Correctness. Pages 433–444 of: ACM Symposium on Object-Oriented Programming, Systems, Languages and Applications (OOPSLA).
  • Cook et al. (1990) Cook, William R., Hill, Walter L., & Canning, Peter S. 1990. Inheritance is not Subtyping. In: POPL’90 Proceedings.
  • Drossopoulou et al. (1999) Drossopoulou, Sophia, Eisenbach, Susan, & Khurshid, Sarfraz. 1999. Is the java type system sound? TAPOS, 5(1), 3–24.
  • Fisher & Reppy (1999) Fisher, K., & Reppy, J. 1999. The design of a class mechanism for Moby. In: PLDI.
  • Flatt et al. (1998) Flatt, Matthew, Krishnamurthi, Shriram, & Felleisen, Matthias. 1998. Classes and mixins. Pages 171–183 of: Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM.
  • Flatt et al. (1999) Flatt, Matthew, Krishnamurthi, Shriram, & Felleisen, Matthias. 1999. A programmer’s reduction semantics for classes and mixins. Pages 241–269 of: Formal syntax and semantics of Java. Springer.
  • Gierz et al. (2003) Gierz, G., Hofmann, K. H., Keimel, K., Lawson, J. D., Mislove, M. W., & Scott, D. S. 2003. Continuous Lattices and Domains. Encyclopedia Of Mathematics And Its Applications, vol. 93. Cambridge University Press.
  • Gordon et al. (1978) Gordon, Michael J., Milner, Arthur J., & Wadsworth, Christopher P. 1978. Edinburgh LCF: A Mechanized Logic of Computation. Springer-Verlag.
  • Gosling et al. (2014) Gosling, James, Joy, Bill, Steele, Guy, Bracha, Gilad, & Buckley, Alex. 2014. The Java Language Specification. Addison-Wesley.
  • Gunter & Scott (1990) Gunter, C. A., & Scott, Dana S. 1990. Handbook of Theoretical Computer Science. Vol. B. Chap. 12 (Semantic Domains).
  • Igarashi et al. (2001) Igarashi, Atsushi, Pierce, Benjamin C., & Wadler, Philip. 2001. Featherweight Java: A Minimal Core Calculus for Java and GJ. ACM Transactions on Programming Languages and Systems, 23(3), 396–450.
  • Langer (2015) Langer, Angelika. 2015. The Java Generics FAQ.
  • Leroy et al. (n.d.) Leroy, X., Doligez, D., Garrigue, J., Rémy, D., & Vouillon., J. The Objective Caml system. Available at
  • MacQueen (2002) MacQueen, David B. 2002. Should ML be Object-Oriented? Formal Aspects of Computing, 13, 214–232.
  • MacQueen et al. (1986) MacQueen, David B., Plotkin, Gordon D., & Sethi, R. 1986. An Ideal Model for Recursive Polymorphic Types. Information and Control, 71, 95–130.
  • McCarthy (1963) McCarthy, John. 1963.

    A Basis For A Mathematical Theory Of Computation.

    Computer Programming and Formal Systems, 33–70.
  • McCarthy (1996) McCarthy, John. 1996. Towards a Mathematical Science of Computation. Science.
  • Milner et al. (1997) Milner, R., Tofte, M., Harper, R., & MacQueen, D. 1997. The Definition of Standard ML (Revised). MIT Press.
  • Nipkow & Von Oheimb (1998) Nipkow, Tobias, & Von Oheimb, David. 1998. Java is type-safe–definitely. Pages 161–170 of: Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM.
  • Odersky (2014) Odersky, Martin. 2014. The Scala Language Specification, v. 2.9.
  • Pierce (2002) Pierce, Benjamin C. 2002. Types and Programming Languages. MIT Press.
  • Reus (2002) Reus, Bernhard. 2002. Class-based versus Object-based: A Denotational Comparison. Algebraic Methodology And Software Technology, Lecture Notes in Computer Science, 2422, 473–488.
  • Reus (2003) Reus, Bernhard. 2003. Modular Semantics and Logics of Classes. Pages 456–469 of: Computer Science Logic, vol. 2803. Springer.
  • Reus & Streicher (2002) Reus, Bernhard, & Streicher, Thomas. 2002. Semantics and Logics of Objects. Proceedings of the 17th Symp. on Logic in Computer Science (LICS 2002), 113–122.
  • Scott (1976) Scott, Dana S. 1976. Data Types as Lattices. SIAM Journal of Computing, 5(3), 522–587.
  • Scott (1983) Scott, Dana S. 1983. Domains for Denotational Semantics. Tech. rept. Computer Science Department, Carnegie Mellon University.
  • Simons (2002) Simons, Anthony J. H. 2002. The Theory of Classification, Part 1: Perspectives on Type Compatibility. Journal of Object Technology, 1(1), 55–61.
  • Smyth & Plotkin (1982) Smyth, M. B., & Plotkin, Gordon D. 1982. The Category-Theoretic Solution of Recursive Domain Equations. SIAM J. of Computing, 11, 761–783.
  • Stoy (1977) Stoy, Joseph E. 1977. Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory. MIT Press.