Let me say up front that I'm trying to clarify my understanding of how things
are in Ruby.  So my views below are more a reflection of my current
understanding rather than how things truly are in Ruby.

>R> 1.  [should have asked this in the beginning]  why can't class methods be
>R>     aliased?

> class method can be aliased. Hah::new was an example.

     Let me explain my perspective.  To alias a class method like Hash.new I
     would have prefered something more direct like:
  
         alias old_new Hash.new

     and then to be able say later on

         Hash.old_new

     but the requirment of alias is that its args have to be names or symbols
     so when I tried the above I'd get a parse error.

   From a meta-class perspective, my view is that "class methods" are
   "instance methods" of an object of type Class: we invoke instance methods
   on instances and class methods on classes (i.e., on objects of type Class)
   Hence when we do:

    class Hash
        class << self
          alias old_new new
        ...
    
    we are aliasing 'new' which in this context is an -instance- method of the
    anonymous class being created.  So we are once again only aliasing
    instance methods (of classes this time, rather than normal instance
    methods of objects). Right?  The end result is that from the perspective
    of instances a class method is getting altered but as far as 'alias'
    itself is concerned it is only dealing with instance methods.

>R> 2. On an unrelated issue,  why is it Module#module_function instead of
>R>    #module_method.  We are, after all, creating module methods from instance
>R>    methods .

> For me a method is associated with an object, and an object with a class.

   Agreed.  But for all practical purposes wouldn't you say that a module is
   that a class that can't be instantiated.  The terminology for methods
   associated with modules seems to be "instance methods" and "module
   methods".  Hence it seemed odd to me that the mechanism by means of which
   we create a module method from an instance method of a module would be
   termed #module_function rather than #module_method.  We are after all
   creating something more akin to a method rather than a function
   (proc/lambda). 

>R>    I'm under the impression that aliasing also copies.

> No, not really

    Could you explain a bit more here.  page 232 of the pickaxe book
    describes the process of aliasing as copying.  So if I did:

       alias foo bar

    and then later modified 'bar'  this would not affect 'foo'.  Rather than
    'foo' being a reference to 'bar'  they both seem to be separate entities.

Thanks,
Raja