From: "erlercw@..." <erlercw@...>
Date: 2005-01-16T05:28:50+09:00
Subject: Setting and getting methods and variables

Object#instance_variable_set
Object#instance_variable_get
Object#methods
Module#define_method
Module#remove_method
Module#undef_method

and all the other similar methods suffer from being scattered 
through several classes and naming inconsistencies.  
#instance_variable_set is not only noun-verb, the opposite of 
most method names, set is also different than define.  Also, 
what's the difference between remove and undef ?  It's not easy 
to tell on first glance and the help at ruby-doc.org is a bit 
misleading.

The main problem is that it seems like a bunch of hackish 
workarounds that were added after the language was designed.  
Java needs things like utility classes and long, wordy names, 
because it was badly designed.  Ruby doesn't need to suffer the 
same problems.

I propose a more streamlined way of changing methods and 
instance variables on the fly: treat them like hashes.  This 
doesn't have to affect the inner workings of Ruby, just the 
programmer's interface to Ruby.

For instance, object_or_class.private_instance_methods should 
return a reference to the object or class MethodHash.  This 
will allow easily adding new methods or getting old methods 
without obscure incantations.  The same kind of things could be 
done with instance and class variables (perhaps with a normal 
Hash or VariableHash).

MethodHash#merge would be an easy way to do advanced things 
similar to mixing in modules (although the current method of 
actually mixing in modules works fine and should be kept).

MethodHash#delete would be an easy way to do 
Object#remove_method; hash[:method] = nil should also work.  I 
propose leaving two ways to do Object#undef_method: provide 
Object#undef_method (or something with a better name like 
#forget_method or #block_method) that will set the method in 
the MethodHash to false (conceptually, Ruby looks at the 
object's methods first, and false would make the point clear to 
Ruby and programmers).  This will allow people to figure out 
how to block a method just by looking at method names and also 
allow a somewhat intuitive way of blocking to those who don't 
like memorizing method names.

MethodHash#keys would do the same thing as the array-returning 
methods (that list methods) do now.

This would make Ruby much less Java-like (verbose and no nice 
features like #[] and #[]= outside of arrays).  It would remove 
the need to learn which arcane incantation you need (and allow 
for Ruby's designers not to have to waste time thinking up 
names) for private instance methods compared to instance 
methods (Do I use 'set' or 'define' here ?  Does the verb come 
first or last ?  etc).  Plus, it would be, like blocks and 
iterators, easier to learn and apply in Ruby than most other 
languages.  It would also reduce the time I need to spend 
looking in Pickaxe for method names.

I'm planning on making this an RCR, but I wanted to hear a bit 
of criticism to help me shape the RCR.