A better way to deal with overloading?

[Profile Anaysis via Digitalmars-d]

Many times we pass compound types(non-primitives) as arguments to 
functions.

e.g.,

     void foo(T1 t1, T2 t2, T3, t3);

But to call foo with new variables we have to create the 
arguments. This usually requires extra code to simply initialize 
the variables. (imagine foo being a constructor).

It may be better to use a recursive process where we can specify 
all the values of the arguments inline.

e.g.,

     foo(|a,b,c|,|e|,|f,g,c|).

(I am using | but any type of symbolic notation could be used)

would be equivalent to

foo(T1(a,b,c),T2(e),T3(f,g,c)).

When the T's are structs(other wise maybe new, or we can imply 
new for classes to make it uniform).


If T1 has a compound type for the 3rd parameter, we can then call 
it like

     foo(|a,b,|c1,c2,3||,|e|,|f,g,c|).

this avoids having to do things like

auto t1 = T1(a,b,new X(c1,c2,c3));
auto t2 = T2(e);
auto t3 = T3(f,g,c);

and then f(t1,t2,t3);

or other wise simply inline the above.


This also cuts down on constructor overloading.

This is sort of liked named parameters but the idea is that the 
compiler simply constructs the type internally as it knows what 
type to expect and the grouping symbols allow one to specify the 
contents unambiguously.