static parameters

[Don Clugston]

Robert Fraser wrote:
> Bill Baxter Wrote:
> 
>> On page 30 of WalterAndrei.pdf it talks about static function parameters.
>>
>> It says
>>     void foo(static int i, int j) { ... }
>> will become a synonym for the template
>>     void foo(int i)(int j) { ... }
>>
>> And the reason given is it's supposed to make templates "easier for 
>> mortals".
>>
>> I don't really see how that makes anything easier.  It's longer to type 
>> first of all.  And you still have to be aware of the compile-time / 
>> runtime distinction, this just makes it a little harder to see.  And it 
>> introduces issues like what to do if there are both template parameters 
>> and static arguments, and what to do with __traits for such functions, 
>> and what the parameters tuple should look like, and whether you can have 
>> foo(int i, static j), and whether you can still call it as foo!(7)(5), 
>> and if you can call foo(int i)(int j) as foo(3,x)?
>>
>> And if it is just like a template can you take &foo?  If not, how do you 
>> take the address of a particular specialization of the function?  Do you 
>> revert back to foo!(3) then?
>>
>> In short it seems like a classic case of a feature that adds little 
>> benefit, but a fair number of new rules that everyone will have to 
>> remember, and in the end it could very likely stomp on the toes of some 
>> other future features that would be much more useful.
>>
>> As far as I can tell, this is just another way to do something we can 
>> already do, and all we gain from it is the ability to save two 
>> characters on the calling side for functions that are only templated on 
>> const values.
>>
>> --bb
> 
> As far as I understand it, it will allow overloading on constants for manual constant folding & optimization. So if you have:
> 
> void foo(static int i);
> void foo(int i);
> 
> foo(3); // Calls the first
> foo(x); // Calls teh second (assuming x is not compile-time resolvable)

Yes, means you can do compile-time regexps with identical syntax to run-time 
regexps. This was my proposal from the distant past, and I think someone else 
suggested it as well. But, with macros, most of the impetus is gone; you could 
get the same effect in another way:

macro foo(i)
{
    static if (__traits(compiletimeconst, i))
          foo_template!(i);
    else foo_function(i);
}

One problem with the proposal, is that you can't currently accept any type as a 
template value parameter (only ints, floats, and strings). So
struct Bar {
  int a;
}

foo(static Bar b);

is not going to work. So it's not clear that it's a big win any more. I don't 
think we need it.