I believe the issue that this is trying to solve is that some functions that operate on an object return a new object, and we would like to use them to modify an object. Setting aside the fact that a new object is not the same as a modified object and other references to that object won't change, what this means is that we want to have a shorthand way to write:

Note that the := operator solves a similar problem:

where we can rewrite

blah blah (some subexpression) blah blah (some subexpression) blah (some subexpression) blah 

as

blah blah (X := (some subexpression)) blah blah X blah  X blah

That won't help us here because the two <some references to an object> are respectively an lvalue and an rvalue.

Given that, I'll throw out a straw proposal. Since an lvalue can be converted to an rvalue but not vice versa, suppose we rewrite this as:

(some reference) := X = <some expression using X>

example:

But looking at that, it really isn't much better unless the left hand side is a very complicated expression. If we really needed a feature like this it would be better to use a special symbol like:

Even then, how frequent is this pattern that it would be worth doing?

I think the answer to that question is going to be necessary to convince anyone that the problem is worth solving.

--- Bruce