What order are method arguments evaluated in Ruby?

Question

Up until my attempt to answer this question I had always assumed arguments were evaluated from left to right the way we type them. For example we have some method:

def foo(a,b,c)

Is there a way to monitor variable definitions and values in a Ruby program as time passes? If you call foo 0,1,2 how can you prove that variables assigned in the following order?

time 0: a = 0

time 1: b = 1

time 2: c = 2

I realize my example is trivial because I have the same type of argument for a, b, c but it potentially gets muddied up when you introduce default arguments, keyword arguments, and array arguments. If no one knows the answer I would appreciate suggestions on how to determine the answer.

Basically the Ruby equivalent of this.

This is crazy... I googled "ruby call what order are arguments" and ended up here only to find that you are linking to my question from 4 years ago. Just FYI, I think you are talking about parameter assignment order and not argument assignment. stackoverflow.com/questions/156767/… — Gerry
– Gerry, Commented Sep 20, 2020 at 10:40

Jörg W Mittag · Accepted Answer · 2016-03-25 01:51:24Z

5

The ISO Ruby Language Specification says that arguments are bound to parameters in the order in which they appear in the program text. However, the spec is vague about whether that also means that they are evaluated in that order.

The RubySpec, AFAICS doesn't say anything at all about the evaluation order of method arguments.

So, the answer seems to be: there is no guaranteed evaluation order for method arguments. It may be different between different implementations, it may be different between different versions of the same implementation, it may be different between two runs of the same version of the same implementation, it may even be different between two calls to the same method. They may be evaluated in parallel.

You just don't know.

answered Mar 25, 2016 at 1:51

Jörg W Mittag

371k79 gold badges457 silver badges666 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Mike S Over a year ago

It's slightly frustrating to not know the definitive order but you're right. Even if you can show with some code that in one example it is/isn't left-to-right, it does not mean that it necessarily always will be. Without an official source I guess we can't know.

Paa Yaw Over a year ago

i am able to say for certain that across all ruby versions(from ruby1.8.6 to present 2.7.0) the evaluation is the same through out. by running the following script below rvm use [ruby version] && ruby -ve 'def m(x,y); {same: x==y, ltor: x<y, rtol: x>y}; end; p m(Time.now, Time.now) for all the ruby versions to date( ruby 2.7.0), you will get the following return value below {:same=>false, :ltor=>true, :rtol=>false} where same means x and y are evaluated at the same time, ltor means left to right, and rtol means right to left.

Gerry Over a year ago

@PaaYaw sorry but it seems the question was using the word "argument" when from the examples Op clearly meant "parameter".

Jörg W Mittag Over a year ago

@MikeS: It is completely normal for a spec to not specify something. That is actually where performance comes from: not specifying something allows the implementor to choose the most efficient option. For example, in a massive multi-core system with low overhead, it would be possible to evaluate the arguments in parallel. Specifying an evaluation order would deny this optimization opportunity.

steenslag · Accepted Answer · 2016-03-24 18:59:17Z

3

def arg_test(a=Time.now, b=Time.now) puts "left to right" if a < b end arg_test #=> left to right

answered Mar 24, 2016 at 18:59

steenslag

80.2k16 gold badges144 silver badges174 bronze badges

2 Comments

Paa Yaw Over a year ago

this approach will be inconclusive if it returns nil. Because that could mean b is either assigned first or has the same timestamp as a.

Gerry Over a year ago

You can just output the timestamps

sawa · Accepted Answer · 2016-03-24 18:45:59Z

Perhaps you can record the initialization of the objects, and see them later in a stack.

module Record @@stack = [] def initialize *; super; @@stack.push(self) end def self.stack; @@stack end end class String prepend Record end def foo a, b, c; end foo(String.new("x"), String.new("y"), String.new("z")) Record.stack # => ["x", "y", "z"]

In this case, a, b, c are evaluated in this order.

With default value, you can see:

def foo a, b, c = String.new("c"); end foo(String.new("x"), String.new("y")) Record.stack # => ["x", "y", "c"]

Gerry · Accepted Answer · 2020-09-20 10:52:50Z

For anybody coming here looking for argument assignment order (what the question asks at the time of my post) and not parameter assignment order. I always assumed they were evaluated in the order written until I tried writing some odd code and got a strange result. steenslag gave me an idea of how I could test it:

def arg_test(a, b) puts([a, b].inspect '- out of order!') if a > b end 1000000.times { arg_test(Time.now, Time.now) }

This results in no output. So it seems they are assigned in order and my other code probably just has a bug.

Collectives™ on Stack Overflow

What order are method arguments evaluated in Ruby?

4 Answers 4

4 Comments

2 Comments

1 Comment

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

4 Comments

2 Comments

1 Comment

Comments

Linked

Related