"I decided not to introduce full refinement for Ruby 2.0."

Repost of the message, since bugs.ruby-lang.org appears to be down:

    Issue #4085 has been updated by matz (Yukihiro Matsumoto).
    
    
    Since there still remain undefined corner case behavior in refinements, 
    and the time is running out, I decided not to introduce full refinement 
    for Ruby 2.0. The limited Ruby 2.0 refinement spec will be:
    
    * refinements are file scope
    * only top-level "using" is available
    * no module scope refinement
    * no refinement inheritance
    * module_eval do not introduce refinement (even for string args)
    
    In addition, Module#include should add refinements to included modules, 
    e.g.
    
      module R1
        refine String do
          def bar
            p :bar
          end
        end
      end
    
      module R2
        include R1
        refine String do
          def foo
            p :foo
          end
        end
      end
    
      using R2
      "".foo
      "".bar
    
      module R1
        refine String do
          def bar; p :bar end
        end
      end
    
      module R2
        include R1
        refine String do
          def foo; p :foo end
        end
      end
    
      using R2
      "".foo
      "".bar  # does not work now
    
    You can treat top-level "using" as soft-keyword, as long as it does not 
    change the behavior (but performance).
    
    Matz.

I love Ruby with all my heart but that seems to be quite a mess. While a not-well-thought-through feature in some application can be forgiven (and maybe even removed), in language design it cetainly has no place. And while this should be a secondary consideration, I really feel for those poor JRuby and Rubinus guys. As if Ruby wasnt "dynamic" enough, the sheer complexity of implementing refinements must be awful!

I think, they should just leave it out (at least for now) and rather spend some more time on performance, stabilty and memory usage in MRI...

This, I feel, is a rather striking difference between the development processes in ruby and python and tells more about them than any superficial language benchmark or example could.

This is how generally new things to python are introduced: http://www.python.org/dev/peps/

Ok, tell me if I have this correct:

  module Foo
    def hello
      puts "Hello World"
    end
  end

  ...in a different file...

  foo = Foo.new.msg

Q: What does that print? A: There is no way to tell. It depends on what the 'using' line (not shown) is, and whether anything has refined 'Foo'.

Seems like bad action at a distance, to me. Or am I missing something? The example about the effects of refining 'each' is also pretty disconcerting.

Steve, I agree with you that this is a lot of change for something in preview, but didn't Rails 3 have some last minute changes before its release as well, and 3.1 was a big jump also?

Matz, Shugo, and Charlie will figure it out soon enough, but it is interesting. What is more upsetting to me really is the version number. 2.0 implies some major changes, but 1.9 was more major. It should be 1.10, and then they should work on something more revolutionary for 2.

There is a lot of pressure on Matz also. They really need to spend more time on it.

Anyone have an explanation on this part at the end?

      using R2
      "".foo
      "".bar  # does not work now

I can't figure out why "".foo would work in this case but "".bar wouldn't.

I wonder if the problem refinements are trying to solve has already been tackled in the 40+ years of computer programming.

If so, is there something to just learn from or copy for the Ruby team?

Huh, refinement is most of the reason I would want to upgrade to Ruby 2.0. 1.9 works for well for what I want to do.

I think this link is broken or overloaded.