On Wednesday, 8 September 2021 at 09:55:20 UTC, Chris Piker wrote:
Interesting. I presume that the big win for using std.sumtype
over a class set is value semantics instead of reference
semantics?
There's a lot to say about the precise differences. One practical
difference that I alluded to earlier is that an incomplete
`match!` is a compile-time error, so if you later add a fifth
kind of time encoding to your sumtype, the compiler will give you
a laundry list of parts of your code to update to handle the new
case.
So out of curiosity, say each structure implemented a function
to provide the desired broken-down-time, would the following
"virtual function" style call work?
```d
import std.sumtype;
struct BDTime { int y, int m, int d, int h, int m, double s };
struct ISO8601 { BDTime bdTime(){ ... } }
struct FloatEpoch { BDTime bdTime(){ ... } }
struct DoubleEpoch { BDTime bdTime(){ ... } }
struct LongEpoch { BDTime bdTime(){ ... } }
alias Time = SumType!(ISO8601, FloatEpoch, DoubleEpoch,
LongEpoch);
void main() {
import std.stdio : writeln;
import std.format : format;
Time e = ISO8601();
BDTime = e.bdTime();
}
```
or would I need to use `match!` to get the right structure type
and then generate the internal time representation?
You'd get an error like
```
Error: no property `bdTime` for type
`std.sumtype.SumType!(ISO8601, ...)`
```
bdTime is defined for the individual times and not for the
sumtype. You could have a match! that pulls out each member and
calls its individual .bdTime(), but probably a more natural
solution is to define bdTime only once, against the sumtype,
where it has an internal `match!` that pulls out the different
properties of the members that are necessary for each to
construct a BDTime.
