On Thursday, 2 June 2016 at 16:21:03 UTC, ag0aep6g wrote:
On 06/02/2016 05:16 PM, Alex wrote:
I may be getting what you're up to. Maybe not.
So we start with something like this (using arrays instead of
arbitrary ranges to keep things simple):
import std.stdio: writeln;
void main()
{
f([]);
f([1]);
f([1, 2]);
}
void f(int[] a)
{
if (a.length == 0) f_none(a);
else if (a.length == 1) f_one(a);
else f_many(a);
}
void f_none(int[] a)
{
writeln("nothing to see here");
}
void f_one(int[] a)
{
assert(a.length == 1);
writeln("exactly one: ", a[0]);
}
void f_many(int[] a)
{
assert(a.length >= 2);
writeln("at least two: ", a[0 .. 2]);
}
And instead you'd like something more like this:
import std.stdio: writeln;
import std.variant: Algebraic;
void main()
{
f([]);
f([1]);
f([1, 2]);
}
void f(int[] arr)
{
A a = arrayToA(arr);
foreach (T; A.AllowedTypes)
{
if (T* p = a.peek!T) f_impl(*p);
}
}
void f_impl(Empty e) { writeln("nothing to see here"); }
void f_impl(int a) { writeln("exactly one: ", a); }
void f_impl(Many!int a) { writeln("at least two: ", a[0 ..
2]); }
struct Empty {}
struct Many(T)
{
T[] arr;
alias arr this;
/* Somehow it's enforced here that arr.length >= 2. */
}
alias A = Algebraic!(Empty, int, Many!int);
A arrayToA(int[] a)
{
A result;
switch (a.length)
{
case 0: result = Empty.init; break;
case 1: result = a[0]; break;
default: result = Many!int(a);
}
return result;
}
And the advantages of it are:
* Don't need asserts in the different `f_impl`s.
Yes.
* The branching in f is guided by the parameter types of f_impl
(could possibly be extracted, instead of being hardcoded
manually).
Yes! :)
Tell me if I'm way off.
You totally hit the point!
The cool thing about the Algebraic is as I expected, that it
doesn't change it's type... And the hard thing is, that I'm not
used to its Empty, Many, ... things yet.
But the question remains how to keep this @nogc? I wonder at the
line with peek... and why it is not just returning the value...
