iterator - Operator Precedence and Order of Evaluation in Ruby: yield vs << (shovel operator)

Question

I'm reading this book Well-Grounded Rubyist and its Control-Flow Techniques chapter on p.184 has a simple example of implementing map with an iterator:

class Array
  def my_map
    c=0
    acc = []
    until c == size
      acc << yield self[c]
      c += 1 end
    acc
  end
end

I have the following error when run this code ruby MY_FILE.rb:

MY_FILE.rb:6: syntax error, unexpected `self', expecting `end'
      acc << yield self[c]

Solution to this problem is to put brackets around yield self[c], so this whole line would look like this:

  acc << (yield self[c])

Then, the routine works with this one-line change. In my understanding the problem is either with operator precedence or with order of evaluation. I surfed the web for quite a while but could not pinpoint why exactly the code from the book does not work.

Why the book example does not work? What is operator precedence or/and order of evaluation in acc << yield self[c]?

Answer 1

Usually, method parameters come in parentheseis:

x=foo(y)
a=bar(baz(z))
b=7+baz(w)

In certain situations (i.e. if precedences does not bind otherwise), you can leave out the braces. Therefore,

x = foo y

works, but

a = bar baz z

is interpreted as

a = (bar(baz))(z)

and

b = 7 + baz w

as

b = (7+baz) w

This is risky, if the interpretation of the expression results in something meaningful. In this case, you would not even get an error message, but the program would simply behave in a different way than you expected.

In general, it is a good idea to always use parenthesis when invoking methods.