Hi everyone,
I checked, just out of curiosity, what is staticMap's
implementation. It's implemented using recursive, this made me
think if there is way to use static foreach instead. I came out
with following solution: https://run.dlang.io/is/qvgJaw
I checked time it took compiler to compile std and my version for
7 parameters and there was no difference. The only difference I
found was number of template instantiations: 1 for my code and 9
for std version.
Are there any benefits to implementing staticMap use recursive
template?

Hi everyone,
I checked, just out of curiosity, what is staticMap's
implementation. It's implemented using recursive, this made me
think if there is way to use static foreach instead. I came out
with following solution: https://run.dlang.io/is/qvgJaw
I checked time it took compiler to compile std and my version
for 7 parameters and there was no difference. The only
difference I found was number of template instantiations: 1 for
my code and 9 for std version.
Are there any benefits to implementing staticMap use recursive
template?

Some testing indicates there's not a whole lot to gain from the
unrolled parts of your sMap, so here's a shorter version:
template sMap(alias F, T...) {
mixin("alias sMap = AliasSeq!(",{
string result;
static foreach (i, _; T) {
result ~= "F!(T["~i.stringof~"]), ";
}
return result;
}(),");");
}
I took the liberty of comparing different implementations and
workloads, and can't really see any big difference between sMap
and staticMap in the cases tested. There is a very small tendency
for sMap to be faster, but the difference from run to run tends
to drown this out, so I'm not sure it's an actual difference. For
completeness, here's the code I've been using to test:
template add1(int n) {
enum add1 = n + 1;
}
struct testStruct(int n) {}
unittest {
enum N = 10000;
alias a = sMap!(add1, generate!N);
alias b = staticMap!(add1, generate!N);
alias c = sMap!(testStruct, generate!N);
alias d = staticMap!(testStruct, generate!N);
}
template generate(int n) {
mixin("alias generate = AliasSeq!("~{
string result;
static foreach (i; 0..n) {
result ~= i.stringof~", ";
}
return result;
}()~");");
}
I did find a different interesting tidbit, though: static foreach
is significantly slower when used to iterate over a N..M range
than over a tuple of the same length. Reported as
https://issues.dlang.org/show_bug.cgi?id=19705
--
Simen