Matz,
One of the biggest breaking changes in Ruby 1.9 is the change in constant
lookup inside a proc that is *_eval'ed.

For instance,

*1.8*
*
*
class Foo
  class Bar
  end
  def evaluate(&blk) instance_eval(&blk) end
end

Foo.new.evaluate { Bar }
NameError: uninitialized constant Bar

*1.9*

class Foo
  class Bar
  end

  def evaluate(&blk) instance_eval(&blk) end
end

Foo.new.evaluate { Bar }
=> Foo::Bar


The 1.9 behavior is understandable if everything is in one file. However, in
the normal case, instance_eval is used to implement DSLs. For instance,
rspec has the following semantics:

module RubyFun
  class Foo
  end

  describe ("Foo") do
    it("exists") do
      lambda { Foo }.should_not raise_error
    end
  end
dnc

This test passes in 1.8 but not in 1.9 because of the change in behavior. It
also clearly articulates the *reason* for the 1.8 behavior: it is more the
expected behavior. One of the things that's great about Ruby is that it
focuses on programmer understanding, even if that is sometimes slow. This is
a case where the programmer expects to see a constant but it is being looked
up somewhere the programmer knows nothing about. I think it is clear that
the old behavior is better, even if it is harder to implement. Additionally,
both JRuby and Rubinius were able to implement the old behavior in a
compiled system, so it should be possible.

Thanks for your time.

-- 
Yehuda Katz
Developer | Engine Yard
(ph) 718.877.1325