I was reading Perl Cannot Be Parsed: A Formal Proof on PerlMonks over breakfast this morning (this may in itself cause you to worry about me), which introduced me to a clever, ambiguous snippet of Perl constructed by Randall Schwartz:
whatever / 25 ; # / ; die "this dies!";
How this is parsed depends on what
whatever is: if
it’s a function that takes an argument, the slashes delimit a
regular expression, and the following statement kills the
If, on the other hand,
whatever is a function
without any arguments, its return value is divided by 25, and the
rest of the line is a comment.
Since it’s possible to define
the snippet can’t be parsed without running the program up to that
point. Ergo, Perl cannot be parsed statically.
But can we do the same in Ruby? Initially, it seems possible. The disambiguation of slashes has an additional nicety in Matz’s Ruby interpreter: if there’s a space after the opening slash, it will always be interpreted as a division operator. This works, though:
whatever /25#/; raise 'this dies!'
The meaning of the line depends on whether
is a method or a variable:
whatever = 100 whatever /25#/; raise 'this dies!' # completes
def whatever(re) end whatever /25#/; raise 'this dies!' # dies
So it looks like we can perform the Perl trick and use code to
whatever is, thereby creating Ruby code
that can’t be parsed. But, in fact, it doesn’t work, because Ruby’s
cleverer than that. And by clever, I mean evil. Ruby looks at
everything in the current context—even unreachable code—to
determine what the symbol
whatever refers to. So this
works as you’d expect:
if false def whatever() 200 end else whatever = 100 end whatever # => 100
But reverse the logic, and something strange happens:
if true def whatever() 200 end else whatever = 100 end whatever # => nil
Even though the method is defined, and the variable isn’t, the
parser has ‘seen’ the variable, and the meaning of the symbol is
changed into a variable. The message
never sent, because it refers to a variable. But that variable
isn’t defined! Instead of an error, though, we get nil.
If you’re thinking of getting round it by setting up the
eval, I’ve bad news: that doesn’t work
eval "def whatever() 200 end" whatever # => 200
eval "whatever = 100" whatever # => NameError: undefined local variable or method `whatever' for main:Object
So there you go. Ruby’s syntax may have some apparent ambiguities, but they can be resolved statically. At least, unless there are any others I don’t know about …
Incidentally, it’s testament to the hard work that the JRuby developers have put in that it has exactly the same behaviour.