CommonType and non-built-in types

[Joseph Rushton Wakeling]

Hello all,

In the course of examining std.rational I've had to take a look inside 
std.traits.CommonType, and I'm hoping people can help me to understand some fine 
details which I'm currently unsure of.

The essence of the CommonType template is simple:

     * If it is passed no arguments, the common type is void.

     * If it is passed one argument, the common type is the type of that
       argument.

     * If it is passed more than one argument, it looks for the common type U
       between the first 2 arguments.  If it finds it, then it returns the
       common type of U and the remaining arguments (in other words, it
       recursively identifies the common types of successive arguments until
       none are left).

     * If the first 2 arguments can't be implicitly converted, it returns void.

A consequence of this is that CommonType will not necessarily work nicely with 
many non-built-in types.  For example, the common type of BigInt and int is 
void, even though in principle it should be possible to convert an int to a 
BigInt.  It's this that is particularly of concern to me.

Anyway, to concrete questions.

(1) Can someone please explain to me _in detail_ the mechanics of the code which 
identifies whether the first 2 template arguments have a common type?

I understand what it does, but not why/how it does it, if you get me :-)

     static if (is(typeof(true ? T[0].init : T[1].init) U))
     {
         alias CommonType!(U, T[2 .. $]) CommonType;
     }

(2) Same code -- why is it only necessary to check T[0].init : T[1].init and not 
vice versa?  (Yes, you can tell I don't really understand the : operator properly:-)

(3) What would one have to implement in a library-defined type to enable 
T[0].init : T[1].init to evaluate to true?  For example, to enable int and 
BigInt to be compatible?

(4) Is there a good reason why there _shouldn't_ be a CommonType of (say) int 
and BigInt?

I'm sure I'll think up more questions, but this seems enough to be going on with 
... :-)

Thanks & best wishes,

     -- Joe