template functions, a special case of constant folding?

[Jari-Matti Mäkelä]

Hasan Aljudy wrote:
> Derek Parnell wrote:
>> On Thu, 23 Mar 2006 16:34:07 -0700, Hasan Aljudy wrote:
>>
>>
>>> Given the following expression:
>>> #x = 10 * 5 + y;
>>> the compiler will compute 10 * 5 at compile-time and convert the
>>> expression into
>>> #x = 50 + y;
>>>
>>> I think that's called constant-folding, am I right?
>>>
>>> Why can't this be extended such that for the following function:
>>> # int add( int x, int y ) { return x + y; }
>>>
>>> if it's called with constant arguments:
>>> # x = add( 10, 3 );
>>>
>>
>>
>> You can almost do this with mixins, except that mixins only allow one to
>> mixin a complete statement and not just an expression. What would be
>> useful
>> is to allow mixins (or some other similar thing) to generate
>> expressions at
>> compile time and not just statements. Something like ...
>>
>>  
>>  template add(b,c)
>>  {
>>     b + c;
>>  }
>>
>>  int main()
>>  {
>>    int q;
>>    q = mixin add!(10,3);
>>    return q;
>>  }
>>
>> Which would generate
>>  int main()
>>  {
>>    int q;
>>    q = 10 + 3;
>>    return q;
>>  }
>>
>> Which the compiler would constant-fold as normal.
>>
>> But this is starting to look too much like text macros which Walter is
>> very
>> concerned not to have.
>>
> 
> but you're still using templates. which completely defies my point!

Doing this kind of compiler optimization is very expensive (adds
compiling time & optimizer complexity and thus more bugs). If you
already know that the function should be folded / inlined when you're
writing the code, it's a natural way to explicitly say this with
templates. I think the compiler already does some tricks when -inline is
used. I think new M$ compilers convert stuff like this:

 int a = 5, b = 2;
 for (int i=0; i<3; i++) a *= b;
 int get(int c) { return c+2; }
 a = b = get(a);

into:

 int a = 42, b = 42;

but IMHO it's a sign of a bad coder not to optimize code on the higher
levels. It's extremely simple to "hint" to compiler by using templates
and lift the burden of implementation to the metaprogramming engine.

-- 
Jari-Matti