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]

On Sat, 13 Sep 2003 09:12:57 +0900, 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
> --> 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]

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
> --> 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"
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.

[daz]

"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
> > --> 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]

>>>>> "d" == daz <dooby@d10.karoo.co.uk> writes:

d> "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]

>>

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]

"ts" <decoux@moulon.inra.fr> wrote:

> >>>>> "d" == daz <dooby@d10.karoo.co.uk> writes:

>
> d> "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]

> >>

>
> 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