[#5218] Ruby Book Eng tl, ch1 question — Jon Babcock <jon@...>

13 messages 2000/10/02

[#5404] Object.foo, setters and so on — "Hal E. Fulton" <hal9000@...>

OK, here is what I think I know.

14 messages 2000/10/11

[#5425] Ruby Book Eng. tl, 9.8.11 -- seishitsu ? — Jon Babcock <jon@...>

18 messages 2000/10/11
[#5427] RE: Ruby Book Eng. tl, 9.8.11 -- seishitsu ? — OZAWA -Crouton- Sakuro <crouton@...> 2000/10/11

At Thu, 12 Oct 2000 03:49:46 +0900,

[#5429] Re: Ruby Book Eng. tl, 9.8.11 -- seishitsu ? — Jon Babcock <jon@...> 2000/10/11

Thanks for the input.

[#5432] Re: Ruby Book Eng. tl, 9.8.11 -- seishitsu ? — Yasushi Shoji <yashi@...> 2000/10/11

At Thu, 12 Oct 2000 04:53:41 +0900,

[#5516] Re: Some newbye question — ts <decoux@...>

>>>>> "D" == Davide Marchignoli <marchign@di.unipi.it> writes:

80 messages 2000/10/13
[#5531] Re: Some newbye question — matz@... (Yukihiro Matsumoto) 2000/10/14

Hi,

[#5544] Re: Some newbye question — Davide Marchignoli <marchign@...> 2000/10/15

On Sat, 14 Oct 2000, Yukihiro Matsumoto wrote:

[#5576] Re: local variables (nested, in-block, parameters, etc.) — Dave Thomas <Dave@...> 2000/10/16

matz@zetabits.com (Yukihiro Matsumoto) writes:

[#5617] Re: local variables (nested, in-block, parameters, etc.) — "Brian F. Feldman" <green@...> 2000/10/16

Dave Thomas <Dave@thomases.com> wrote:

[#5705] Dynamic languages, SWOT ? — Hugh Sasse Staff Elec Eng <hgs@...>

There has been discussion on this list/group from time to time about

16 messages 2000/10/20
[#5712] Re: Dynamic languages, SWOT ? — Charles Hixson <charleshixsn@...> 2000/10/20

Hugh Sasse Staff Elec Eng wrote:

[#5882] [RFC] Towards a new synchronisation primitive — hipster <hipster@...4all.nl>

Hello fellow rubyists,

21 messages 2000/10/26

[ruby-talk:5961] Re: Problem with ++?

From: Dave Thomas <Dave@...>
Date: 2000-10-31 04:01:19 UTC
List: ruby-talk #5961
shreeve@s2s.org (Steve Shreeve) writes:

> Am I doing something wrong? If "counter += 1" works, shouldn't "counter++"?

Ruby doesn't have a ++ operator.

The reason is interesting (I think). Most Ruby operators are
interpreted as messages, sent to a receiver.

  counter = counter + 1

sends the message '+' to the object referenced by the variable
'counter', passing it the argument '1'. Thi object then returns
something appropriate (the next integer is counter is a Fixnum), and
the resulting (new) object is assigned to counter.

  counter += 1

is effectively shorthand for this process.

However, counter++ is different. This would be telling counter to
increment itself. But variables don't understand messages, objects
do.

    __________            __ Fixnum __
   | counter  | -------->|  1234      |
   |__________|          |____________|

    counter++

Now, what should happen here? There's no assignment, so counter will
still reference the same object afterwards. So for it to work, you'd
have to change the value of '1234'. This would be unfortunate, as
Ruby's semantics act as if there's only one '1234' object in the
system, shared among all variables that hold that value.
Languages such as C++ and Java don't have this problem, as basic types 
such as Fixnum are not objects.

Regards


Dave


Footnotes: 
ケ  The implementation is actually different, but that's another story.


In This Thread