Hello,
I'd like to open up discussion regarding allowing foreach loops
which iterate over a tuple of types to exist outside of function
bodies. I think this would allow for templating constants and
unittests easier. Take, for instance, this hypothetical example:
----------------------------------------------------------------------
T foo(T)(ref T thing)
{
thing++; return thing * 2;
}
foreach(Type; TupleType!(int, long, uint))
{
unittest
{
Type tmp = 5;
assert(foo(tmp) == 12);
}
unittest
{
Type tmp = 0;
foo(tmp);
assert(tmp == 1);
}
}
----------------------------------------------------------------------
Without the ability to wrap all of the unittests in a template,
one would have to wrap the bodies of each unittest in an
individual foreach loop. This is not only repetitive and tedious,
but error prone, as changing the types tested then requires the
programmer to change *every* instance of the foreach(Type;
TupleType).
A similar pattern already exists in Phobos, for testing all
variants of strings (string, dstring, and wstring) and char
types, as eco brought to my attention. After taking a look at
some of the unittests that employ this pattern, I'm certain that
code clarity and unittest quality could be improved by simply
wrapping all of the individual unittests themselves in a foreach
as described above.
Now, I'm certainly no D expert, but I can't think of any
breakages this change might impose on the language itself. So,
I'd like to hear what the benevolent overlords and community
think of the idea.
