order of evaluation for method arguments

[Michael Garriss]

Is this code guaranteed to always work this way:

a = [1,2,3,4,5]
--> [1, 2, 3, 4, 5]
def m( a, b, *c )
puts a, b, c
end
--> nil
m( a.shift, a.shift, a )
1
2
3
4
5
--> nil

I'm wondering (hoping) that the arguments will always be evaluated from
left to right as is the case above. Is this a 'ruby rule' or something
that could change?

TIA,
Michael

 

[Tim Hunter]

Is this code guaranteed to always work this way:

a = [1,2,3,4,5]
--> [1, 2, 3, 4, 5]
def m( a, b, *c )
puts a, b, c
end
--> nil
m( a.shift, a.shift, a )
1
2
3
4
5
--> nil

I'm wondering (hoping) that the arguments will always be evaluated from
left to right as is the case above. Is this a 'ruby rule' or something
that could change?

TIA,
Michael

Maybe it's just my C background, but I've always felt like depending on
the order of operations like this is a code smell. I'm curious about why
you're "hoping" it works the way you've described?

 

[Michael Garriss]

Is this code guaranteed to always work this way:

a = [1,2,3,4,5]
--> [1, 2, 3, 4, 5]
def m( a, b, *c )
puts a, b, c
end
--> nil
m( a.shift, a.shift, a )
1
2
3
4
5
--> nil

I'm wondering (hoping) that the arguments will always be evaluated
from left to right as is the case above. Is this a 'ruby rule' or
something that could change?

Let me extend the question to include arrays (which might be related to
arguments, I don't know, I've never looked at the ruby source):

a = [1,2,3,4,5]
--> [1, 2, 3, 4, 5]
b = [a.shift,a.shift,a.shift,a.shift,a.shift]
--> [1, 2, 3, 4, 5]


Michael

 

[Yukihiro Matsumoto]

Hi,

In message "Re: order of evaluation for method arguments"

|> I'm wondering (hoping) that the arguments will always be evaluated
|> from left to right as is the case above. Is this a 'ruby rule' or
|> something that could change?
|
|Let me extend the question to include arrays (which might be related to
|arguments, I don't know, I've never looked at the ruby source):

It's left to right. But I don't encourage you to depend on it.

matz.

 

[daz]

Is this code guaranteed to always work this way:

a = [1,2,3,4,5]
--> [1, 2, 3, 4, 5]
def m( a, b, *c )
puts a, b, c
end
--> nil
m( a.shift, a.shift, a )
1
2
3
4
5
--> nil

I'm wondering (hoping) that the arguments will always be evaluated
from left to right as is the case above. Is this a 'ruby rule' or
something that could change?

From Pickaxe:

The Ruby Language
Method Definition
Method Arguments

(I can't find this section on rubycentral/book to link to)


"The expressions are evaluated from left to right.
An expression may reference a parameter that precedes it
in the argument list."

#--------------------
a = [1,2,3,4,5]

def m( a, b, *c )
p a, b, c
end

m( a.shift, b=a, a )
#--------------------


#-> 1
#-> [2, 3, 4, 5]
#-> [[2, 3, 4, 5]]


So that's as safe as Pickaxe.

Let me extend the question to include arrays (which might
be related to arguments, I don't know, I've never looked
at the ruby source):

a = [1,2,3,4,5]
--> [1, 2, 3, 4, 5]
b = [a.shift,a.shift,a.shift,a.shift,a.shift]
--> [1, 2, 3, 4, 5]

Well, since:

a, b = b, a

is 'defined' (in the sense that it's a ruby idiom),
your example works the way I'd expect, even though
Matz has guarded his options. Perhaps he means that
this could look like a prime candidate for optimization
which would give [1, 1, 1, 1, 1] but I don't know if
anyone would like to see that happen.

Michael

daz

 

[ts]

a = [1,2,3,4,5] --> [1, 2, 3, 4, 5]
b = [a.shift,a.shift,a.shift,a.shift,a.shift] --> [1, 2, 3, 4, 5]

d> Well, since:

d> a, b = b, a

d> is 'defined' (in the sense that it's a ruby idiom),
d> your example works the way I'd expect, even though
d> Matz has guarded his options.

I don't see the relation between the two.

The first modify `a' in the RHS, the second not.

Perhaps, it can exist a version of ruby which give

b = [5, 4, 3, 2, 1]

and where

a, b = b, a

still work


Guy Decoux

 

[daz]

a = [1,2,3,4,5] --> [1, 2, 3, 4, 5]
b = [a.shift,a.shift,a.shift,a.shift,a.shift] --> [1, 2, 3, 4, 5]

d> Well, since:

d> a, b = b, a

d> is 'defined' (in the sense that it's a ruby idiom),
d> your example works the way I'd expect, even though
d> Matz has guarded his options.

I don't see the relation between the two.

The first modify `a' in the RHS, the second not.

Perhaps, it can exist a version of ruby which give

b = [5, 4, 3, 2, 1]

and where

a, b = b, a

still work


Guy Decoux

I defer, of course

I was merely trying to convey that Ruby evaluates all
RHS (in sequence) before assigning to LHS and it's
no accident (indeed sensible) that:

r = [1,2,3]

a, b = r.shift, r.shift
p [a, b]

#-> [1, 2]



daz