Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Ruby > order of evaluation for method arguments

Reply
Thread Tools

order of evaluation for method arguments

 
 
Michael Garriss
Guest
Posts: n/a
 
      09-13-2003
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


 
Reply With Quote
 
 
 
 
Tim Hunter
Guest
Posts: n/a
 
      09-13-2003
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?
 
Reply With Quote
 
 
 
 
Michael Garriss
Guest
Posts: n/a
 
      09-13-2003
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



 
Reply With Quote
 
Yukihiro Matsumoto
Guest
Posts: n/a
 
      09-13-2003
Hi,

In message "Re: order of evaluation for method arguments"
on 03/09/13, Michael Garriss <(E-Mail Removed)> 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.

 
Reply With Quote
 
daz
Guest
Posts: n/a
 
      09-13-2003

"Michael Garriss" <(E-Mail Removed)> 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



 
Reply With Quote
 
ts
Guest
Posts: n/a
 
      09-13-2003
>>>>> "d" == daz <(E-Mail Removed)> writes:

d> "Michael Garriss" <(E-Mail Removed)> 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


 
Reply With Quote
 
daz
Guest
Posts: n/a
 
      09-13-2003

"ts" <(E-Mail Removed)> wrote:

> >>>>> "d" == daz <(E-Mail Removed)> writes:

>
> d> "Michael Garriss" <(E-Mail Removed)> 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



 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Order of evaluation of arguments in a subroutine Krishna Chaitanya Perl Misc 1 12-09-2010 07:49 PM
order of evaluation of arguments to constructors Peter C++ 7 03-22-2007 11:09 PM
Order of evaluation of function arguments dragoncoder C Programming 21 12-23-2005 07:08 PM
[EVALUATION] - E03 - jamLang Evaluation Case Applied to Python Ilias Lazaridis Python 2 04-24-2005 05:29 PM
[EVALUATION] - E03 - jamLang Evaluation Case Applied to Ruby Ilias Lazaridis Ruby 74 04-04-2005 05:29 PM



Advertisments