If I can, I want to back up the conversation a bit. Instead of starting with a solution, what's the problem?
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:
(some reference to an object) = (an expression that operates on <some reference to an object))
Note that the := operator solves a similar problem:
(an expression that references (some subexpression) multiple times)
where we can rewrite
blah blah (some subexpression) blah blah (some subexpression) blah (some subexpression) blah
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>
thing =: T = T.replace(before, after)
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:
thing = <>.replace(before,after)
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.