[GOODIE] Arithmetic assignments (+= and friends)

Richard A. O'Keefe ok at cs.otago.ac.nz
Tue Jun 18 04:30:27 UTC 2002


"Andreas Raab" <Andreas.Raab at gmx.de> wrote:
	> To return to the point, the new += seems more like := than 
	> like #value:.
	
	Whoops? What makes you think that?! It's exactly the opposite - the
	entire intent is to ask the receiver to increase itself, e.g.,
	accurately represented it should be "foo addValue: bar". And the only
	reason the assignment form is required because some of the "more stupid"
	but unfortunately fundamental literals can't do it any other way.
	
	> The new += affects the variable, not (typically) the value. 
	
	Wrong. Exactly wrong. It *always* affects the value and only the value
	if propertly implemented.

Urk.  So if I do
    x := 3.
    x += 1.
it should affect the value (3) and ONLY the value, so after this
x is still 3, and 3 is still unchanged because you can't change numbers?

Now I am really confused.  (And I've used update assignment in a lot of
programming languages, including an APL dialect, since about 1974, and
I've implemented it a couple of times.)

Can we have a clarification, please?
In the form
    <lhs> += <rhs>
What are the allowed forms for <lhs> and <rhs>?
What are the allowed values for <lhs> and <rhs>?
Can the effect be explained by a source to source transformation?
If so, what is that transformation?
Does the same transformation work for <lhs> things that have an
immutable object as value and for <lhs> things that have a mutable
object as value?
Does the <lhs> (or its value, or whatever) have to support #+=?
If not, will a suitable #+= be automatically defined?

	> In fact, there are existing implementations of += that
	> are more like #value: -- just check out implementors-of += 
	> to see 4 interesting implementations. 
	
	Well, yeah, look at the initials of those methods ;-)
	
I'm rather unhappy about a += that isn't *automatically related*
to +.  (Even more so about B2Color4Array that does have #+= but
does not have #+.)

The existing uses have the property that
    x += y
is an ordinary message send that alters the object that is the value
of x, but does not alter x itself.

I really hate inconsistency in a language.  It always ends up tricking
me into making mistakes.  I can like with a few ad hoc += methods
scattered around the system that act like other message sends.  But
special syntax that sometimes does that and sometimes does something
different will have me screaming for a Preference to turn it off.

	See above. In order to make += polymorphic (how often do I have to
	repeat this in this thread - this must the third or fourth time) it is
	required that += is an assignment form.
	
It is already polymorphic.




More information about the Squeak-dev mailing list