implicit construction operator

[WebFreak001]

hi, I had an idea from using some C# which I think would be 
really cool in D. Basically allow modifying implicit construction 
of a type. Right now we only have struct opAssign/constructor 
implicit conversion, but this addition would also add it to 
classes and make it even more convenient.

Changes in code (example Nullable):

---
struct Nullable(T) {
     this(typeof(null)) @implicit {} // <-- @implicit is new
}

void foo(Nullable!int a, Nullable!int b) {}
---

Now before you would have only been able to do this:

---
Nullable!Foo a;
foo(a, Nullable!int(5));
---

but now you should also be able to do:

---
Nullable!Foo x = null;
Nullable!Foo y = 5;

foo(null, 5);

// while this would be nice, I am not sure how well this is 
possible right now:
Nullable!int[] foo = [1, 2, 3, null, 5];
---
The array syntax might not be possible if it looks at consistency 
inside the array before attempting to cast it, but for function 
arguments and quicker

This is especially making this case less of a pain to deal with:
---
void sendMessage(string content, Nullable!Snowflake nonce = 
Nullable!Snowflake.init, Nullable!Embed embed = 
Nullable!Embed.init);
Nullable!Embed embed = Embed.init;
sendMessage("a", Nullable!Snowflake.init, embed)

// ->

void sendMessage(string content, Nullable!Snowflake nonce = null, 
Nullable!Embed embed = null);
sendMessage("a", null, Embed.init);
---

Now this would be really useful for Variant:

---
struct Variant {
     this(U)(U value) @implicit { ... }
}

void bar(Variant x, Variant y) {}

Variant[] myObjects = [1, 2, "abc", new Node()];
Variant a = 4;
bar(4, "asdf");
---

Just a few examples where it could be used in phobos, especially 
when passing them function arguments: Variant, JSONValue, 
eventual XML node, Nullable, BigInt, Unique, scoped, NullableRef, 
Rebindable, AsciiString, Latin1String, etc and many more. Plus 
also many libraries will be able to make use of this like vibe.d 
Json, Bson or msgpack or dyaml etc etc etc. Additionally this 
will make many duplicate functions which are just there for 
emulating this behaviour disappear, std.regex could accept just 
regex as argument and strings will be implicitly cast to it, 
reducing template/overload usage and possibly also making it 
faster to import.

What's your opinion on this? I think it is really useful to have 
when interoping with scripting languages or doing 
(de)serialization or for these attribute wrappers which are there 
because of no function attribute UDAs. I was looking into 
implementing this to dmd myself but the code on the implicit cast 
checks looks a bit hardcoded for the types that are in right now 
and not really suitable to implement this, but maybe someone with 
more knowledge about dmd internals can do this with ease.

This is only a single direction T -> Wrapper and I think this 
would actually be enough, but it would maybe be possible to add 
@implicit to opCast in the future.