Type-conversion operators generated from single-argument constructors

[naine]

In C++, if a type declares a single-argument constructor without specifying the explicit keyword, the compiler may use that constructor for implicit type conversions and copy-initialization.

I'd like to propose similar functionality to be added to C#, except unlike C++ it should be opt-in, not opt-out. It could be implemented by having the compiler automatically generate type-conversion operators.

For example:

struct Foo
{
    public implicit Foo(Bar bar)
    {
       // ...
    }

    // The compiler automatically adds:
    // public static implicit operator Foo(Bar bar) => new Foo(bar);
}

For symmetry, we might also consider allowing explicit:

struct Foo
{
    public explicit Foo(Bar bar)
    {
       // ...
    }

    // The compiler automatically adds:
    // public static explicit operator Foo(Bar bar) => new Foo(bar);
}

The presence of the implicit/explicit keyword on the constructor should not affect the constructor itself in any way. It is still callable directly as normal per its declared accessibility. The implicit/explicit keyword only prompts the compiler to auto-generate the type-conversion operator in addition. The compiler should raise an error if the keyword is applied to a constructor that does not have exactly one parameter. The compiler should also raise an error if a conflicting operator is declared explicitly.

[HaloFour]

Could do that with a source generator:

partial struct Foo
{
    [Implicit]
    public Foo(Bar bar)
    {
       // ...
    }
}

// generated
partial struct Foo
{
    public static implicit operator Foo(Bar bar) => new Foo(bar);
}

[svick]

I don't think conversion operators that are exactly the same as a constructor are that common. And, as you have shown, the syntax to declare them is one clear and fairly short line of code.

Also, if this is a common pattern in your code, you could write a source generator to do this.

So I personally don't see the value in adding this feature.

[jaredpar]

Agree. This feature is saving very little in terms of code written. Even without a source generator you could just write out the conversion operator with a single line here. Also generally not keen on making it easier to have implicit conversions in the code.

[huoyaoyuan]

Moreover, conversion operators themselves are often abuse.