If Inheritance is so bad, why does everyone use it?
If Inheritance is so bad, why does everyone use it?
Alloy Workshop There are still two slots available for the alloy workshop! I've been hard at work adding a bunch of teaching innovations to the class, which...
This essay says that inheritance is harmful and if possible you should "ban inheritance completely". You see these arguments a lot, as well as things like "prefer composition to inheritance". A lot of these arguments argue that in practice inheritance has problems. But they don't preclude inheritance working in another context, maybe with a better language syntax. And it doesn't explain why inheritance became so popular in the first place. I want to explore what's fundamentally challenging about inheritance and why we all use it anyway.
You're viewing a single thread.
🙄 people who blindly say "inheritance is bad" or "composition over inheritance" and mean "no inheritance" are just like followers of religion. Always repeating the same stuff without thinking and being completely convinced they are right. Nigh everything has a place and a valid usecase and just because you don't see it doesn't mean nobody else does.
Edit: Also "sum types" and "algebraic data types" are horrible names. Pretty much the equivalent of "imaginary numbers". What the fuck is a "sum type"? How do you "add" types together? Adding numbers makes sense, it has a real world equivalent. Two balls in a cup, add one ball and you have three balls in a cup. Add color to water and you have colored water. Simple. But types? The fuck?
str | intis a sum type --> does that mean sum types are adding two spaces of possibilities together aka a union of two sets? The wikipedia article is so friggin bad at explaining it to people who aren't in the know.@onlinepersona @armchair_progamer
A type has a number of 'inhabitants'. 'Sum' indeed corresponds to adding the possible inhabitants together.
A Boolean has two inhabitants - true and false. A byte has 256 inhabitants. A BoolOrByte type has 258 inhabitants.
If you have BoolByte pair, that's a product type - 512 possible inhabitants.
It may make no fucking sense depending on your exposure to Java, where Void (literally 'empty') has an inhabitant, and Boolean has 5.
OK, that explains
bool | byte, but how is an enum a sum type? And what's a product type? A product of sets is a cartesian product. How does that work with types?An enum is a sum type because the number of inhabitants of the enum is the sum of the inhabitants of its parts.
A product type's number of inhabitants is the product of its parts' inhabitants. So a struct would fit that definition, or a pair, or a tuple.
Looking at the pic on your Cartesian product link:
if A is an enum {x,y,z} and B is an enum {1,2,3}, then a struct AxB has 9 possible inhabitants.OK, I think I'm getting it.
A product is a set that this is the result of an ordered cartesian products.
struct Car { make: String, model: String, seats: u8, }Car = String X String x u8.
An enum is a series of "or"s.
enum Animal { Dog, Cat, Giraffe, Chimpanzee, }can also be thought of as
Animal = Dog | Cat | Giraffe | Chimpanzee. WhereDogis a type that only has single value in its set akaAnimal = {1} | {2} | {3} | {4}, but it could also be strings, or other objects. Rust however allows more complex objects:enum ComplexEnum { Nothing, Something(u32), LotsOfThings { usual_struct_stuff: bool, blah: String, } }In this case is
Something(u32)the equivalent of any "tagged"u32, meaning in memory it's something like aTag + 32 bitswhereTagis a constant string of bits, maybe itself au32? Wouldn't that make it a product type?
But thenLotsOfThingsis itself a product typeLotsOfThings = bool x String.So to put it all together
ComplexEnum = Nothing | TaggedU32 | (bool x String)? Is that correct?So to put it all together
ComplexEnum = Nothing | TaggedU32 | (bool x String)? Is that correct?Pretty much, yeah. But just be aware the tags are effectively unique constants, so each has only one value. For consistency I would write it as:
ComplexEnum = Nothing | Something(u32) | LotsOfThings(bool x String)In this notation,
Something(u32)could also be written as1 x u32because tags are constants.OK, so finally I get it. It's pity none of the blogs I've read or wikipedia articles in existence spell it out this way. Instead it's a bunch of math mumbo jumbo.
Thanks for helping me reach understanding 🙏 And thanks to @[email protected] too.
just like followers of religion
We say that shit, because we've touched code that's deeply inherited, and it was a god-damn pain to work with, because changing a single line can mean you'll need to update a fuckton more, which breaks tests all god-damn over, which means you may have to refactor 50% of the application in one go.
Anyway, everything has its uses (even goto). It's just there are typically better alternatives.
“sum types” and “algebraic data types” are horrible names.
Agreed, but they exist due to historic reasons, and now we're stuck with them. Not much we can do there ¯\_(ツ)_/¯
Pretty much the equivalent of “imaginary numbers”.
Terrible name that just means "vertical number line" (with an added operation where you rotate the vector, instead of add or scale), or "y-axis for the number line". It's funny because "Real" numbers are about as real as "Imaginary" numbers. Both are virtual (not physically existing).
str | intis a sum typeIt just means that the variable can either be a
stror anint. You've seen|used as "bitwise or", right? Think in that direction.PS: Stay away from Monads - they'll give you an aneurysm. 😂
In some langs like Python,
|is also the "union" operator, to join sets and such, which I think is more directly related to types, since types are sets of possible values.
The sum and product types follow pretty much the same algebraic laws as natural numbers if you take isomorphism as equality.
Also class inheritance allows adding behaviour to existing classes, so it's essentially a solution to the expression problem.
Yes, I know some of those words. Could you repeat that for those that aren't mathematicians or in the know?
As you already figured out the types are sets with a certain number of elements.
Two types are isomorphic if you can write a function that converts all elements of the first one into the elements of the second one and a function which does the reverse. You can then use this as the equality.
The types with the same number of elements are isomorphic, i.e True | False = Left | Right. For example, you can write a function that converts True to Left, False to Right, and a function that does the reverse.
Therefore you essentially only need types 0, 1, 2, 3, ..., where type 0 has 0 elements, type 1 has 1 element, etc. and all others are isomorphic to one of these.
Let's use (*) for the product and (+) for the sum, and letters for generic types. Then you can essentially manipulate types as natural numbers (the same laws hold, associativity, commutativity, identity elements, distributivity).
For example:
2 = 1 + 1 can be interpreted as Bool = True | False
2 * 1 = 2 can be interpreted as (Bool, Unit) = Bool
2 * x = x + x can be interpreted as (Bool, x) = This of x | That of x
o(x) = x + 1 can be interpreted as Option x = Some of x | None
l(x) = o(x * l(x)) = x * l(x) + 1 can be interpreted as List x = Option (x, List x)
l(x) = x * l(x) + 1 = x * (x * l(x) + 1) + 1 = x * x * l(x) + x + 1 = x * x * (l(x) + 1) + x + 1 = x * x * l(x) + x * x + x + 1 so a list is either empty, has 1 element or 2 elements, ... (if you keep substituting)
For the expression problem, read this paper: doi:10.1007/BFb0019443
Mathematically, the union of disjoint sets is often called the sum. This is a natural name because when you look at the number of elements (or in general, any measure), it will be the actual numeric sum.
Why the emphasis on "disjoint"? Aren't integers a subset of floats? Would that mean then that
int | floatis incorrect?In most programming languages, integers are not considered a subset of floats, so when you have the type
Int | Float, you can distinguish3from3.0.
How do you “add” types together? Adding numbers makes sense, it has a real world equivalent. Two balls in a cup, add one ball and you have three balls in a cup. Add color to water and you have colored water. Simple. But types? The fuck?
It makes sense when using some fluent patterns and things like monads. For example:
User user = new User("Bob"); // User Class UserWithPassword user = new User("Bob").WithPassword("Dylan123"); // UserWithPassword TypeA UserWithPassword type would then be a User object wrapper with some
IWithPasswordinterfaceThen you could create extension methods on
IWithPasswordobjects and decorate those objects with password behaviorYou can then have sort of polymorphic behavior by combining types together, and have different functionality available depending on which types you've added together
Saying "X is bad" or "Y over X" is not the same as saying "there is never a place for X". I think JS is a pretty bad language, and prefer other languages to it, but I still recognise very obvious places where it should be used.
Maybe it depends on the way you understand types, but to me sum and product types are completely intuitive. A type is a set of possible values. A sum type is multiple sets added together (summed).
Saying “X is bad” or “Y over X” is not the same as saying “there is never a place for X”.
That rarely comes across online where opinions are often stated dichotomously. Especially when speaking of inheritance, some crowds (I've noticed this in the Rust crowd) are vehemently against it and will do nigh anything not to think of a problem as one of inheritance nor a solution that could benefit from inheritance. The makers of the servo browser engine which has to implement hierarchical structures (the DOM) ran against this exact issue within the Rust community where inheritance might as well equate to blasphemy.
I recognise that it's probably a loud, zealous minority, but it makes interacting with the rest of the community rather difficult.
A type is a set of possible values. A sum type is multiple sets added together (summed).
That makes sense for
str | int, but how is an enum a "sum type"?As for product types, in set theory a product of sets is a cartesian product. How is a
struct Dog { height: u8 length: u8, name: String, } impl Dog { fn bark() { println!("woof!"); } }a product? What is it a product of? And why is the type itself a product, not
Dog x Cat? Or isDog x Catindeed some kind of product that I'm not aware of but with another syntax?Well what is an enum except a chain of
X | Y | Z | .... An enum can be any of its variants, and therefore the set of its possible values are just all possibilities of its variants added together.Consider this enum:
enum Foo { A, B(bool), }The possible values for
Aare just one:A. The possible values forBareB( true )andB( false ). So the total possible values forFooare simply these sets combined:AorB( true )orB( false ).As for product types, what it is the product is, is still the same: the sets of possible values. Consider the possible values for the product of
AandB. For every possible value ofA, a value could be made by matching it with any possible value ofB(so, multiplication). If there are 3 possible values ofA, and two possible values ofB, then the total number of possible combinations of these for the product type is 6.In your example,
Dogis a product ofu8, anotheru8, andString. If you decide to add a Boolean field to this type, accordingly the size of the set of options would double, because for every possibleDogyou currently have, two possibilities would be created, one with atrueand one with afalse.As for your last question, some languages might use
xas a product type syntax, but because tuples and structs are inherently product types, most languages use those as Syntax. For example in Haskell the product type ofDogandCatwould be written as(Dog, Cat).