On Sun, 18 Mar 2012 08:34:19 +0100, Tongzhou Li <[email protected]> wrote:

On Sunday, 18 March 2012 at 06:15:16 UTC, Ali Çehreli wrote:
Every template instantiation of a set of template parameters becomes a distinct type than any other set of template parameters.

In other words, Tuple!(double, char) and Tuple!(int, char) are distinct types. For all the compiler knows, Tuple is a user type and only the user should define whether they are compatible. Tuple does not define opCast() to covert from Tuple!(int,char) to Tuple!(double,char). I guess it could have been defined. (?)

A solution is to explicitly perform the conversion:

import std.conv;
// ...
    stack ~= to!(Tuple!(double, char))(tuple(10, '+'));

(An alias would make that easier to read. :/).
It seems long and ugly...
I also write:
     Tuple!(uint, double delegate(double, double))[char] Operators;
     Operators['+'] = tuple(1u, (x, y) => x + y);
It doesn't work. I have to write:
Operators['+'] = tuple(1u, cast(double delegate(double, double))(x, y) => x + y);
Much longer :/

Someone tell me that this is called SFINAE problem in C++
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html
I tried this C++ code:
     stack<pair<double, char> > s;
     s.push(make_pair(10, '+'));
It compiles fine with g++.
Any chance to see this being solved in D?
;)

Try this one for size:


import std.traits : isImplicitlyConvertible, isSomeChar, isAssignable;
import std.conv : to;

void push( T, U )( ref T[] arr, U element ) if (isImplicitlyConvertible!(U, T) ||
            (isSomeChar!T && isSomeChar!U) || isAssignable!(T, U) ) {
    arr ~= to!T( element );
}


Works for me with this code:

Tuple!(double, char)[] arr;
arr.push(tuple(10, 'a'));

Reply via email to