Ruby operator precedence table

Question

Show me a definitive, peer-reviewed/maintained Ruby precedence table (of operators, non-operators, and modifiers).

Over the years I have had to rely on the following sources for this information:

1. http://phrogz.net/programmingruby/language.html#table_18.4 - The Pickaxe book, which documents Ruby 1.6, which was released in September 2000, and includes a formatting error or typo ({ is listed as an assignment operator).

2. http://www.techotopia.com/index.php/Ruby_Operator_Precedence - A near copy of the above Pickaxe table, including the erroneous {, and accidentally describes || as Logical 'AND'.

3. http://www.tutorialspoint.com/ruby/ruby_operators.htm - Also a near copy of the Pickaxe table, though it fixes the description of || to Logical 'OR', yet it still lists { as an assignment operator. As well, it lists :: and incorrectly describes it as a constant resolution operator (:: is not an operator).

4. http://my.safaribooksonline.com/book/web-development/ruby/9780596516178/expressions-and-operators/operators - The Ruby Programming Language book, which documents Ruby 1.8 and 1.9, which were released in August 2003 and December 2007, respectively. This book was published in 2008 by David Flanagan and Yukihiro Matsumoto (aka "Matz", the inventor of Ruby). It seems to be the most up-to-date and accurate list of operators, non-operators, modifiers, and supporting information. Incidentally, around 2005, interest in Ruby surged in tandem with Rails, which was released in July 2004.

5. http://romhack.wikia.com/wiki/Ruby_operators - Also documents operators in Ruby 1.9, and includes non-operators and modifiers in its table.

Ruby 2.0 was released in February 2013, and was intended to be fully backward compatible with Ruby 1.9.3. Of the few known incompatibilities, none are related to operators.

Ruby 2.1.0 was released on Christmas Day in 2013, and similarly, no operator incompatibilities are listed.

Thus, I decided to include an answer, based on the Flanagan/Matz book, and made it a community wiki.

Answer 1

Ruby 2.1.0, 2.0, 1.9, 1.8

An operator is a token that represents an operation (such as addition or comparison) to be performed on one or more operands. The operands are expressions, and operators allow us to combine these operand expressions into larger expressions. (Ref)

N = arity = The number of operands the operator operates on. (Ref)

A = associativity = The order of evaluation when the same operator (or operators with the same precedence) appear sequentially in an expression. The value L means that expressions are evaluated from left to right. The value R means that expressions are evaluated from right to left. And the value N means that the operator is nonassociative and cannot be used multiple times in an expression without parentheses to specify the evaluation order. (Ref)

M = definability = Ruby implements a number of its operators as methods, allowing classes to define new meanings for those operators. Column M of specifies which operators are methods. Operators marked with a Y are implemented with methods and may be redefined, and operators marked with an N may not. (Ref)

The following table is ordered according to descending precedence (highest precedence at the top).

N A M  Operator(s)            Description
- - -  -----------            -----------
1 R Y  ! ~ +                  boolean NOT, bitwise complement, unary plus
                              (unary plus may be redefined from Ruby 1.9 with +@)

2 R Y  **                     exponentiation
1 R Y  -                      unary minus (redefine with -@)

2 L Y  * / %                  multiplication, division, modulo (remainder)
2 L Y  + -                    addition (or concatenation), subtraction

2 L Y  << >>                  bitwise shift-left (or append), bitwise shift-right
2 L Y  &                      bitwise AND

2 L Y  | ^                    bitwise OR, bitwise XOR (exclusive OR)
2 L Y  < <= >= >              ordering

2 N Y  == === != =~ !~ <=>    equality, pattern matching, comparison
                              (!= and !~ may not be redefined prior to Ruby 1.9)

2 L N  &&                     boolean AND
2 L N  ||                     boolean OR

2 N N  .. ...                 range creation (inclusive and exclusive)
                              and boolean flip-flops

3 R N  ? :                    ternary if-then-else (conditional)
2 L N  rescue                 exception-handling modifier

2 R N  =                      assignment
2 R N  **= *= /= %= += -=     assignment
2 R N  <<= >>=                assignment
2 R N  &&= &= ||= |= ^=       assignment

1 N N  defined?               test variable definition and type
1 R N  not                    boolean NOT (low precedence)
2 L N  and or                 boolean AND, boolean OR (low precedence)
2 N N  if unless while until  conditional and loop modifiers

Answer 2

RE Ruby Operators Precedence

A useful list can also be found at the bottom of this page:

https://www.tutorialspoint.com/ruby/ruby_operators.htm

RE: Using {}

Local variables begin with a lowercase letter or _. The scope of a local variable ranges from class, module, def, or do to the corresponding end or from a block's opening brace to its close brace {}.

When an uninitialized local variable is referenced, it is interpreted as a call to a method that has no arguments.

Assignment to uninitialized local variables also serves as variable declaration. The variables start to exist until the end of the current scope is reached. The lifetime of local variables is determined when Ruby parses the program.

In the above example, local variables are id, name and addr.

ALSO: You can substitute the value of any Ruby expression into a string using the sequence #{ expr }. Here, expr could be any ruby expression.

Source: https://www.tutorialspoint.com/ruby/ruby_variables.htm