As others have pointed out, there are const-correctness bugs.
As for a workaround, have you considered using a simple array instead of a
linked list?
Arrays in D, especially when combined with std.array, make for easy-to-use
(though
perhaps not particularly efficient) stacks:
int[] stack;
stack ~= 3; // Push
stack = stack[0..$-1]; // Pop
stack.popBack(); // Pop with std.array

As others have pointed out, there are const-correctness bugs.
As for a workaround, have you considered using a simple array
instead of a linked list?
Arrays in D, especially when combined with std.array, make for
easy-to-use (though
perhaps not particularly efficient) stacks:
int[] stack;
stack ~= 3; // Push
stack = stack[0..$-1]; // Pop
stack.popBack(); // Pop with std.array

As for a workaround, have you considered using a simple array
instead of a linked list?
Arrays in D, especially when combined with std.array, make for
easy-to-use (though
perhaps not particularly efficient) stacks:
int[] stack;
stack ~= 3; // Push
stack = stack[0..$-1]; // Pop
stack.popBack(); // Pop with std.array

As for a workaround, have you considered using a simple array instead
of a linked list?
Arrays in D, especially when combined with std.array, make for
easy-to-use (though
perhaps not particularly efficient) stacks:
int[] stack;
stack ~= 3; // Push
stack = stack[0..$-1]; // Pop
stack.popBack(); // Pop with std.array

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. :/).

That's different because this time there is no slice involved. The
assignment is done on t itself. Tuple defines opAssign() that
effectively performs the following operations (calling the right-hand
side object 'temp'):
t[0] = temp[0];
t[1] = temp[1];
And that succeeds because int can implicitly be converted to double.
Ali

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?
;)

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 distin=

ct =

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 ~=3D to!(Tuple!(double, char))(tuple(10, '+'));
(An alias would make that easier to read. :/).