'new expressions' and operator overloading

[kofifus]

I use operator overloading a lot with immutable containers. This may not be everybody's cup of tea but I find it very natural and inline with ie strings:

record MyList<T> { 
  ImmutableList<T> Lst { get; init; }
  MyList(ImmutableList<T> v) => Lst = v;

  public MyList() => Lst = ImmutableList<T>.Empty;
  public static MyList<T> operator + (MyList<T> o, T v) => new(o.Lst.Add(v));
}

record Employee(string name, int age);

var l1 = new MyList<Employee>();

l1 += new Employee("John", 30);  // ok

l1 += new("Kate", 20);  // Error CS8310 Operator '+=' cannot be applied to operand 'new(string, int)'

Why do I get this error and is there a point in asking this be changed ?

[svick]

This is explicitly called out as the expected behavior by the specification of target-typed new:

It is a compile-time error if a target_typed_new is used as an operand of a unary or binary operator

I couldn't find the reason why the spec says that, but I think it's because of the difficulty of figuring out which type you're trying to create there.

[alrz]

The rationale can be found here: dotnet/roslyn#42262

In short: equality operators may infer object for operands due to object equality semantics which isn't always desirable (note that primitives follow a different set of rules here). For consistency (and simplicity) it's been rejected and extended to all operators.

[kofifus]

Thanks @alrz, in the roslyn issue you referenced:

I suggest we disable target-typing of new beneath all of the unary and binary operators.

Agreed, I couldn't think of a compelling example where this could be actually useful. To be clear, that will include tuple equality as well. /cc @jcouv

I understand the case for equality but I have shown a case where such use for other operators can be very useful for immutable collections (I have a whole set of collections in https://github.com/kofifus/F/wiki/Collections)

Is there a point/way/place to ask for this limitation to be removed for operators other than equality ?