News for hackers. Stuff that matters.

A comment on Union types ('enum types') would be complicated in Go. Parent comment

Re:Union types ('enum types') would be complicated in Go by siebenmann on Wednesday December 04, 2024 @04:07PM (#42322060)
The problem with allocating bit-packed storage is that then you are into the issue where types don't agree on where any pointers are. Interface values solve this today because they are always mono-typed (an interface value always stores two pointers), so the runtime is never forced to know the current pointer-containing shape of a specific interface value. And the values that interface values 'contain' are also always a fixed type, so they can be allocated and maintained with existing GC mechanisms (including special allocation pools for objects without pointers and etc etc).

I agree with you about the overall motivation for Rust-style enums. I just think it's surprisingly complex to get even the memory efficiency advantages, never mind anything more ambitious.

[ Parent | on HN ]
Re:Union types ('enum types') would be complicated in Go by foldr on Thursday December 05, 2024 @04:21AM (#42326442)
I was saying that you can have a single allocation without using bit packing.

I'm not sure what you're referring to with 'anything more ambitious'.

[ Parent | on HN ]
Re:Union types ('enum types') would be complicated in Go by treyd on Friday December 06, 2024 @10:25PM (#42346996)
> The problem with allocating bit-packed storage is that then you are into the issue where types don't agree on where any pointers are.

The solution to this should be trivial. You just have to extend the gcshape concept to account for the enum discriminator.

[ Parent | on HN ]
Re:Union types ('enum types') would be complicated in Go by ryanpetrich on Friday December 06, 2024 @10:57PM (#42347144)
The bigger problem is mutability. Any pointers into the bit-packed enum storage become invalid as soon as you change its type. To solve this you can either prohibit pointers into bit-packed enum storage, which is very limiting, or introduce immutability into the language. Immutability is particularly difficult to add to go, where default zero-values emerge in unexpected places (such as the spare capacity of slices and the default state of named return values)
[ Parent | on HN ]