Implicit Constructors

[Q. Schroll]

We have some sort of implicit construction already. Weirdly, it's 
reserved for classes. Just look at this:

     class C { this(int x) { } }
     void foo(C c ...) { }
     void main() { foo(0); }

If you put @nogc in front of ctor and functions, the compiler 
tells you not to use 'new' in main while you actually don't. 
Merely the compiler inserts it for you to complain about it.

One could propose to extend the three-dots notation to structs. I 
don't. I'd vote for deprecating the three-dots for classes. Did 
you know it exists? Did you use it - like ever? Does anyone 
depend on it?

(If you don't want to read it all: The examples may be expressing 
enough.)

The main point of this post is a library solution to implicit 
constructor calls. The implementation is very conservative: A 
double handshake; not the constructors must be annotated with 
@implicit, the functions which want to allow being called with a 
constructor parameter must explicitly state that (these functions 
are called "receiving" functions). @implicit constructors must 
have exactly one parameter (no defaulted additional ones) and a 
receiving function has an annotation @implicit(i) where i is the 
index of a parameter for which it will be allowed to plug in a 
constructor argument of its type. Sounds complicated? See an 
example.

     struct S
     {
         import bolpat.implicitCtor : implicit;
         long s;
         @implicit this(int x)  { s = x; }
         @implicit this(long x) { s = x; }
         this(bool x) { s = x ? 0 : -1; }
     }

This is all that you need from the one side. Now the receiver 
side.

     import bolpat.implicitCtor : implicit, implicitOverloads;

     long proto_goo(int v, S s, bool b) @implicit(1)
     {
         import std.stdio : writeln;
         writeln("goo: call S with value ", s.s);
         return b ? v : s.s;
     }
     void proto_goo(char c) { } // no @implicit(i) ==> will be 
ignored

     mixin implicitOverloads!("goo", proto_goo); // generates goo

     assert(goo(1, 2, false) == 2);

It also works for members. See:

     struct Test
     {
         int proto_foo(int v, S s) @implicit(1)
         {
             import std.stdio : writeln;
             writeln("foo: call S with value ", s.s);
             return v;
         }

         void proto_foo(char c) { } // ignored

         mixin implicitOverloads!("foo", proto_foo);
     }

What to do further? Make @implicit take more than one argument. 
I'm working on it. This is just a first taste. And for Stefan 
Koch, thanks to static foreach, one can safe so many templates.

tl;dr the implementation is here:
https://github.com/Bolpat/dUtility/blob/master/bolpat/implicitCtor.d