Odd construct idea. Splitting arguments inside a parameter list.

[Chris Katko]

````D
struct pair
{
float x,y;
}

myFunction(float taco, float x, float y, float burrito)
  {
  // stuff
  }

myfunction(_taco, _x, _y, _burrito);  // call function

// But can we do this?
pair p;
myfunction(_taco, p; _burrito);  // p becomes (x,y) and satisfies 
the two floats in the signature
````
I don't know if I need this but I'm curious if it's a template 
possibility. Though under-the-hood it could violate some 
necessary assumption about function signature matching.

I'm curious if you can pass a struct of values (a 'tuple'?) with 
the right subfields, as if those fields occupied a function 
signature. (As I write this and try to explain it, it probably 
sounds impossible.)

I have an existing API that uses X/Y coordinates, but I like 
using packed/named tuples (right term?) for related arguments. 
pos(x,y) vs velocity(x,y) for example make it super easy to tell 
which x belongs to which construct. Worst case I could just write 
wrapper functions for like 60+ functions. But it's still an 
interesting "can D do this" idea that popped into my head 
tonight. I'm always curious about what's possible.

  - Note that it doesn't necessarily have the struct fields match 
the called function argument names. I'm talking about calling 
with a struct with two floats (of any name), fulfilling two float 
requirement of a function signature. Is there a way for a 
tuple/array/some-sort-of-combined object to fulfill two separate 
function arguments?

Of course we could always just do:
````D
pair p;
myFunction(taco, p.x, p.y, burrito);
````