www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - template alias = parameter

reply =?UTF-8?B?Ikx1w61z?= Marques" <luis luismarques.eu> writes:
Could you please comment on the following behaviors? Are all of 
them intended? Are they internally coherent, with respect to each 
  other?

1)
     void foo(alias f)(int f)
     {
         writeln(f);
     }

     foo(42);

     Error: does not match template

2)
     ...
     foo!(42)(42);

     > 42

3)
     ...
     foo!(7)(42);

     > 42

4)
     void foo(alias f)(int g=f)
     {
         writeln(g);
     }

     foo(42);

     Error: does not match template

5)
     void foo(alias f=42)(int g=f)
     {
         writeln(g);
     }

     foo();

     > 42
Sep 17 2013
next sibling parent "Dicebot" <public dicebot.lv> writes:
On Tuesday, 17 September 2013 at 11:24:10 UTC, Luís Marques wrote:
 Could you please comment on the following behaviors? Are all of 
 them intended? Are they internally coherent, with respect to 
 each
  other?

Looks fine to me.
 1)
     void foo(alias f)(int f)
     {
         writeln(f);
     }

     foo(42);

     Error: does not match template

`alias` is never inferred so error is expected. You did not provide any template parameters to foo. `void foo(T)(T f)` would have worked because `T` can be inferred.
 2)
     ...
     foo!(42)(42);

     > 42

Explicit template parameter + normal parameter. Name of normal parameter shadows alias name (would have expected a warning/error here tbh).
 3)
     ...
     foo!(7)(42);

     > 42

Same as (2).
 4)
     void foo(alias f)(int g=f)
     {
         writeln(g);
     }

     foo(42);

     Error: does not match template

Again, you do not provide template parameter, it can't match. `foo!(42)()` should have worked here.
 5)
     void foo(alias f=42)(int g=f)
     {
         writeln(g);
     }

     foo();

     > 42

Default parameters can be used everywhere so no need to provide any parameter explicitly.
Sep 17 2013
prev sibling next sibling parent =?UTF-8?B?Ikx1w61z?= Marques" <luis luismarques.eu> writes:
Thanks. I think what is weird is that the template parameters are 
allowed to have the same name as the normal parameters, which 
confused my mental model and made me wonder what was even the 
expected behavior.

These examples came from a set of experiments where I was trying 
to do something which I expected would probably not be possible: 
make a template function generate different code 1) without 
varying the function types, 2) without explicitly instantiating 
the template using "!". (this was for compatibility purposes).
Sep 17 2013
prev sibling next sibling parent "Dicebot" <public dicebot.lv> writes:
On Tuesday, 17 September 2013 at 11:43:24 UTC, Luís Marques wrote:
 These examples came from a set of experiments where I was 
 trying to do something which I expected would probably not be 
 possible: make a template function generate different code 1) 
 without varying the function types, 2) without explicitly 
 instantiating the template using "!". (this was for 
 compatibility purposes).

It should not be possible as template instances with same template parameter list share same body in code gen.
Sep 17 2013
prev sibling next sibling parent =?UTF-8?B?Ikx1w61z?= Marques" <luis luismarques.eu> writes:
On Tuesday, 17 September 2013 at 11:46:07 UTC, Dicebot wrote:
 It should not be possible as template instances with same 
 template parameter list share same body in code gen.

Well, my long shot idea was to use an alias template parameter, that way different values would mean different template parameters. But it seems I can't make the alias template parameter implicitly match in any way.
Sep 17 2013
prev sibling next sibling parent "Dicebot" <public dicebot.lv> writes:
On Tuesday, 17 September 2013 at 11:50:56 UTC, Luís Marques wrote:
 On Tuesday, 17 September 2013 at 11:46:07 UTC, Dicebot wrote:
 It should not be possible as template instances with same 
 template parameter list share same body in code gen.

Well, my long shot idea was to use an alias template parameter, that way different values would mean different template parameters. But it seems I can't make the alias template parameter implicitly match in any way.

Any two different alias parameter values mean different template instances. Static introspection demands it: ``` auto foo(alias T)() { static if (is(typeof(T) : int) && (T == 42)) return true; else return false; } ```
Sep 17 2013
prev sibling parent =?UTF-8?B?Ikx1w61z?= Marques" <luis luismarques.eu> writes:
On Tuesday, 17 September 2013 at 12:10:11 UTC, Dicebot wrote:
 Any two different alias parameter values mean different 
 template instances. Static introspection demands it:

 ```
 auto foo(alias T)()
 {
     static if (is(typeof(T) : int) && (T == 42))
         return true;
     else
         return false;
 }
 ```

Yes, that's what I was saying (or trying? thanks anyway). The problem is that I can't get that and implicit instantiation at the same time. I mean, if void foo(T)(T x) makes T=int when called with foo(42), I was hoping that maybe void foo(alias V)(int V) would make V=42. But no. Well, it was a long shot, but it was worth the try.
Sep 17 2013