[Paper Review] Why Nominal-Typing Matters in OOP

Moez A. AbdelGawad|arXiv (Cornell University)|Jun 13, 2016

Logic, programming, and type systems40 references3 citations

TL;DR

This paper argues that nominal typing in object-oriented programming (OOP) provides essential semantic clarity by linking type names to behavioral contracts, enabling a one-to-one correspondence between inheritance and subtyping—contrary to structural OOP models. It demonstrates through domain-theoretic comparison that nominal typing supports robust, maintainable software design, advocating for future foundational OOP research to prioritize nominal models over structural ones.

ABSTRACT

The statements `inheritance is not subtyping' and `mainstream OO languages unnecessarily place restrictions over inheritance' have rippled as mantras through the PL research community for years. Many mainstream OO developers and OO language designers however do not accept these statements. In \emph{nominally-typed} OO languages that these developers and language designers are dearly familiar with, inheritance simply is subtyping; and they believe OO type inheritance is an inherently nominal notion not a structural one. Nominally-typed OO languages are among the most used programming languages today. However, the value of nominal typing to mainstream OO developers, as a means for designing robust OO software, seems to be in wait for full appreciation among PL researchers--thereby perpetuating an unnecessary schism between many OO developers and language designers and many OO PL researchers, with each side discounting, if not even disregarding, the views of the other. In this essay we strengthen earlier efforts to demonstrate the semantic value of nominal typing by presenting a technical comparison between nominal OO type systems and structural OO type systems. Recently, a domain-theoretic model of nominally-typed OOP was compared to well-known models of structurally-typed OOP. Combined, these comparisons provide a clear and deep account for the relation between nominal and structural OO type systems that has not been presented before, and they help demonstrate the key value of nominal typing and nominal subtyping to OO developers and language designers. We believe a clearer understanding of the key semantic advantage of pure nominal OO typing over pure structural OO typing can help remedy the existing schism. We believe future foundational OO PL research, to further its relevance to mainstream OOP, should be based less on structural models of OOP and more on nominal ones instead.

Motivation & Objective

• To challenge the prevailing PL research view that inheritance and subtyping are distinct in OOP, especially in nominally-typed languages.
• To demonstrate that nominal typing provides a more semantically meaningful and practical foundation for OOP than structural typing.
• To bridge the schism between mainstream OO developers/language designers and PL researchers by showing the technical and semantic value of nominal typing.
• To argue that future foundational OOP research should shift from structural models to nominal models to improve relevance and practical impact.

Proposed method

• Conducting a technical comparison between domain-theoretic models of nominally-typed OOP and well-known models of structurally-typed OOP.
• Analyzing how class names in nominally-typed languages serve as references to behavioral contracts, embedding semantic meaning into types.
• Contrasting the role of type names in nominal systems (fixed, contract-associated) with their role in structural systems (synonyms without inherent meaning).
• Examining the implications of nominality on subtyping, inheritance, and type reification, particularly in the context of binary methods and recursive types.
• Using Table 3 to systematically compare key features such as contract inclusion, type reification, and subsumption behavior between nominal and structural systems.
• Highlighting how generics and F-bounded polymorphism in languages like Java further support the viability and expressiveness of nominal typing.

Experimental results

Research questions

• RQ1 Why do mainstream OO developers and language designers perceive inheritance and subtyping as equivalent in languages like Java and C#?
• RQ2 What semantic advantages does nominal typing offer over structural typing in OOP type systems?
• RQ3 How do domain-theoretic models of nominal and structural OOP differ in their treatment of behavioral contracts and type identity?
• RQ4 To what extent does nominal typing enable a one-to-one correspondence between inheritance and subtyping?
• RQ5 Can a clearer understanding of nominal typing help reconcile the divide between PL researchers and mainstream OOP practitioners?

Key findings

• Nominal typing allows type names to directly reference behavioral contracts, making object specifications more explicit and statically checkable.
• In nominally-typed OOP, type inheritance and subtyping are one-to-one, preserving the mental model of developers and ensuring consistency.
• Structural OOP models ignore behavioral contracts, leading to spurious subsumption and binary method issues that nominal typing avoids.
• Nominal typing naturally supports recursive types and binary methods, while structural systems require special constructs or face expressiveness limitations.
• The absence of type name rebindability in nominal systems ensures type stability and prevents semantic confusion during inheritance.
• The paper concludes that future foundational OOP research should prioritize nominal models to better serve mainstream software development.