A = b = c order of evaluation weird

ruby-talk
1

i thought if it is

  a = b = c

due to associativity rule, then it is

  a = (b = c)

so (b = c) is evaluated first. and then now it will be a =
(evaluated_value)

now how come when

  a = Array(1..100)

and to cut off the first 1/3 and last 1/3 of the array to get about 33
elements, shouldn't we use

  a[0..a.size/2] = a[a.size*2/3..-1] = nil

as after the last 1/3 is deleted, you got about 66 elements remaining
and we want the other half deleted, to get to 33 elements. However, it
won't work and requires

  a[0..a.size/3] = a[a.size*2/3..-1] = nil

why is that?

···

--
Posted via http://www.ruby-forum.com/.

2

SpringFlowers AutumnMoon wrote:

why is that?

a = Array(1..6)
p a

puts "size: #{a.size/3}"
a[p(0..a.size/3)] = a[p(a.size*2/3..-1)] = nil

···

--
Posted via http://www.ruby-forum.com/\.

3

Hi --

···

On Tue, 2 Oct 2007, SpringFlowers AutumnMoon wrote:

i thought if it is

a = b = c

due to associativity rule, then it is

a = (b = c)

so (b = c) is evaluated first. and then now it will be a =
(evaluated_value)

now how come when

a = Array(1..100)

and to cut off the first 1/3 and last 1/3 of the array to get about 33
elements, shouldn't we use

a[0..a.size/2] = a[a.size*2/3..-1] = nil

as after the last 1/3 is deleted, you got about 66 elements remaining
and we want the other half deleted, to get to 33 elements. However, it
won't work and requires

a[0..a.size/3] = a[a.size*2/3..-1] = nil

why is that?

Although the = associates to the right, the subscript expressions are
evaluated first. So you're really doing:

   a[0..50] = a[66..-1] = nil

David

--
Upcoming training from Ruby Power and Light, LLC:
   * Intro to Ruby on Rails, Edison, NJ, October 23-26
   * Advancing with Rails, Edison, NJ, November 6-9
Both taught by David A. Black.
See http://www.rubypal.com for more info!

4

I'm having a bit of a problem accessing variables in an instance of GServer.
What I would like to do is make a hash that is effectively global to the
current thread.

-/Server.rb
require 'gserver'
require 'connect.rb'

class TestServer < GServer
  def initialize(port = 4000, *args)
    super(port, *args)
  end
  def serve( io )
      @test_hash = Hash.new
      connect(io) #Defined in connect.rb
    loop do
      str = io.gets
      parser(str,io)
    end
  end
end

The way that I'm doing it doesn't allow each thread to have it's own copy of
@test_hash and that's my problem. I need each thread to be able to change
the data stored in the hash without affecting the data stored in the hash
for all threads. I'm sure that my understanding of scope and GServer itself
is causing my problem, but I just don't know what to do to fix it. I was
thinking that I could pass the hash as a parameter to the connect function
but that would quickly become a problem as it would need to be passed to
several other functions after that and if possible I just don't want to have
to use that many extra parameters in my functions. Any help would be
appreciated.

5

a = Array(1..100)
a[0..a.size/2] = a[a.size*2/3..-1] = nil
p a

a = Array(1..100)

a.=(
  0..(a.size)./(2),
  a.=(
    (((a.size).*(2))./(3))..-1, nil
  )
)

p a

···

On 10/2/07, SpringFlowers AutumnMoon <summercoolness@gmail.com> wrote:

  a = Array(1..100)

  a[0..a.size/2] = a[a.size*2/3..-1] = nil

won't work and requires

why is that?

6

and to cut off the first 1/3 and last 1/3 of the array to get about 33
elements, shouldn't we use

  a[0..a.size/2] = a[a.size*2/3..-1] = nil

Or, just do a.slice!(a.size/3..a.size*2/3)
:slight_smile: but I somewhat realise this isn't the real question.

Arlen.

7

7stud -- wrote:

SpringFlowers AutumnMoon wrote:

why is that?

Or even simpler:

a = Array(1..6)

a[puts "hello"] = a[puts "world"] = nil

···

--
Posted via http://www.ruby-forum.com/\.

8

Hi --

···

On Tue, 2 Oct 2007, 7stud -- wrote:

SpringFlowers AutumnMoon wrote:

why is that?

a = Array(1..6)
p a

puts "size: #{a.size/3}"
a[p(0..a.size/3)] = a[p(a.size*2/3..-1)] = nil

Have you tried to run that? :slight_smile:

David

--
Upcoming training from Ruby Power and Light, LLC:
   * Intro to Ruby on Rails, Edison, NJ, October 23-26
   * Advancing with Rails, Edison, NJ, November 6-9
Both taught by David A. Black.
See http://www.rubypal.com for more info!

9

Hi,

···

Am Dienstag, 02. Okt 2007, 19:25:07 +0900 schrieb Chris Bailey:

I'm having a bit of a problem [...]

Please have a look where your message appears when you just
hit the "Reply" button:

  <http://news.gmane.org/gmane.comp.lang.ruby.general/cutoff=229420&gt;

Bertram

--
Bertram Scharpf
Stuttgart, Deutschland/Germany
http://www.bertram-scharpf.de

10

Arlen Christian Mart Cuss wrote:

and to cut off the first 1/3 and last 1/3 of the array to get about 33
elements, shouldn't we use

  a[0..a.size/2] = a[a.size*2/3..-1] = nil

Or, just do a.slice!(a.size/3..a.size*2/3)

there are so many people who are familiar with Ruby. Have been using
Ruby for a long time? Do you find after using Ruby, a work day becomes
a fun day?

···

--
Posted via http://www.ruby-forum.com/\.

11

puts returns nil, and you can't index an array with nil.

David

···

On Tue, 2 Oct 2007, 7stud -- wrote:

7stud -- wrote:

SpringFlowers AutumnMoon wrote:

why is that?

Or even simpler:

a = Array(1..6)

a[puts "hello"] = a[puts "world"] = nil

--
Upcoming training from Ruby Power and Light, LLC:
   * Intro to Ruby on Rails, Edison, NJ, October 23-26
   * Advancing with Rails, Edison, NJ, November 6-9
Both taught by David A. Black.
See http://www.rubypal.com for more info!

12

Hello,

Arlen Christian Mart Cuss wrote:
>> and to cut off the first 1/3 and last 1/3 of the array to get about 33
>> elements, shouldn't we use
>>
>> a[0..a.size/2] = a[a.size*2/3..-1] = nil
>
> Or, just do a.slice!(a.size/3..a.size*2/3)

there are so many people who are familiar with Ruby. Have been using
Ruby for a long time? Do you find after using Ruby, a work day becomes
a fun day?

I've been using it for a year or two now -- I'm lucky enough to have a
job where I can choose what language I program in :slight_smile: so, I think a "fun
day" is definitely the way to put it.

To be honest, though, I wasn't even sure a 'slice' or a 'slice!' command
existed when I read your first email. But, I felt the way you stated it
in the start wasn't very "rubyish" enough -- so I looked to see if there
was a way that was - for me - even less surprising. I just opened up
`irb', and then:

irb(main):001:0> a = (1..100).to_a
=> [1, 2, 3, [... removed half of this ...]
irb(main):002:0> a.methods.sort
=> ["&", "*", "+", [... lots of methods ...] "singleton_methods",
"size", "slice", "slice!", "sort", "sort!", [... lots more] "zip", "|"]
irb(main):003:0>

I was looking for something like "slice", and there it is. :slight_smile: So, if you
feel it's a bit tedious, try having a look!

Cheers!

Arlen

···

On Wed, 2007-10-03 at 01:06 +0900, SpringFlowers AutumnMoon wrote:

13

David A. Black wrote:

···

On Tue, 2 Oct 2007, 7stud -- wrote:

7stud -- wrote:

SpringFlowers AutumnMoon wrote:

why is that?

Or even simpler:

a = Array(1..6)

a[puts "hello"] = a[puts "world"] = nil

puts returns nil, and you can't index an array with nil.

Yes, I know, but that isn't the point of the example. The output
provides the answer to the question.
--
Posted via http://www.ruby-forum.com/\.

14

7stud -- wrote:

a[puts "hello"] = a[puts "world"] = nil

puts returns nil, and you can't index an array with nil.

How's this:

a = Array(1..6)

a[(puts "hello", 0..a.size/2;0..a.size/2)] = a[(puts "world",
a.size*2/3..1;a.size*2/3..1)] = nil
p a

···

--
Posted via http://www.ruby-forum.com/\.

15

My impression was that the OP knew what the evaluation order is, but
not why it is like that.

But anyway, my take on this is that

  a[0..a.size/2] = a[a.size*2/3..-1] = nil

is equivalent to:

  a.=(0..a.size/2, a.=(a.size*2/3..-1, nil))

Arguments are evaluated left to right, completely explaining the
evaluation order the OP is seeing.

Peter

···

On 02/10/2007, 7stud -- <dolgun@excite.com> wrote:

David A. Black wrote:
> On Tue, 2 Oct 2007, 7stud -- wrote:
>
>> 7stud -- wrote:
>>> SpringFlowers AutumnMoon wrote:
>>>>
>>>> why is that?
>>
>> Or even simpler:
>>
>> a = Array(1..6)
>>
>> a[puts "hello"] = a[puts "world"] = nil
>
> puts returns nil, and you can't index an array with nil.
>
>

Yes, I know, but that isn't the point of the example. The output
provides the answer to the question.

16

I guess it's safer to say that the order of evaluating arguments is
undefined, unless it is stated somewhere.

Is it defined for ruby?

···

On 2007-10-02 21:06:32 +0900 (Tue, Oct), Calamitas wrote:

My impression was that the OP knew what the evaluation order is, but
not why it is like that.

But anyway, my take on this is that

  a[0..a.size/2] = a[a.size*2/3..-1] = nil

is equivalent to:

  a.=(0..a.size/2, a.=(a.size*2/3..-1, nil))

Arguments are evaluated left to right, completely explaining the
evaluation order the OP is seeing.

--
A thousand words are worth a picture, and they load a heck of a lot faster.

17

Hi --

My impression was that the OP knew what the evaluation order is, but
not why it is like that.

But anyway, my take on this is that

  a[0..a.size/2] = a[a.size*2/3..-1] = nil

is equivalent to:

  a.=(0..a.size/2, a.=(a.size*2/3..-1, nil))

Arguments are evaluated left to right, completely explaining the
evaluation order the OP is seeing.

I guess it's safer to say that the order of evaluating arguments is
undefined, unless it is stated somewhere.

Is it defined for ruby?

I believe that a subscript expression is always going to be evaluated
first:

irb(main):001:0> a = [1,2,3,4,5]
=> [1, 2, 3, 4, 5]
irb(main):002:0> b = 1
=> 1
irb(main):003:0> a[b] = (b = 10)
=> 10
irb(main):004:0> a
=> [1, 10, 3, 4, 5]

David

···

On Tue, 2 Oct 2007, Mariusz PÄ~Ykala wrote:

On 2007-10-02 21:06:32 +0900 (Tue, Oct), Calamitas wrote:

--
Upcoming training from Ruby Power and Light, LLC:
   * Intro to Ruby on Rails, Edison, NJ, October 23-26
   * Advancing with Rails, Edison, NJ, November 6-9
Both taught by David A. Black.
See http://www.rubypal.com for more info!

18

Hi,

···

Am Dienstag, 02. Okt 2007, 22:25:26 +0900 schrieb David A. Black:

  This message is in MIME format. The first part should be readable text,
  while the remaining parts are likely unreadable without MIME-aware tools.
On Tue, 2 Oct 2007, Mariusz PÄ~Ykala wrote:

On 2007-10-02 21:06:32 +0900 (Tue, Oct), Calamitas wrote:

My impression was that the OP knew what the evaluation order is, but
not why it is like that.

I guess it's safer to say that the order of evaluating arguments is
undefined, unless it is stated somewhere.

Is it defined for ruby?

I believe that a subscript expression is always going to be evaluated
first:

I never found it's good programming practice in any language
to rely on evaluation order of function/method arguments.
Understanding your own code will become unneccessarily hard.

Bertram

--
Bertram Scharpf
Stuttgart, Deutschland/Germany
http://www.bertram-scharpf.de

19

David A. Black wrote:

I believe that a subscript expression is always going to be evaluated
first:

irb(main):001:0> a = [1,2,3,4,5]
=> [1, 2, 3, 4, 5]
irb(main):002:0> b = 1
=> 1
irb(main):003:0> a[b] = (b = 10)
=> 10
irb(main):004:0> a
=> [1, 10, 3, 4, 5]

I think you missed Mariusz Pękala's point:

Mariusz Pękala wrote:

···

On 2007-10-02 21:06:32 +0900 (Tue, Oct), Calamitas wrote:

Arguments are evaluated left to right, completely explaining the
evaluation order the OP is seeing.

I guess it's safer to say that the order of evaluating arguments is
undefined, unless it is stated somewhere.

Is it defined for ruby?
----------

In other words, I think Mariusz was pointing out that, yes the subscript
expressions are evaluated before the assignments, but does that
necessarily mean the subscript expressions are guaranteed to be
evaluated left to right. Since your example only has one subscript
expression, it doesn't shed any light on that issue.

--
Posted via http://www.ruby-forum.com/\.

20

Hi --

···

On Tue, 2 Oct 2007, Bertram Scharpf wrote:

Hi,

Am Dienstag, 02. Okt 2007, 22:25:26 +0900 schrieb David A. Black:

  This message is in MIME format. The first part should be readable text,
  while the remaining parts are likely unreadable without MIME-aware tools.
On Tue, 2 Oct 2007, Mariusz PÄ~Ykala wrote:

On 2007-10-02 21:06:32 +0900 (Tue, Oct), Calamitas wrote:

My impression was that the OP knew what the evaluation order is, but
not why it is like that.

I guess it's safer to say that the order of evaluating arguments is
undefined, unless it is stated somewhere.

Is it defined for ruby?

I believe that a subscript expression is always going to be evaluated
first:

I never found it's good programming practice in any language
to rely on evaluation order of function/method arguments.
Understanding your own code will become unneccessarily hard.

I wouldn't go out of my way to do tricks involving evaluation order,
but I certainly advocate understanding what's going to happen under
what circumstances.

David

--
Upcoming training from Ruby Power and Light, LLC:
   * Intro to Ruby on Rails, Edison, NJ, October 23-26
   * Advancing with Rails, Edison, NJ, November 6-9
Both taught by David A. Black.
See http://www.rubypal.com for more info!