RCR 267: "original" keyword in method redefinition (like "super")

A keyword "original" which could be used to call the previous definition of the current method in this class, similar to the keyword "super" which is used to call the definition of the current method in the superclass. This makes redefining a method a lot nicer in many cases.

Suggestiong for a better name than "original" are welcomed.

Ruby allows you to redefine methods of some class in an unrelated section of code. Often it is desired to use this to add one feature to a method.

For example, I might want to introduce a new numeric type, and allow Fixnum#+ to accept it. There is currently no simple way to refer to the "old" behaviour of Fixnum#+ inside my new definition, and so I resort to something like:

class Fixnum
alias :old_plus :+
def +(x)

  if x.is_a? MyType
    ...
  else
    old_plus(x)
  end

end
end

Except that I have to take care to use a unique method name instead of "old_plus", in case another library does this too and the names collide.

This is cumbersome, and results in namespace pollution.

Add a keyword "original".

It would have the same syntax as "super", and its behaviour would be:
If the method with the current method's name was defined in the current method's class immediately prior to the def statement that defined the current method, then _that_ method is executed.
Otherwise, it behaves identically to "super"

The above example would become:

class Fixnum
def +(x)

   if x.is_a? MyType
      ...
   else
      original(x)
   end

end
end

The method aliasing method is ugly, not obvious to beginners, and just doesn't "feel right".

In most other common OO languages, methods can only be defined once, and so the equivalent of "super" refers to "the definition I'm overriding". Being able to add functionality like that without getting deep into the class's implementation is important for decoupled code.

There may be a case for making "super" behave like "original" instead of the current behaviour, or replacing it with "original", but that would likely be too disruptive.

Potential problems:
If "original" is called in Foo#meth and there was no previous definition, Foo#method_missing will get called with method name :meth. This is potentially confusing since the method does exist. I still think this is the best behaviour.
A backwards compatibility exists due to the introduction of a new keyword.
Performance/memory issues if uses of "original" cannot be identified (see Implementation)

(Note: I know very little about the implementation of Ruby, so please correct me if I'm wrong)

Excluding the case of eval-ing a string, I think it is possible to determine when parsing the method definition whether "original" is used. If it is not used, then the previous definition does not need to be stored, and so there should be negligible performance loss.
If it is used, the method could store a pointer to the "previous" method. When "original" is invoked in a method, it would invoke the "previous" method if non-null, otherwise it would behave as super does now. The performance cost should be less than when using the aliasing solution (due to being written in C and the fact that if the chain is broken all "orphan" methods get destroyed).

The problem with this is if eval(string) is used, it can't be determined if "original" will be called. Two options are:
a) Disallow "original" in eval(string). This makes it inconsistent with "super".
b) Always store the previous method if eval(string) is used. This increases the cost of eval() in cases where "original is not used".