For any struct type with implicit operator cast from a primitive type, allow it's optional-method-parameter to be set to a compiler-constant of the primitive type.

[Aniobodo]

For example, System.Index has an implicit operator with System.Int32:
public static implicit operator Index(int value) => FromStart(value);

Now, take a look at the following MyMethodA():

public void MyMethodA(System.Index index = 1){ //do something
}

A Compiler Error CS1750 is thrown for the babove method saying: A value of type cannot be used as a default parameter because there are no standard conversions to type.

Now rewriting the above method for System.Decimal, no error is shown:

public void MyMethodB(System.Decimal decimal = 1){ //do something
}

Therefore, the proposal here is that the implicit operator above could serve as the standard conversion.

The implementation detail is simply analog to System.Decimal.

The difference between this proposal and other simililar proposals on GitHub is that in this case, it's simply about assigning the optional-method-parameter to a compiler-comstant.

[KennethHoff]

I remember seeing a proposal recently for allowing more things as constants; allowing all readonly structs to be const, to be precise.

Given that, you could theoretically at least do something like this;

const Index ConstantIndex = 1;

public void Method(Index index = ConstantIndex) {}

[colejohnson66]

The implementation detail is simply analog to System.Decimal.

Not any apt comparison; decimal constants are already allowed:

public const decimal MyDecimal = 1.234m;

As for this proposal, I'd much rather see the "const anything" proposal make headway. Also, what you desire is already possible with overloading:

public void DoSomething(int index = 1) =>
    DoSomething((Index)index);

public void DoSomething(Index index)
{
    // ...
}

This allows someone to leave the argument off, or to pass in an explicit int or Index. The runtime will easily inline that extra function call on the DoSomething(int = 1) method.

[Aniobodo]

@colejohnson66
The essence of optional method parameter is to avoid code duplication. That’s why the method overloads you pointed out does not rule out the need for this proposal.
There is also another concern of expressiveness.
So for int index = 1: what is „index“? Does the int type give you insight into what that number represents? Oh index is clear here, now lets take another example: int abc = 1. Now what does abc represent here?

[Aniobodo]

@colejohnson66
Further about expressiveness, sometimes you want the idea of OPTIONAL (regarding the method parameter) to be the EXCEPTION , not the RULE. So for this parameter, a particular value, hinted in the method arguments, should be applied most of the time. Having multiple overloads with different types doesn’t make it clear.

[colejohnson66]

I agree. But the fact remains that a solution already exists (method overloading), and a much more demanded proposal (const on user types) would solve this issue. For your case, allowing const on user types would turn void X(Index i = 1) into void X(Index i = (Index)1). Remember, all ideas, including this one, start at -100 points.

[Aniobodo]

This is a further example I stumbled upon today. So, you can actually do a switch for ReadOnlySpan (a non-compiler constant) over constant strings. Very good one!
The only thing missing is just to be able to do something similar as optional-method-parameter: Method(ReadOnlySpan number = "00")

 bool MyMethodC()
 {
     ReadOnlySpan<char> number = "00";

     return number switch
     {
         "10" => true,
         "11" => true,
         "12" => true,
         _ => false,
     };
 }

[colejohnson66]

You can switch on anything that can compare with a constant. In other words, if you can do if (<variable> is <constant>), you can use a switch expression.

[Aniobodo]

I stumbled upon a workaround with attribute DefaultParameterValue, see below.
Using Visual Studio, the default value of the optional parameter is even visible both within and outside the assembly ... very good!

using System.Runtime.InteropServices;
 public class C
 {
     public C()
     {
         MyMethodA();//Test without Parameter
         MyMethodA(2);//Test with parameter
     }
     public void MyMethodA([Optional, DefaultParameterValue(1)] System.Index index) { /*do something*/}
 }