I don't see any difficult semantics in those examples.
The hard part of parsing Ruby is mostly trying to conform to MRI rather than to a formal grammar. In comparison the semantics are reasonably simple.
It's hard to compile Ruby efficiently, though, but for reasons unrelated to those examples.
(Incidentally I don't know if that scoping example is intentionally ignoring the fact that Ruby does support lexical scoping (EDIT: for blocks), or if it's lack of understanding of what what "def" is.
The Ruby way of achieving what that example is trying to do is:
def f(x)
g = proc do |y|
x + y
end
g[2]
end
f(2)
(g[2] is shorthand for g.call(2))
"def" explicitly introduced a method-level scope of the innermost wrapping class scope. Nesting 'def's is not in any way idiomatic Ruby. It's not necessarily very useful to nest them given those semantics. But "def" is really just syntactic sugar for #define_method, and so it is logical for it to work where #define_method does.
I might be inclined to agree that the different Ruby ways of defining blocks, methods and closures could do with some simplification. Allowing "def" to bind surrounding variables would remove a lot of the need for class instance variable or class variables, for example.
)
EDIT:
Also, the currying example would look like this in Ruby:
o = Object.new
def o.my_method(x)
self.y + x
end
def o.y
10
end
method_as_fun = o.method(:my_method)
method_as_fun[5]
You can argue for implicit currying if you want, but to me that's far more confusing. That said, it is extremely rare to find currying used in Ruby code.