this post was submitted on 11 Apr 2024
13 points (93.3% liked)
Programming Languages
1186 readers
1 users here now
Hello!
This is the current Lemmy equivalent of https://www.reddit.com/r/ProgrammingLanguages/.
The content and rules are the same here as they are over there. Taken directly from the /r/ProgrammingLanguages overview:
This community is dedicated to the theory, design and implementation of programming languages.
Be nice to each other. Flame wars and rants are not welcomed. Please also put some effort into your post.
This isn't the right place to ask questions such as "What language should I use for X", "what language should I learn", and "what's your favorite language". Such questions should be posted in /c/learn_programming or /c/programming.
This is the right place for posts like the following:
- "Check out this new language I've been working on!"
- "Here's a blog post on how I implemented static type checking into this compiler"
- "I want to write a compiler, where do I start?"
- "How does the Java compiler work? How does it handle forward declarations/imports/targeting multiple platforms/?"
- "How should I test my compiler? How are other compilers and interpreters like gcc, Java, and python tested?"
- "What are the pros/cons of ?"
- "Compare and contrast vs. "
- "Confused about the semantics of this language"
- "Proceedings from PLDI / OOPSLA / ICFP / "
See /r/ProgrammingLanguages for specific examples
Related online communities
- ProgLangDesign.net
- /r/ProgrammingLanguages Discord
- Lamdda the Ultimate
- Language Design Stack Exchange
founded 1 year ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
🙄 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 | int
is 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.Anti Commercial-AI license
@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?Anti Commercial-AI license
@onlinepersona
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.
Car = String X String x u8
.An enum is a series of "or"s.
can also be thought of as
Animal = Dog | Cat | Giraffe | Chimpanzee
. WhereDog
is 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:In this case is
Something(u32)
the equivalent of any "tagged"u32
, meaning in memory it's something like aTag + 32 bits
whereTag
is a constant string of bits, maybe itself au32
? Wouldn't that make it a product type?But then
LotsOfThings
is itself a product typeLotsOfThings = bool x String
.So to put it all together
ComplexEnum = Nothing | TaggedU32 | (bool x String)
? Is that correct?Anti Commercial-AI license
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 u32
because 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.
Anti Commercial-AI license
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.
Agreed, but they exist due to historic reasons, and now we're stuck with them. Not much we can do there ¯\_(ツ)_/¯
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).
It just means that the variable can either be a
str
or 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?
Anti Commercial-AI license
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 | float
is incorrect?Anti Commercial-AI license
In most programming languages, integers are not considered a subset of floats, so when you have the type
Int | Float
, you can distinguish3
from3.0
.It makes sense when using some fluent patterns and things like monads. For example:
A UserWithPassword type would then be a User object wrapper with some
IWithPassword
interfaceThen you could create extension methods on
IWithPassword
objects 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).
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.
Anti Commercial-AI license
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
a product? What is it a product of? And why is the type itself a product, not
Dog x Cat
? Or isDog x Cat
indeed some kind of product that I'm not aware of but with another syntax?Anti Commercial-AI license
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:
The possible values for
A
are just one:A
. The possible values forB
areB( true )
andB( false )
. So the total possible values forFoo
are simply these sets combined:A
orB( 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
A
andB
. 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,
Dog
is 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 possibleDog
you currently have, two possibilities would be created, one with atrue
and one with afalse
.As for your last question, some languages might use
x
as 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 ofDog
andCat
would be written as(Dog, Cat)
.