T... args!

[Petar]

On Thursday, 9 December 2021 at 00:36:29 UTC, Salih Dincer wrote:
> On Wednesday, 8 December 2021 at 23:47:07 UTC, Adam Ruppe wrote:
>> On Wednesday, 8 December 2021 at 23:43:48 UTC, Salih Dincer 
>> wrote:
>>
>> I think you meant to say
>>
>> void foo(string[] args...) {}
>
> Not exactly...
>
> ```d
> alias str = immutable(char)[];
>
> void foo(str...)(str args) {
>   foreach(ref a; args) {
>     a.writeln('\t', typeof(a).stringof);
>   }
>   str s; // "Amazing! ---v";
>   s.writeln(": ", typeof(s).stringof);
> }
> ```

Unlike [value template parameters][0] (which constitute of 
existing type + identifier), all other template parameter forms 
introduce a brand new identifier in the template scope that is 
completely unrelated to whatever other types you may have outside 
in your program (including the ones implicitly imported from 
`object.d` like `string`).

The `str...` in your `foo` function introduces a [template 
sequence parameter][1] which shadows the `str` `alias` you have 
above. The `str s;` line declares a variable of the `str` type 
sequence, so it's essentially a tuple (*). See:

See:

```d
import std.stdio : writeln;

alias str = immutable(char)[];

void foo(str...)(str args) {
   foreach(ref a; args) {
     a.writeln('\t', typeof(a).stringof);
   }
   str s; // "Amazing! ---v";
   s.writeln(": ", typeof(s).stringof);
}

void main()
{
     foo(1, true, 3.5);
}
```

```
1	int
true	bool
3.5	double
0falsenan: (int, bool, double)
```

(*) Technically, you can attempt to explicitly instantiate `foo` 
with non type template arguments, but it will fail to compile, 
since:
* The `args` function parameter demands `str` to be a type (or 
type sequence)
* The `s` function local variable demands `str` to be a type (or 
type sequence)

If you can either remove `args` and `s` or filter the sequence to 
keep only the types:

```d
import std.meta : Filter;
enum bool isType(alias x) = is(x);
alias TypesOnly(args...) = Filter!(isType, args);

void foo(str...)(TypesOnly!str args)
{
     static foreach(s; str)
         pragma (msg, s);
}

void main()
{
     static immutable int a = 42;
     foo!(int, double, string)(3, 4.5, "asd");
     pragma (msg, `----`);
     foo!(a, "asd", bool, foo, int[])(true, []);
}
```

```
int
double
string
----
42
asd
bool
foo(str...)(TypesOnly!str args)
int[]
```

[0]: https://dlang.org/spec/template.html#template_value_parameter
[1]: https://dlang.org/spec/template.html#variadic-templates