CommonType and non-built-in types

[Dicebot]

On Tuesday, 1 October 2013 at 10:50:39 UTC, Joseph Rushton 
Wakeling wrote:
> (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;
>     }

a) Ternary operator returns value of type that can be used to 
store values of both condition branches. Don't know exact 
algorithm in compiler do determine this but it is likely based on 
presence of implicit conversion.

b) If it is impossible to use both types in ternary operator, no 
implicit conversions (and thus no common type) are possible. Thus 
it will result in compilation error and typeof() of whole 
expression will be invalid type, making is() return false.

c) If it is a valid expression, its type is CommonType and 
aliased to U. Then template is recursively called to find common 
type between U and rest of template parameter list.

d) In the end who;e CommonType template will be aliased to last 
such U in recursion chain.

> (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:-)

It is not is(T : U) form but ternary operator.

> (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?

It requires int to be implicitly convertible to BigInt. Don't 
know if we have tools to do it.

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

If it is possible to express it, common type of those should be 
BigInt.