On Wednesday, 8 September 2021 at 07:10:21 UTC, Chris Piker wrote:
Hi D
I'm working on data streaming reading module where the encoding
of each input array isn't known until runtime. For example
date-time column values may be encoded as:
* An ISO-8601 UTC time string (aka char[])
* A ASCII floating point value with an indicated unit size
and epoch (aka char[])
* A IEEE double with an indicated endianness, unit size, and
epoch. (aka double[])
* A 64-bit signed in with an indicated endianness, unit
size, and epoch. (aka long[])
a std.variant.Variant can contain *any* type, but this only four
types, so I'd look at a std.sumtype of them first:
```d
import std.sumtype;
struct ISO8601 { }
struct FloatEpoch { }
struct DoubleEpoch { }
struct LongEpoch { }
alias Time = SumType!(ISO8601, FloatEpoch, DoubleEpoch,
LongEpoch);
void main() {
import std.stdio : writeln;
import std.format : format;
Time e = ISO8601();
writeln(e.match!(
(FloatEpoch _) => "doesn't happen",
(DoubleEpoch _) => "doesn't happen",
(LongEpoch _) => "an error to omit, unlike the next
example",
(ISO8601 time) => format!"%s"(time),
));
}
```
...
I'm wondering if std.variant is useful in cases where type
information is only known at run-time, since many of the
flexible data structures I've run across so far in D require
compile-time information.
It is. It's used for message passing in std.concurrency for
example, where an actor can receive any kind of type into its
messagebox. If std.sumtype didn't exist then I might look at
std.variant or a novel discriminated union of my own or OOP,
where an option is to try casting to the different subtypes until
the cast works:
```d
class Encoding { }
class ISO8601 : Encoding { }
class FloatEpoch : Encoding { }
class DoubleEpoch : Encoding { }
class LongEpoch : Encoding { }
void main() {
import std.stdio : writeln;
Encoding e = new ISO8601;
if (!cast(FloatEpoch) e) writeln("it's null");
if (!cast(LongEpoch) e) writeln("it's null");
if (auto time = cast(ISO8601) e)
writeln(time);
}
```
