Few questions about staticMap

[Simen Kjærås]

On Tuesday, 26 February 2019 at 18:50:39 UTC, Mitacha wrote:
> 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