Why does the with-operator need parenthesis around the expression to access object.

[FreeApophis]

We found very strange behaviour on the with-operator. I'd like to discuss if this is an oversight or if there are some real implications.

When you create an instance of Type T with the Property Initializer, the expression itself is of type T.
However if you create an instance of Type T using a with-expression Initializer, I cannot access the Interface of the Type T.

Here is a full example:

public record ComplexNumber
{
    public double Re { get; init; }
    public double Im { get; init; }
    public double R => Math.Sqrt((Re * Re) + (Im * Im));
    public double Phi => Math.Atan2(Im, Re);
}

var zero= new ComplexNumber { Re = 4 };
var fromInitializer = new ComplexNumber { Im = 3 }.R;
var fromWithExpression = zero with { Im = 3 }.R; // this does not compile!
var working = (zero with { Im = 3 }).R; // With parenthesis, it works as expected.

When analyzing the syntax-tree with Rosly-Quoter, it looks like the Syntax-Tree is very similar, and I think it should be handled similarly.

Could you please point me to the C# language specification which describes this behaviour, I have read the 5 paragraphs about the with-expression, I did not find an explanation.

[HaloFour]

I'm going to suggest that it's possible to ask this question about being required to wrap the "with" expression in parenthesis without being combative.

[FreeApophis]

Ok, could you please point me to the specification which describes this behaviour?

[DavidArno]

Have a look at the Operator precedence on the C# operators and expressions (C# reference) page. The member access expression (x.y) has higher precedence than the with expression. So it's the { Im = 3 }.R that isn't compiling as the compiler sees it as (zero) with ({ Im = 3 }.R).

[Mafii]

Is there any reason the brackets after with bind stronger to the right side than to the with? As that part doesn't have any meaning in itself without the with and the variable before it, it was very confusing to read that the compiler has this precedence. Wouldn't this be something that could be changed without any meaningful implications?

[FreeApophis]

I actually read the precedence list, and obviously you want that the . has a higher precedence in a case like this:

object.Property with { Value = 42 }`

However, I do not see why the Initilizer list couldn't be part of the with-operator, like the intializer list is part of the constructor.

[svick]

This discussion about choosing the precedence of the switch expression may be of interest: dotnet/csharpstandard#300.

Since the with expression has the same precedence as the switch expression, and since they have similar syntaxes, I think the same considerations should apply to both.

[DavidArno]

That's interesting as the docs suggest switch has a higher precedence than with.

[agocke]

@svick is basically right here -- the precedence of switch and with were intended to be the same, just because they look and act so similar. Beyond that, any behaviors for with were inherited from switch. I'm not sure why the docs have them listed differently, I think that was just a mistake during transcription

[svick]

I have opened a PR to fix the docs: dotnet/docs#26789.

[DavidArno]

@svick, you beat me to it, was about to do that myself. I'll put my feet up instead 😃

[FreeApophis]

Thanks, that is very interesting, and I added to the dicussion there.