template functions, a special case of constant folding?

[Hasan Aljudy]

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 );

the compiler shall do the computation at compile time and convert it to:
# x = 13;
is there a particular reason for not doing that?

What I'm trying to say is, why do we need templates to do compile-time 
computation of square roots? (as shown on 
http://www.digitalmars.com/d/templates-revisited.html)

Why not, instead of calling the templated sqrt
#    x = sqrt!(2);
you just call the regular sqrt
#    x = sqrt(2);
and the compiler, if smart enough, should do the computation at compile 
time?

If it's too hard to make the compiler smart enough, then maybe we can 
add a keyword to hint to the compiler that if all arguments to this 
function are constants then it can be "folded"!
After all, that's essentially what the "template" keyword is doing! 
(kinda, not really though, I know).

# fold int add( int x, int y ) { return x + y; }
vs.
# template add( int x, int y ) { const add = x + y; }

The "fold" version of the function can be reused for non-constant 
arguments. Where as the templated version can't. (although I'm not 
entirely sure about that).