Why does `puts(nil or 4)` fail in Ruby?

Question

When I do:

puts(nil or 4)

Ruby complains:

SyntaxError: syntax error, unexpected ke         


        

Answer 1

@Sergio Tulentsev (and @sawa) gave a good answer, but I want to rephrase it so I can understand it quickly in the future:

Ruby lets us drop parenthesis in function calls. That is, instead of:

func1(ARG, ARG, ARG) or func2(ARG, ARG, ARG)

We can do:

func1 ARG, ARG, ARG or func2 ARG, ARG, ARG

However, in order to make this last line behave like the first one, "or" can't be an operator used in the top-level of an ARG (otherwise that last line will be interpreted as func1(ARG, ARG, ARG or func2 ARG, ARG, ARG)). Indeed, when we look in the BNF we see that ARG doesn't directly mention "or"/"and" (which means it's illegal there).

But ARG still makes it possible to use "or": by wrapping the expression in parentheses. In the BNF we see this as the PRIMARY alternative that ARG can branch to (as PRIMARY, in its turn, branches to '(' COMPSTMT ')').

Now, as to why func (1 or 2) and func((1 or 2)) work whereas func(1 or 2) doesn't:

• func(1 or 2) is what the BNF calls FUNCTION, which expands to OPERATION ['(' [CALL_ARGS] ')'], which means the ARG is "1 or 2", but, as we've seen, ARG can't contain "or", so it's invalid.

• func((1 or 2)) is, again, OPERATION ['(' [CALL_ARGS] ')'], but here the the ARG is "(1 or 2)", which is a valid ARG (see PRIMARY mentioned above).

• func (1 or 2) is what the BNF calls COMMAND, which expands to OPERATION CALL_ARGS, which means the ARG is "(1 or 2)", which is a valid ARG (see PRIMARY mentioned above).

Answer 2

Short answer

Because that's how ruby syntax is.

Longer answer

and/or keywords were designed to be used in control flow constructs. Consider this example:

def die(msg)
  puts "Exited with: #{msg}"
end

def do_something_with(arg)
  puts arg
end

do_something_with 'foo' or die 'unknown error'
# >> foo
# >> Exited with: unknown error

Here or works nicely with ruby's optional parentheses, because of ruby parsing rules (pseudo-BNF).

In short, an argument list (CALL_ARGS) is a list of ARG, separated by comma. Now, most anything is an ARG (class definitions, for example, through being a PRIMARY), but not an unadorned EXPR. If you surround an expression with parentheses, then it'll match a rule for "compound statement" and, therefore, will be a PRIMARY, which is an ARG. What this means is that

puts( (nil or 4) ) # will work, compound statement as first argument
puts (nil or 4)  # same as above, omitted optional method call parentheses
puts(nil or 4) # will not work, EXPR can't be an argument
puts nil or 4 # will work as `puts(nil) or 4`

You can read the grammar referenced above to understand exactly how it works.

BONUS: Example of class definition being a valid ARG

puts class Foo
       def bar
         puts "hello"
       end
     end, 'second argument'

# >> bar # this is the "value" of the class definition
# >> second argument

Answer 3

It is because or and and have lower precedence than method call. Your expression is interpreted as:

{puts(nil} or {4)}

where {} stands for grouping. The syntax error comes from the expression

puts(nil

(and the following will also raise a syntax error):

4)

If you force grouping by putting a pair of parentheses around the expression, then it will work the way you intended:

puts((nil or 4))

Notice that the outer pair of parentheses is used for method call, not grouping, hence just having one pair of parentheses has no effect of changing the grouping.

Alternatively, if you disambiguate a single pair of parentheses to be used for grouping by putting a space, then that will work too:

puts (nil or 4)