Recursive template expansion

[Norbert Nemec]

Hi there,

trying out a few ideas on expression templates, I stumbled over the 
following problem, for which I cannot find a solution. The code below 
demonstrates what I try to do:

I need to construct a nested template type at compile time. Any 
expression should correspond to an equivalent nested tree of templates 
which can then be unraveled at compile time.

For some reason, the D compiler complains about a "recursive template 
expansion" as soon as I use ((a+b)+c). My guess is that this is supposed 
to protect against infinite recursions at compile time. In this case, 
however, there is actually no risk of that. Nested types are only needed 
at the depth of nested expressions that actually occur.

Is there any fundamental error in my thinking? Some simple 
misunderstanding? Some slightly different syntax to be used? Or is it 
simply an unnessessary restriction in the compiler that could easily be 
removed?

Apart from all that, I want to point out that the error message does not 
even give a line number in the code. If any such error occurs within a 
larger piece of software, identifying the problem would be a nightmare!

Greetings,
Norbert


---------------
import std.stdio;

struct sum(A,B) {
     A a;
     B b;

     auto opAdd(T)(T a) { return .sum!(sum,T)(this,a); }
}


struct base {
     auto opAdd(T)(T a) { return .sum!(base,T)(this,a); }
}

void main() {
     base a,b,c;

     // first a few working examples
     writeln(typeid(a));       // base
     writeln(typeid(a+b));     // sum!(base,base).sum
     writeln(typeid(a+(b+c))); // sum!(base,sum!(base,base)).sum

     sum!(sum!(base,base),base) d;
     writeln(typeid(d));       // sum!(sum!(base,base),base).sum

     // the following produces
     //   Error: recursive template expansion for
     //   template argument sum!(base,base)
     writeln(typeid((a+b)+c)); // sum!(sum!(base,base),base).sum
}

---------------