Ruby

By D.new.bar, not foo but bar is searched in refinements, so M#C#foo cannot be found.
I've fixed alias to use C#foo.

Why that? I assumed two scenarios.

(1) Invoke C#foo

• D#bar -> find a method entry (alias to C#foo)
• Invoke C#foo

(2) Invoke M#C#foo

• D#bar -> find a method entry (alias to C#foo)
• C#foo is refined by M so invke M#C#foo

Of course, if D#bar is refined, then the refining method should be invoked.

Simplify example:

class C def foo p "C" end end module M refine C do def foo p "Refiend C" end end end class C alias bar foo end C.new.foo C.new.bar using M C.new.foo C.new.bar 

C.new.foo # C C.new.bar # C using M C.new.foo # refined C C.new.bar # C 

I agree that invoking only "C" is reasonable because it can be direct pointer to C#foo.
However, I think it is also reasonable to call refined C because people can assume C#bar should be same as C#foo.

Koichi Sasada wrote:

However, I think it is also reasonable to call refined C because people can assume C#bar should be same as C#foo.

If so, what should be printed by the last C.new.bar in the following example?

class C def foo p "C#foo" end end module M refine C do def foo p "Refiend C#foo" end def bar p "Refined C#bar" end end end class C alias bar foo end C.new.foo C.new.bar using M C.new.foo C.new.bar 

Koichi Sasada wrote:

I believe the implementation uses (2) model.

For (1), calling M::C#bar is reasonable.
For (2), calling M::C#bar is reasonable.

Wow, both should be M::C#bar.

Example on #5, both models should call M::C#bar. But my comment at #5 "C#bar should be same as C#foo" is wrong.

M::C#bar is not defined in Example #5, so the orignal C#bar, which is an alias of C#foo, should be called, shoudn't it?

I will offer a quick opinion: refinements are an overlay on the method table, and therefore modifications to the method table should not reflect refinements. Put differently: the alias bar foo should call C#foo always, because there it is a modification to D's method table.

We already established in past discussions about refinements that the class's actual method table (and methods that query or manipulate it) should not reflect refinements, since that would require them to be aware of the caller's scope. This is just another case of the same thing: creating an alias looks up in the target class/module's method table and adds a new entry. It's as simple as that.

Let's discuss with use cases. I don't have good example, but please assume we want to make new Hash class to support something like HashWithIndifferentAccess.

Okay, we need an extra Hash class doing something special.

class MyHash < Hash def initialize *args args.each{|(k, v)|self[k] = v} end alias iterate each end h = MyHash.new([:b, 1], [:a, 2]) h.each{|k, v| p [k, v]} # [:b, 1] [:a, 2] 

Good.

Next time, I invented a nice refinement to iterate Hash contents by ordered.

module OrderedHashEach refine Hash do def each sort.each{|k, v| yield k, v } end end end using OrderedHashEach {b: 1, a: 2}.each{|k, v| p [k, v]} # [:a, 2], [:b, 1] 

Excellent.

And of course, we can combine MyHash and OrderedHashEach.

module OrderedHashEach refine Hash do def each sort.each{|k, v| yield k, v } end end end class MyHash < Hash def initialize *args args.each{|(k, v)|self[k] = v} end end h = MyHash.new([:b, 1], [:a, 2]) using OrderedHashEach h.each{|k, v| p [k, v]} # [:a, 2] [:b, 1] 

Great.

Wait. each is not good terminology for our project. Use iterate intead.

module OrderedHashEach refine Hash do def each sort.each{|k, v| yield k, v } end end end class MyHash < Hash def initialize *args args.each{|(k, v)|self[k] = v} end alias iterate each end h = MyHash.new([:b, 1], [:a, 2]) using OrderedHashEach h.iterate{|k, v| p [k, v]} # [:b, 1] [:a, 2] 

It doesn't affect :( It is unexpected result for me.

Note that I don't want to change this specification. I want to know what is ideal specification.

This time, I made a scenario that we may want to use M::C#foo.

Koichi Sasada wrote:

Wait. each is not good terminology for our project. Use iterate intead.

module OrderedHashEach refine Hash do def each sort.each{|k, v| yield k, v } end end end class MyHash < Hash def initialize *args args.each{|(k, v)|self[k] = v} end alias iterate each end h = MyHash.new([:b, 1], [:a, 2]) using OrderedHashEach h.iterate{|k, v| p [k, v]} # [:b, 1] [:a, 2] 

It doesn't affect :( It is unexpected result for me.

If you need to refine iterate you should define OrderedHashIterate
and use it instead.

Refinements are designed not to change behavior implicitly.
If refinements are changed to affect aliases, someone might complain
that refinements don't support local rebinding.