Is there a ?= conditional assignment operator in C#?

[ActivistInvestor]

Another language I use, has the operator ?= which basically assigns a value to a property/field if that property/field's current value is != to the value to be assigned. If they are equal, nothing happens.

IOW,

x ?= 10;

Is equivalent to

if(x != 10) x = 10;

I've searched the language spec and see nothing like it, and am just wondering if it exists possibly using a different form.

I deal with properties that trigger significant work on assignment and in some cases, they don't do the check internally before doing all that work.

[333fred]

There is not an operator like that, no.

[colejohnson66]

What's the harm in setting a property/field to the same value? If this has something to do with reactive components, you can implement the != check in your property setter, or use something built-in, like this.RaiseAndSetIfChanged in ReactiveUI.

[CyrusNajmabadi]

What is the advantage of x*=10 over x = x*10 ?

Taking a location and updating it through some mutation is a very common operation. So much so that we have the entire 'compound assignment' space to take binary operators and combine them with assignment into one operator.

This is not the same though. All the others unilaterally assign, and they're combining with an existing operator with the same starting syntax to do the operation. Thats' not the same with ?=. It is not an assignment of some ? operator.

[tannergooding]

but I can’t see any for ?=

the general use case is for multithreaded code. Writes are significantly more expensive than reads and can cause memory and cache contention, so it is typically to avoid writing if the value is already as desired

Such a need is fairly specialized and uncommon however, it is likely also worth explicitly commenting such cases and making it more apparent, so I don’t personally see the benefit in a new language operator

[ActivistInvestor]

Using such an operator to avoid expensive writes allows the compiler to more-easily optimize code, because it doesn't have to infer the intent from a more-complex set of instructions, as such an operator would make the intent of the operation explicit.

The issues with an ?= operator are actually more rooted in how equality comparisons are done, specifically on floating point values. It's not a simple ==, as it involves an epsilon (actually several of them, depending on what the values being compared represent) so it wouldn't work for those kind of cases.

[tannergooding]

There aren’t any compiler optimizations here done by any major compiler for such patterns. There is likewise already no difficulty in inferring intent from trivial patterns and most optimizations compilers do are done on an intermediate representation where high level operations have already been transformed into some new, often simpler/decomposed/lower, representation

Similarly there is not any epsilon considered as part of floating point comparisons. They are by spec effectively bitwise comparisons. The two special considerations that are not bitwise being nan != nan and +0.0 == -0.0

[ActivistInvestor]

Similarly there is not any epsilon considered as part of floating point comparisons. They are by spec effectively bitwise comparisons. The two special considerations that are not bitwise being nan != nan and +0.0 == -0.0

That's precisely what I said above without getting into the details of exactly how floating point comparisons are done. When I said comparisons I meant what is written by programmers using more complex operations like abs(a-b) < epsilon, that obviously would not work with any such proposed operator.

[HaloFour]

I don't like the idea of such an operator for property access. It hides that you are performing both a read and a write operation, and it is inherently not thread safe.

[CyrusNajmabadi]

This proposed operator breaks with syntactic consistency in more ways than you cite. It returns a bool.

That's a strong negative strike against it.

[ActivistInvestor]

I don't think it is, because complex, compound use of operators is a notorious source of bugs, and is discouraged in some development standards. That stems largely from not easily understanding or visualizing operator precedence.

On the other hand, compilers can optimize x ?= y more consistently than a manual conditional assignment, as the intent of the operation is explicit to the compiler.

[CyrusNajmabadi]

and is discouraged in some development standards.

We do not discourage it. Nor does .net.

That stems largely from not easily understanding or visualizing operator precedence.

Compound assignments have been part of the language for 25 years, and have not been a source of problems. Things like += are generally taught almost immediately when someone is learning a language.

On the other hand, compilers can optimize x ?= y more consistently than a manual conditional assignment, as the intent of the operation is explicit to the compiler.

This is not a compound assignment though. Reusing compound assignment syntax is a problem here. Basically, if you're going to be reusing a syntactic pattern, while not following teh semantics of that pattern as we've had it for 25 years, then there has to be an exceptionally good argument for that.

This would need to be a pattern we see people clamoring for (so far, it's just one person) and we'd need to feel strongly that violating expectations around this pattern woudl be worthwhile.

[ActivistInvestor]

Compound assignments have been part of the language for 25 years, and have not been a source of problems. Things like += are generally taught almost immediately when someone is learning a language.

I said compound use of operators, not compound assignments (e.g., where the result of one binary operation is itself an operand).

[CyrusNajmabadi]

Compound assignments Are a compound use of operators. They compound the binary operator with the assignment operator.

[ActivistInvestor]

Compound assignments Are a compound use of operators. They compound the binary operator with the assignment operator.

A single compound assignment operator is not a compound use of operators at the source level, such as x &= y || z. Without a well-rounded understanding of operator precedence, the operation is not terribly obvious, and the programmer often ends up using parens, sometimes without the need for them.

Maybe chaining is a better term, but a compound operator that performs multiple operations internally isn't what I was describing above.

[ActivistInvestor]

This really didn't start out as a proposal but I think there are other better reasons why it is not feasible aside from the fact that it doesn't follow the pattern of other compound assignment operators. I personally don't place that much importance on following a pattern, especially when it serves little other than to impede general developer productivity.

[CyrusNajmabadi]

I personally don't place that much importance on following a pattern

We do. Exceptions is the design are like exceptions in natural languages. They make round harder and more confusing to learn and use the language.

[ActivistInvestor]

Well, I don't agree with strict consistency for its own sake. And I don't believe a lack of consistency in this case would have any impact on anyone's ability to learn the language.

I'd be interested in scanning every line of C# on GitHub to count occurrences where ??= is a right-side operand of another binary operation.

[CyrusNajmabadi]

I'd be interested in scanning every line of C# on GitHub to count occurrences where ??= is a right-side operand of another binary operation.

Go ahead :)

Well, I don't agree with strict consistency for its own sake.

The argument isn't that strict consistency is necessary. The argument is that if you are going to be inconsistent it must come with a very compelling reason. As i said above:

Basically, if you're going to be reusing a syntactic pattern, while not following teh semantics of that pattern as we've had it for 25 years, then there has to be an exceptionally good argument for that.

This would need to be a pattern we see people clamoring for (so far, it's just one person) and we'd need to feel strongly that violating expectations around this pattern woudl be worthwhile.

And I don't believe a lack of consistency in this case would have any impact on anyone's ability to learn the language.

It would definitely do that. Heck, seeing ?= is confusing to me. I have no idea why it is using ? and = in that fashion. Nothing about it conveys that it is actually a non assignment operator. Or that it chooses to not assign in the case where the value is "the same" (for some definition of "sameness").

Finally, there hasn't been any examples provided of why this is a good thing or would be wanted. The OP case is not compelling. Why would i want to avoid this assignment when the values are the same? Where and why does that pattern come up, and why does it need special syntax over the extremely simple and idiomatic patterns already available?

[ActivistInvestor]

It would definitely do that. Heck, seeing ?= is confusing to me.

Of course it is, but not any more confusing than my first encounter with ??= was. If one doesn't know what an operator does, it's going to confuse them because some 2- and most 3-character operators generally don't adequately convey what they do. I'm not proposing ?=. It could be ?!=, which is 3 characters and slightly-more obvious.

To close this out, I don't think this proposal is a good one, but it has nothing to do with the points you're making. It has to do with the fact that it would have very limited usefulness in most floating point scenarios. I spend a great deal of time working with scalar values and there is little-to-no use of their == / != operators.

[ActivistInvestor]

Thankfully, you won't see these sorts of debates in the LISP world.

(defmacro ?= (place value)
  (let ((val-sym (gensym)))
    `(let ((,val-sym ,value))
       (when (/= ,place ,val-sym)
         (setf ,place ,val-sym)))))

(defun test ()
  (let ((x 1))
    (?= x (+ 2 3))))

[CyrusNajmabadi]

Correct. Lisp chooses different design paths.

Note: if you want a .net language that allows you to define operators, you can use f#. It's a very specific design goal of c# that that not be a general facility.

[CyrusNajmabadi]

but not any more confusing than my first encounter with ??= was

I disagree. ??= falls out from the existing patterns in the language. It was of that it didn't immediately exist when we added ?? in the first place given how all the rest of the binary operators work. That was a major reason we did it. People were genuinely confused why it didn't work for ?? given that it worked for *, +, -, <<, /, % etc.