implicit construction operator

[Meta]

On Monday, 26 February 2018 at 19:25:06 UTC, WebFreak001 wrote:
> 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");
> ---

This is possible in the language today using the implicit class 
construction feature of runtime variadic arrays:

class VArray
{
     Variant[] va;

     this(T...)(T ts) { foreach(t; ts) { va ~= Variant(t); } }
}

void test(VArray ta...)
{
     foreach (v; ta.va)
     {
         writeln(v.type);
     }
}

void main()
{
     test(1, "asdf", false);
}



> What's your opinion on this?

This is a very slippery slope to fall down. Even `alias this` is 
pushing the limit of what I think we should allow.

That said, there is exactly 1 case where I really, really want 
some kind of implicit conversion:

struct Success {}
struct Error { string msg; }

alias Result = Algebraic!(Success, Error);

Result connectToHost(IPAddress host)
{
     //do some stuff
     if (operationSucceeded)
     {
         return Success();
     }
     else
     {
         return Error(statusMessage);
     }
}

This currently doesn't work, and you instead have to return 
Result(Success()) and
Result(Error(statusMessage)). I would love to have some way of 
implicitly constructing an Algebraic from any of the possible 
underlying types. It would bring us very close (if not all the 
way) to having Algebraic work identically to sum types in other 
languages such as Rust, Swift, Haskell, etc. Having to explicitly 
wrapping the values in an Algebraic doesn't seem like a big deal, 
but it makes it really annoying to use it in everyday code.