On Fri, Aug 6, 2010 at 21:59, Rory Mcguire <rjmcgu...@gm_no_ail.com> wrote:
>
> Here is a possible solution to your problem:
>
> -Rory
I believe you can get the type of A. Isn't it typeof(super) or
std.traits.BaseClassesTuple!B[0] ? B in the latter case being typeof(this)
That way, there is no need for the user to provide A, it's automatically
found by the template.
Warning: I did not test this.
And, we know the constructs are of type 'A function(someTypes)' [*], so the
'A function' part is redundant.
Hence, the user only needs to provide for the args types and that makes for
a cleaner call.
* either as a list :
mixin(InheritConstructors!(int, double, string)); // I want to inherit
the constructors taking one type, build me the __ctors for int, double and
string
* or, in the case of multi-parameters constructors, wrap them in a tuple:
mixin(InheritConstructors!(int, double, Tuple!(int, double)); // I want
super(int), super(double) and super(int, double)
That means iterating on the type list, and determining if the current type
is a tuple or not
* if its a 'normal' type, create the corresponding contructor
* if it's a Tuple, crack it open and get the types, using the .Types alias
std.typecons.Tuples have. Creating a constructor from this typetuple is no
different from creating it for one type.
To determine if something is a std.typecons.Tuple, you cannot use an is()
expression: they do not allow multiple types:
enum bool isTuple = is(T == Tuple!U, U...); // no. U... is not allowed. Hmm,
enhancement request?
So, you can either rely on it having a .Types 'member':
template isTuple(T)
{
enum bool isTuple = is(T.Types);
}
Pb: that will flag as tuples any type that exposes a ".Types" alias.
Or use a function accepting a Tuple:
template isTuple(T)
{
enum bool isTuple = is(typeof({
void foo(U...)(Tuple!U t) {}; // this
function accepts only tuples
foo(T.init); // test it
}()));
}
It's ugly as a rat's ass, but it's more solid than the former template.
Philippe
[*] btw, shouldn't that be A delegate(someTypes)???
