Interfaces and Template Specializations

[dsimcha]

== Quote from Björn_T._Herzig (raichoo at googlemail.com)'s article
> Hi,
> I've been trying out D lately and stumbled upon the following problem.
> I have 2 interfaces:
> interface Plugable
> {
> 	public void plug();
> }
> interface Printable
> {
> 	public void print();
> }
> and two classes that implement those named Test which implements Plugable and
Printable, and Test2 which only implements Plugable.
> I now want to create a generic function with two specializations.
> void tester(U)(U u) if (is(U : Plugable) && is(U : Printable))
> {
> 	writefln("U : Printable, Plugable");
> 	u.plug();
> 	u.print();
> }
> void tester(U : Printable)(U u)
> {
> 	writefln("U : printable");
> 	u.print();
> }
> First of all this doesn't compile with the dmd 2.014 compiler since it doesn't
accept the if statement after the template declaration (Or did I do something
wrong?).

http://digitalmars.com/d/2.0/changelog.html#new2_015

This syntax is called constraints.  It didn't exist before 2.015.  The info on
some pages is outdated.  The latest DMD version is 2.023.

> Another thing is that it's really weird syntax. In the second
> specialization it's enough to write U : Plugable but it's not
> possible to write something like void tester(U : Printable, Plugable)(U u) since
Plugable would be handled as a second template parameter (or am I mistaken?).
Wouldn't it be much nicer if you could write something like this : void tester(U :
(Plugable, Printable))(U u) and void tester(U : (Plugable))(U u)? This way it
would be possible to use a unified syntax for both cases without the need for a
special case with the if-statement.

The weird syntax is because the first case is a constraint and the second is a
template specialization.  For consistency, it might be better to just use
constraints for everything.

Overall, though, D2's compile-time reflection system grew very organically and has
a lot of duplicated features.  There's been some discussion in the past about how
to reduce this complexity by removing redundancy.  You may have stumbled on one
here:  Constraints, as far as I can tell, are just a more general case of template
specialization.  Maybe we don't need template specialization anymore.