Issue #8481 has been updated by headius (Charles Nutter).


I do not currently have a problem with Module level #using, provided it is still lexical. The same mechanism for file-level #using would work here: if a "using" call is present in the code, we'll treat all calls in that scope as potentially refined (different call logic). Scopes without a #using call will not do refined dispatch.

A few other clarifications I think are important:

* Since this is lexical, you can't __send__ or send :using from any scope and expect it to work. It might work by accident on some implementations, but this is non-spec. Should it be specified that it explicitly does *not* work?
* I assume we still do not have "magic" #send and #instance_method and friends, correct?

Regarding timeline for implementation in JRuby...

Because of the invasive nature of the changes required, we are not comfortable implementing it in the JRuby 1.7.x codebase. Therefore, we will probably not be able to start in earnest on a final implementation until after we branch 1.7. However, I would like to get a prototype implementation based on current 2.0 and upcoming 2.1 refinement features so we can work through issues sooner rather than later. I hope to do that this month...but hope is a complicated thing.
----------------------------------------
Feature #8481: Module#using
https://bugs.ruby-lang.org/issues/8481#change-39839

Author: shugo (Shugo Maeda)
Status: Open
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: core
Target version: current: 2.1.0


As I said at RubyKaigi2013, refinements in Ruby 2.0 have a problem that it's impossible to use incompatible refinements in the same file.
And at RubyKaigi, I've proposed the new option using: of instance_eval, by which you can activate refinements in the specified module only in the given block.
See my presentation slides for details: http://shugo.net/tmp/refining_refinements.pdf

However, Matz doesn't like that idea for the following two reasons:

1. It's difficult for users to expect what refinements are activated in a block.
2. It's difficult for Ruby implementors to implement it efficiently.

So, I propose Module#using instead of the using: option of instance_eval.
Module#using had once been introduced into trunk, but it was removed from Ruby 2.0.
I'd like to make it simpler, as follows.

1. Module#using activates refinements in a given module only in the current class or module definition.
2. So Module#using is private and the receiver of Module#using should be self.
3. The refinements never be activated in class or module definitions reopened later.
4. The refinements never be inherited to subclasses.

That is, Module#using works lexically.

EXAMPLE 1

  class Foo
    using Ref1
    # Refinements in Ref1 are activated only in the current definition of Foo.
  end
  class Bar
    using Ref2
    # Refinements in Ref2 are activated only in the current definition of Bar.
  end

EXAMPLE 2

  class Foo
    using Ref1
    # Refinements in Ref1 are activated only in the current definition of Foo.
  end
  class Foo
    # Refinements in Ref1 are not activated here.
  end

EXAMPLE 3

  class Foo
    using Ref1
    # Refinements in Ref1 are activated only in the current definition of Foo.
  end
  class Bar < Foo
    # Refinements in Ref1 are not activated here.
  end

Any thoughts?



-- 
http://bugs.ruby-lang.org/