Re:Switching from C++ to Rust
by cornstalks on Monday March 13, 2023 @08:09PM
(#35145254)
The union part is just an (obvious) optimization. An implementation detail. Sum types are not required to use a union; they can be implemented without using a union.
[ Parent
| on HN ]
how, exactly?
Re:Switching from C++ to Rust
by cornstalks on Monday March 13, 2023 @08:18PM
(#35145349)
By using a struct with lazily initialized members, for example.
if that is your example, provide some code.
Re:Switching from C++ to Rust
by cornstalks on Monday March 13, 2023 @09:07PM
(#35145891)
Pretend we have the following sum type:
enum SumType {
Foo(foo),
Bar(bar),
Baz(baz),
}
void DoSomething(SumType sum_type) {
match sum_type {
Foo(foo): foo.do_x();
Bar(bar): bar.do_y();
Baz(baz): baz.do_z();
}
}
This could be lowered to: struct LoweredSumType {
optional<Foo> foo;
optional<Bar> bar;
optional<Baz> baz;
}
void DoSomething(LoweredSumType sum_type) {
if (sum_type.foo.has_value()) {
sum_type.foo->do_x();
} else if (sum_type.bar.has_value()) {
sum_type.bar->do_y();
} else {
sum_type.baz->do_z();
}
}
This isn't real code; it's a pretend language that's kind of a mix of Rust and C++. But it illustrates that the sum type can be lowered into a non-union representation.> Pretend we have the following sum type:
which looks remarkably like a union to me, if i understand your made-up language.
It's not a union, though, it stores references to three memory locations, not just one (as a union represents a single memory location which can have multiple possible interpretations). And the lowered code has nothing protecting it from an invariant where more than one reference is non-null!
Re:Switching from C++ to Rust
by the-smug-one on Monday March 13, 2023 @08:52PM
(#35145712)
Why does the members be lazily init:ed?
Re:Switching from C++ to Rust
by cornstalks on Monday March 13, 2023 @09:00PM
(#35145817)
If the data types have constructors and/or destructors that have side effects then it has to be lazy. Otherwise IMO it's not really behaving like a sum type.
Re:Switching from C++ to Rust
by the-smug-one on Monday March 13, 2023 @08:50PM
(#35145697)
struct List {};
struct Cons : public List {
Cons(int v, List* nxt);
int v; List* nxt;
};
struct Nil : public List {};
This is how you'd do it in Java.
and you would use it ... how?
It's not exactly Java, but:
Cons(1, Cons(2, Cons(3, Nil)))Actually, Java does have sum types nowadays, and you can write a recursive list implementation like “new Cons(2, new Cons(3, Nil.nil()))”.
Here is a definition for a Maybe type, converting it to a List is left as an exercise to the reader :) : https://news.ycombinator.com/item?id=35133670
I just meant because I was eliding the `new`s.
Re:Switching from C++ to Rust
by the-smug-one on Tuesday March 14, 2023 @04:55AM
(#35148859)
I've showed you an alternative encoding, maybe get to work and learn something yourself?