varargs when they're not all the same type?

[Basile B.]

On Thursday, 14 March 2024 at 20:58:21 UTC, Andy Valencia wrote:
> On Thursday, 14 March 2024 at 18:05:59 UTC, H. S. Teoh wrote:
>> ...
>> The best way to do multi-type varags in D is to use templates:
>>
>> 	import std;
>> 	void myFunc(Args...)(Args args) {
>
> Thank you.  The first parenthetical list is of types, is it 
> not?  I can't find anywhere which says what "type" is inferred 
> for "Args..."?  (gdb pretends like "arg" is not a known 
> symbol.)  Is it basically a tuple of the suitable type?
>
> Andy

Most of the time the variadic template parameters are infered 
from the run time parameters. In that case indeed `Args` will be 
a type tuple of `args` types.

```d
void myFunc(Args...)(Args args) {}
myFunc(0,0.1); // is like the more verbose 
`myFunc!(int,double)(0,0.1)`
```

However explicit instantiation can take whatever is known at 
compile time, such as constant expressions or even certain static 
variables. So that is rather called an `alias sequence` in D.

That being said and with the signature of `myFunc` that will 
effectively only work if `Args` is made of types.

About debugging, each individual runtime arg can be inspected 
using a bit of knowledge of D internals.

![](https://i.imgur.com/XW74nke.png)

As you can see the elements are named following this pattern 
`__param_[0-9]+`.
So with gdb used as CLI, `$ p __param_0` will (🤞🤞) print the 
first variadic element, and so on.