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
Michael Garriss wrote:
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
→ nilI’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
Hi,
In message “Re: order of evaluation for method arguments” on 03/09/13, Michael Garriss mgarriss@earthlink.net writes:
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.
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.”
“Michael Garriss” mgarriss@earthlink.net wrote:
Michael Garriss wrote:
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
→ nilI’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?
#--------------------
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
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.
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
"Michael Garriss" <mgarriss@earthlink.net> wrote:
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
“ts” decoux@moulon.inra.fr wrote:
“Michael Garriss” mgarriss@earthlink.net wrote:
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.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