static parameters

[Bruno Medeiros]

Bill Baxter wrote:
> Bruno Medeiros 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
>>
>> "this is just another way to do something we can already do" ?
>> Are you sure that is the case? 
> 
> No, I'm not at all sure.  That's why I was asking.
> 

You had a statement, not a question. :P

>> The presentation says:
>>   void foo(static int i, int j) { ... }
>> will become a synonym for the template
>>   void foo(int i)(int j) { ... }
>>
>> However one will also be able to call foo as if it were a function:
>>   foo(3, 2);
>> which is not at all possible currently for the template:
>>   void foo(int i)(int j) { ... }
>> (or will that also change with the upcoming D features?)
> 
> By "do something we can already do" I meant the functionality, not the 
> syntax.  We can already pass compile time integer parameters to 
> functions, we just have to call it like foo!(3)(2) instead of foo(3,2).
> 
> Robert and Reiner both pointed out some (mildly) interesting things it 
> would allow.
> 1) seamlessly overloading on static/vs non-static.

That's the whole point of this functionality, just as described in 
Walter's slides (2 pages bellow where static function parameters are 
introduced). And that's why being able to call something foo(3,2) 
instead of foo!(3)(2) is not just a syntactical sugar.

> 2) allowing to make compile-time constant opIndex (and other operators 
> too I suppose like opAddAssign).
> 

That's assuming operator overloading will work with these functions, 
which we don't know for sure (unless it was mentioned in the conference).

> Neither of those is really knocking my socks off, though.
> 
> --bb


-- 
Bruno Medeiros - MSc in CS/E student
http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D