无法理解`puts {}。class`和`puts（{} .class）`之间的区别

Question

As the anonymous block and hash block looks like approximately same. I was doing kind of playing with it. And doing do I reached to some serious observations as below:

{}.class
#=> Hash

Okay,It's cool. empty block is considered as Hash .

print{}.class
#=> NilClass
puts {}.class

#=> NilClass

Now why the above code showing the same as NilClass ,but the below code shows the Hash again ?

puts ({}.class)
#Hash
#=> nil
print({}.class)
#Hash=> nil

Could anyone help me here to understand that what's going one above?

I completely disagree with the point of @Lindydancer

How would you explain the below lines:

print {}.class
#NilClass
print [].class
#Array=> nil
print (1..2).class
#Range=> nil

Why not the same with the below print [].class and print (1..2).class ?

EDIT

When ambiguity happens with local variable and method call, Ruby throws an error about the fact as below :

name
#NameError: undefined local variable or method `name' for main:Object
#        from (irb):1
#        from C:/Ruby193/bin/irb:12:in `<main>'

Now not the same happens with {} (as there is also an ambiguity between empty code block or Hash block). As IRB also here not sure if it's a empty block or Hash . Then why the error didn't throw up when IRB encountered print {}.class or {}.class ?

Answer 1

The precedence rules of ruby makes print{}.class interpreted as (print{}).class . As print apparently returns a nil the class method returns #NilClass .

EDIT : As been discussed on other answers and in the updates to the question, print{} it of course interpreted as calling print with a block, not a hash. However, this is still about precedence as {} binds stronger than [] and (1..2) (and stronger than do ... end for that matter).

Answer 2

{} in this case is recognized as block passed to print , while [] unambiguously means empty array.

print {}.class                            # => NilClass
print do;end.class                        # => NilClass

Answer 3

You are running into some nuances of Ruby, where characters mean different things depending on context. How the source code is interpreted follows rules, one of which is that {} is a closure block if it follows a method call , and otherwise a Hash constructor.

It's common throughout the language to see characters mean different things depending on context or position within the statement.

---

Examples:

Parens () used for method call or for precedence

print(1..5).class => NilClass
print (1..5).class => Range <returns nil>

Square brackets [] used to call :[] method or for Array

print[].class => NoMethodError: undefined method `[]' for nil:NilClass
print([].class) => Array <returns nil>

Asterisk * used for multiplication or splatting

1 * 5 => 5
[*1..5] => [1, 2, 3, 4, 5]

Ampersand & used for symbol -> proc or logical and

0 & 1 => 0
[1, 2, 3].map(&:to_s) => ["1", "2", "3"]

Or in your case, braces used for block closures or for a hash

... hope it makes sense now ...