[ruby-core:25219] Re: Module#prepend and Array#prepend

On Mon, Aug 31, 2009 at 8:39 AM, Yusuke ENDOH<[e-mail]> wrote:
> I cannot guess the problem you want to solve.  know this mail
> is just discussion log or reminder, but I'd like you to elaborate
> your proposal completely when sending to ruby-core.
>
> Why don't you define subclass explicitly?
>
> lass Person
> ef speak(words)
> uts words
> nd
> nd
> odule Exclaim
> ef speak(words)
> uper("#{ words }!")
> nd
> nd
> lass Exclaimer < Person
> nclude Exclaim
> nd
> xclaimer.new.speak("matz") #=> matz!

Perhaps I'm mistaken but I think that besides the 'syntax' difference,
Yehuda's intent was that something like this would work:


class Person
    def speak(str)
         str
    end
end

p = Person.new

p.speak("hello") #=> "hello"

module LoudSpeaker
   def speak(str)
         super(str.upcase)
   end
   end
end

class Person
    prepend Voice
end

p.speak("hello") #=> "HELLO"

If this is the intent, it's more than adjusting the ancestor chain of
the class when it prepends a module, but adjusting the ancestor chain
of any present and future instances of that class.

I think that this is the intent because of something Yehuda said in
the post which started this thread: "Effectively, prepend would
prepend a module to the class' ancestor chain. Implementation-wise, it
means that all methods on a class are put into an implicit module, or
an implicit subclass is created for each new class that can have
modules mixed into it (via prepend)."

Although hidden, or maybe transparent, might be a better word here than hidden.

I think there are several interesting discussion topics about this idea.

First, is it useful enough to carry it's weight.

Second, if it is what's the 'right' syntax.

Third, what's the impact on implementation and potential for edge cases.

I think that the Yehuda's implementation suggestions are that either:

   The existing hash in class objects which maps method selectors to
methods would actually be empty, or at least not consulted directly
during method lookup and the class would start out with klass pointing
to something akin to a module proxy, really a class proxy pointing to
the instance method hash of the class.  The prepend method would
insert a module proxy for the module being prepended at the head of
the chain started by the klass field of the class. The current include
method would search the klass chain for the special class proxy and
insert the module proxy just after that.

or

 A hidden subclass with no instance methods be created for each class
which could "have modules mixed into it (via prepend)" and  instances
of the class would actually be directly instances of this hidden class
instead of the class itself.  Prepend would insert a module proxy
between this hidden class and the actual class.  I think that this
would need to be the case for every class since I don't know how you
would predict if prepend would be sent to the class in future.

These two alternatives seem to me to be only subtly different, I
suspect that the first one is cleaner, but I don't know.

Some questions that occur to me:

1) Since prepend is really a variation on include, if you can prepend
a module to a class, why can't you prepend a module to a  module

2) Is there a similar variant for extend?

3) Which is related to the question of should you be able to prepend
to a singleton-class?

4) Are there edge-cases related to handing super?  Right now unless
it's changed (again) in Ruby 1.9, include takes pains not to have a
proxy to the same module show up twice in an ancestor chain because of
the way super method lookup works by searching first from the
beginning of self's klass chain for the current method, then searching
again for the next one, which can cause unexpected results if super is
used in a method invoked itself from super earlier in the chain.


-- 
Rick DeNatale

Blog: http://talklikeaduck.denhaven2.com/
Twitter: http://twitter.com/RickDeNatale
WWR: http://www.workingwithrails.com/person/9021-rick-denatale
LinkedIn: http://www.linkedin.com/in/rickdenatale