But += isn’t a method. The reason it works is because it’s NOT a method.
It’s an assignment (ostensibly after an addition method is called). Ruby
can find the proper integer and the variable is bound to the new integer
found.
++ would be a method, not a re-assignment. I suppose one could argue for a
++= operator but that seems silly when +=1 already works.
Drew
···
-----Original Message-----
From: Shannon Fang [mailto:xrfang@hotmail.com]
Sent: Friday, December 06, 2002 4:28 PM
To: ruby-talk@ruby-lang.org
Subject: Re: YA ++ explanationHi,
Any comments? Since everything in ruby is object, += is a
method of the object preceding it, why can’t ++ like that? it
can be defined to avoid the “immutable” property discussed,
anyway. A little more confused… I guee I have asked this question…Shannon
On Sat, 7 Dec 2002 06:08:47 +0900 > “Mills Thomas (app1tam)” app1tam@ups.com wrote:
I’ve worked it out in my mind why ++ isn’t valid. Maybe my
thoughts
will help others. And maybe someone can straighten me out if I’m
wrong!Following is an annotated irb session:
irb(main):001:0> a=“abc”
“abc”
irb(main):002:0> a.id # The “abc” string has a particular ID
22443468
irb(main):003:0> a.succ!# succ!() is only similar to ++ for numbers
“abd” # but is actually a well defined method
irb(main):004:0> a.id # for introducing an effect on the string.
22443468 # Interestingly, we KEEP the same instance
# and only the contents had to change!
irb(main):005:0> a += “efg” “abdefg”
irb(main):006:0> a
“abdefg”
irb(main):007:0> a.id # With the above operation, we had
to get a new
22410024 # instance since we did an assignment.
#
irb(main):008:0> b=123 # Now consider Integers:
123 #
irb(main):009:0> b.id # Now we have a particular Integer object.
247 # Indeed, all 123 integers will have this ID
irb(main):010:0> b++ #
irb(main):011:0* # As you can see, this op is
invalid. To be
irb(main):012:0* # like succ!, it would require keeping the
irb(main):013:0* d # SAME object but altering that
objects CONTENTS
# (said contents being the
immutable number 123).
# Compare the annotations for
a.succ! and b++
# to convince yourself.
Error: … # But Integer values are immutable!
# Otherwise, the number 3 could
become 4 and
# you’d end up with a silly Monty
Python skit.
# [“1, 2, 4” “NO, 3, Sir!” “OH, 3!” BOOM!]
#
irb(main):014:0> b += 5 # Now this operation works because
the language
128 # ‘knows’ how to find the item in the set of
irb(main):015:0> b.id # Integer values that is ‘5’ beyond
‘123’ and
257 # Ruby then returns then assigns
the reference
# of this newly found ‘128’ object to the
# variable. NOTE: assignment of a
new instance
# has happened just as in the String += op.The important part of the explanation is the b++ annotation.
I hope I have it right. And if I do have it right, I hope it’s the
kind of explanation that makes sense to someone else and can
enlighten.Good day.
±-----------------------------------------------+
DREW MILLS | 10101 Linn Station Rd. |
> Suite 800 |
tamills@ups.com | Louisville, KY 40223 |
Technical Specialist | 502-394-7785 |
United Parcel Service | 502-394-7812 |
±-----------------------------------------------+