Nondestructive assignment using = with { }

[dmchurch]

The with operator, being a nondestructive binary operator like + or -, would have improved ergonomics with an assignment variant like += or -=, for exactly the same reasons. Has anyone proposed one? If not, I'd suggest reversing the syntax order in this case (because with= doesn't look great) and making it a three-token operator of =, with, and { that looks like the following:

x = new { Foo = "one", Bar = 2 };
x = with { Bar = 3 }; // x is now { Foo = "one", Bar = 3 }

That syntax aligns it with = new for assigning a new instance, = ref for assigning a reference, and = from for assigning a LINQ query, so it feels pretty C#-like to me.

[colejohnson66]

But why? What's wrong with x = x with { Bar = 3 };? Remember, all proposals start with -100 points. Your proposal makes no mention of why existing syntax is bad.

[dmchurch]

Sorry, I thought that "for exactly the same reasons" was self-evident enough, but sure, I can elaborate on why compound assignment operators are a good idea:

• When you use long, descriptive variable/field/property names (as is the custom for C#), it reduces repetition and line-length in the code, making it easier to understand at a glance
• When obtaining the location of a variable/field/property involves side-effects, it allows update of a value without having to (a) set a temporary variable, or (b) repeat the side-effects
• It's much quicker to type
• It makes it extremely clear what the nature of the operation is. You're not assigning an unrelated value, you're assigning a modified value. Seeing the three tokens = with { in sequence tells you "this is an operation that nondestructively updates the value in this location" - you don't have to worry about parentheses, order of operations, or anything like that. If you see x = x with { - where x is an expression unlikely to be one character long - you first have to read the whole x expression on the left side of the =, then read the whole x expression on the right side, verify that they're the same, verify that they're not causing any unexpected side-effects that might cause the left-side expression to resolve to a different location than the right side, and then you know that it's a nondestructive operation. Consider the following:

  while (!Renderers[currentRenderer].SupportsUseCase()) {
    // No compound assignment
    Renderers[currentRenderer++] = Renderers[currentRenderer++] with { FailedUseCaseTest = true };
    // Compound assignment
    Renderers[currentRenderer++] = with { FailedUseCaseTest = true };
  }
  WorkingRendererIndex = currentRenderer;

  The first example, despite being of exactly the form <expr> = <expr> with { <field> = <value> };, has a severe bug which could go uncaught for a long time and cause all sorts of grief, especially if the Renderers array doesn't have a deterministic order. The compound assignment version avoids that entirely. Pop quiz: are you certain you know which ++ should be removed from the first example to make it function as intended? If so, how much thought did you have to put into figuring that out? How sure are you that other programmers won't grab that footgun by mistake?

There is an additional aspect to this: the C#10 addition of allowing with to be used for structs makes the usage of readonly structs significantly more programmer-friendly. That's a good thing, on account of readonly structs have much better performance than non-readonly structs. One hopes that we'll see a lot more C# code using readonly structs in the future.

That means that the with operator is gonna get a lot more use, though. Statements like this:

// Update weather in region 5
api.World.GetRegion(5).PropState.Weather = "rainy";

now have to get written like this:

// One-liner using existing syntax, with repeated side-effects
api.World.GetRegion(5).PropState = api.World.GetRegion(5).PropState with { Weather = "rainy"; }

// Temp variable, unsuited for expression-bodied methods
var region = api.World.GetRegion(5);
region.PropState = region.PropState with { Weather = "rainy"; }

// Compound assignment, no repeated side effects, no variable declaration
api.World.GetRegion(5).PropState = with { Weather = "rainy"; }

Does this make things clearer? I honestly thought "it's a binary operator, it could use a compound assignment form" was a compelling-enough argument on its own, like it was for ?? and ??=, but I suppose if people don't understand why they might want the with operator in the first place then it's a harder sell.

[iam3yal]

That syntax aligns it with = new for assigning a new instance, = ref for assigning a reference, and = from for assigning a LINQ query, so it feels pretty C#-like to me.

Although with seems more of an infix expression and it doesn't quite fit imo.

It might be useful to have inline aliases so we could do something like api.World.GetRegion(5).PropState as state = state with { Weather = "rainy"; } that translates exactly to api.World.GetRegion(5).PropState = api.World.GetRegion(5).PropState with { Weather = "rainy"; } and might be useful in more contexts but that's just an idea, yours is equally good but the syntax might be a bit weird.

[dmchurch]

Oh, inline aliases/variable declarations would be such a welcome addition to C#, you're not wrong. The more I look into it, though, the more the with expression seems like an incomplete feature - it also seems you can't set indexers in a with expression, even though they are valid in new() { ... } initializers.

The other thing that I'd like for with, though, is augmented mutation. The syntax would be so easy given that the = operator is used, so why not give the option to replace it with += or ??= or even = with { }? You could have:

api.World.GetRegion(5).PropState = with
{
  CurrentWeather = "rainy",
  TotalWeatherEvents += 1,
  Temperature -= 5,
  Precipitation = with {
    Type = PrecipitationType.Rain,
    FirstType ??= PrecipitationType.Rain,
    Amount = new CentimetersOfRainfall(5),
  },
};

And then you can modify an entire immutable structure tree in one statement. The existing one-line equivalent of that statement is:

api.World.GetRegion(5).PropState = api.World.GetRegion(5) with
{
  CurrentWeather = "rainy",
  TotalWeatherEvents = api.World.GetRegion(5).TotalWeatherEvents + 1,
  Temperature = api.World.GetRegion(5).Temperature - 5,
  Precipitation = api.World.GetRegion(5).Precipitation with {
    Type = PrecipitationType.Rain,
    FirstType = api.World.GetRegion(5).Precipitation.FirstType ?? PrecipitationType.Rain,
    Amount = new CentimetersOfRainfall(5),
  },
};

[iam3yal]

@dmchurch Thing with += is that it wouldn't make sense without having -= similarly using ??= without considering ?? especially when you're proposing to make it non-conditional expression but only when with is used, makes little sense to me, that's why I think that inline aliases can be useful here because it might be useful in other contexts and it solves the problem but then it may not worth doing, I dunno. 🤷‍♂️ 😄