• dennis luehring (7/7) Jan 23 2007 (just an idea)
• Xinok (3/12) Jan 23 2007 Tuples no. Tuples are template based, so if you were to use a different ...
• BCS (21/43) Jan 23 2007 How about somthing like runtime tuples (for lack of a beter name)

dennis luehring <dl.soluz gmx.net> writes:

(just an idea)

if we say that the parameterslist of a function is a 
local-defined-and-typed tuple
(maybe D should handle function parameters with an tuple-like concept)
couldn't we get rid of the (another) variadic function concept and 
replace it with the variadic template stuff...

ciao dennis

Xinok <xnknet gmail.com> writes:

dennis luehring Wrote:

 (just an idea)
 
 if we say that the parameterslist of a function is a 
 local-defined-and-typed tuple
 (maybe D should handle function parameters with an tuple-like concept)
 couldn't we get rid of the (another) variadic function concept and 
 replace it with the variadic template stuff...
 
 ciao dennis

Tuples no. Tuples are template based, so if you were to use a different set of
types for arguments, it would require a new instance of the function. This can
result in some very large EXEs for relatively simple programs. Could you
imagine using a separate instance of writefln for every different set of
arguments you provided?
I would happily welcome a new concept which is more easily managed though.

BCS <ao pathlink.com> writes:

Reply to Xinok,

 dennis luehring Wrote:
 
 (just an idea)
 
 if we say that the parameterslist of a function is a
 local-defined-and-typed tuple
 (maybe D should handle function parameters with an tuple-like
 concept)
 couldn't we get rid of the (another) variadic function concept and
 replace it with the variadic template stuff...
 ciao dennis
 

 Tuples no. Tuples are template based, so if you were to use a
 different set of types for arguments, it would require a new instance
 of the function. This can result in some very large EXEs for
 relatively simple programs. Could you imagine using a separate
 instance of writefln for every different set of arguments you
 provided?
 
 I would happily welcome a new concept which is more easily managed
 though.
 

How about somthing like runtime tuples (for lack of a beter name)

int writef(V... args)
{
	foreach(arg;args)
	{
		switch(typeof(arg))
		{
			case char[]: ... break;
			case int:      ... break;
			case real:     ... break;
			case Object: ... break;
			case struct:  ... break;
			default:        ... break;
		}
	}
}

The switch would act something like a specialized template or an is statement. 
Each args type is compared against the case list using the same rules that 
are used for overloading specialized template. The important thing being 
that it is done at runtime, as is the tuple creation.