static parameters

Reiner Pope some at address.com
Fri Aug 31 08:58:08 PDT 2007


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


I know it's far from the only way to do this, but static parameters 
should hopefully also allow static opIndex, allowing us to do nifty 
tuple-like behaviour:

struct Tuple(T...)
{
     T impl;

     T[i] opIndex(static int i)
     {
         return impl[i];
     }

     T[i] opIndexAssign(T[i] val, static int i)
     {
         return (impl[i] = val);
     }
}

void main()
{
     Tuple!(int, bool) t;
     t[1] = false;
     t[0] = 5;
}


   -- Reiner



More information about the Digitalmars-d mailing list