● Covered by 1 source · 1 reportLow impact1 neutral
Mutable and Immutable Data Structures Cannot Be Subtypes of Each Other
Key points
- Liskov's Substitution Principle defines subtyping: S is a subtype of T if S can be used everywhere T is expected.
- Immutable types cannot be subtypes of mutable types because they lack modification operations.
- Mutable types cannot be subtypes of immutable types due to differing implicit contracts, such as guaranteed immutability.
- Violating this principle compromises type checking guarantees in programming languages.
The Subtyping Dilemma
The question of whether mutable and immutable data structures can be subtypes of each other frequently arises in programming language discussions. While it is technically possible to implement such relationships, it is not formally correct and can lead to a loss of type checking guarantees within a language's static type system.
Liskov's Substitution Principle
The core reason for this incompatibility lies in Liskov's Substitution Principle. This principle states that a type S is a subtype of T only if a value of type S can be used in *every* context where a value of type T is expected. This definition is strictly interpreted; 'every' means without exception, not just in most cases. A static type system relies on this strict adherence to prove type correctness.
Why Immutable Cannot Be a Subtype of Mutable
An immutable data structure cannot be substituted where a mutable one is expected. A context requiring a mutable type would likely attempt to perform modification operations, which are not defined for an immutable type. This would result in a type error, violating the substitution principle.
Why Mutable Cannot Be a Subtype of Immutable
The inverse, where a mutable type is used in place of an immutable one, is more subtle but equally problematic. While a mutable type might provide all the operations of an immutable type, it violates the implicit contract of immutability. For example, an immutable pair guarantees that its contents will remain constant, allowing for safe hashing or storage. A mutable pair offers no such guarantee, meaning its value could change unexpectedly, breaking the contract expected by contexts requiring an immutable type.
✨ This summary was generated by AI from the outlets' reporting listed below. It is not independently verified and may contain errors — check the original sources. How BrevFeed works →
The daily brief
One email each morning: the day's tech stories, clustered across outlets and summarized. No account needed.
One email a day. Unsubscribe in one click, any time.
Today's brief
Spend a few minutes, get the whole day. Every topic's top stories in one hands-free rundown — listen, watch, or read the transcript.
▶ Play today's brief
New every morning, and the back catalogue is archived by date.
Reporting from
Mutable and immutable variants of data structures cannot be subtypes or supertypes of one another due to the strict interpretation of Liskov's Substitution Principle. This principle requires that a subtype can be used in *every* context where its supertype is expected, which is violated by both mutable and immutable types when considered as subtypes of each other.