This enhancement request is just an idea. Maybe better ideas can be found. Given the definition of an Algebraic like this: import std.variant; struct Foo {} void main() { alias T = Algebraic!(int, Foo); } I think it can be a good idea to generate automatically inside T an enum and a method like this: enum Type { int_, Foo; } @property Type theType() const { return ...; } (Built-in types are keywords so they get a leading underscore.) So an Algebraic can be used in a final switch: import std.variant; struct Foo {} void main() { alias T = Algebraic!(int, Foo); auto t = T(5); final switch (t.theType) { case T.Type.int_: auto p = t.peek!int; break; case T.Type.Foo: auto p = t.peek!Foo; break; } } (Currently T.type is a TypeInfo, that can't be used in a final switch.) This allows a poor man's safe pattern matching on an Algebraic. An implementation of Issue 596 will allow to use a bit better pattern matching on an Algebraic.
This is related to Issue 10127 Personally I like that syntax where you use the actual type name rather than putting an underscore in front - it means you can easily use any type, not just ones that can be named. Algebraic could then have an alias to a particular instantiation of that TypeEnum template inside it rather than generating its own.
I've been using this solution, perhaps it should be included in std.variant, though possibly with a better name: ---- import std.variant; import std.traits : isInstanceOf; /** * Calls the correct overload of Fun based on the runtime value of the Variant value. */ auto applyToAlgebraic(alias Fun, Value)(Value value) if (isInstanceOf!(VariantN, Value)) // Can we constrain to Algebraic only? { foreach (T; Value.AllowedTypes) // unrolled at CT if (typeid(T) is value.type) return Fun(value.get!T); assert(0); } ----
Oops, that should use `value.peek!T`, not `value.get!T`
THIS ISSUE HAS BEEN MOVED TO GITHUB https://github.com/dlang/phobos/issues/9608 DO NOT COMMENT HERE ANYMORE, NOBODY WILL SEE IT, THIS ISSUE HAS BEEN MOVED TO GITHUB