Do you know the official Ruby interpreter "goruby"?

# code from the Ruby soure, golf_prelude.rb, commented

class Object
  # initialize a global hash cache
  @@golf_hash = {}

  # let's begin the madness: our favourite method
  def method_missing m, *a, &b
    # search the cache for the missing method/class combination
    #  or assign it with the best matching constant name
    t = @@golf_hash[ [m,self.class] ] ||= matching_methods(m)[0]

    # if found in the hash and block_given?
    if t && b
      # call the method named by t and pass the arguments
      __send__(t, *a) {|*args|
        # also pass found regexes
        b.binding.eval("proc{|golf_matchdata| $~ = golf_matchdata }").call($~) if $~
        # and execute the block
        b.call(*args)
      }

    # if no block is given
    else
      # call the method named by t or throw method_missing again
      t ? __send__(t, *a, &b) : super
    end
  end


  # here comes the magic
  def matching_methods(s='', m=callable_methods)
    # build a regex which starts with ^ (beginning)
    # take every letter of the method_name
    #   insert "(.*?)" instead, which means: match anything and take the smallest match
    #   and insert the letter itself (but escape regex chars)
    #
    # for example s='matz'
    # => /^(.*?)m(.*?)a(.*?)t(.*?)z/
    #
    r=/^#{s.to_s.gsub(/./){"(.*?)"+Regexp.escape($&)}}/

    # match all available methods for this regex
    #  and sort them by the least matches of the "fill" regex groups
    m.grep(r).sort_by do |i|
      i.to_s.match(r).captures.map(&:size) << i
    end
  end

  # capture not only methods, but also constants
  def self.const_missing c

    # search the cache for the missing constant/class combination
    #  or assign it with the best matching method name
    t = @@golf_hash[ [c,self.class] ] ||= matching_methods(c,constants)[0]

    # return the constant if it exist
    t and return const_get(t)

    # or raise the error
    raise NameError, "uninitialized constant #{c}", caller(1)
  end

  # get the shortest shortcut for a callable method
  def shortest_abbreviation(s='', m=callable_methods)
    # check if s (method_name) is capitalized
    s=s.to_s
    our_case = (?A..?Z)===s[0]

    # check if method_name is callable (and get its index in the callable method array)
    if m.index(s.to_sym)
      # begin with length 1 and try until method_name's size
      1.upto(s.size){|z|
        # try for all combinations of the method_name letters for the current length
        #  combination:  %w[a b c].combination 2 # is [["a","b"],["a","c"],["b","c"]]
        s.scan(/./).combination(z).map{|trial|

        # skip if current combination is capitalized, but out method_name not
        #  (and vice versa)
        next unless ((?A..?Z)===trial[0]) == our_case

        # join the combination and return it if it is the best matching method name
        trial*=''
        return trial if matching_methods(trial,m)[0].to_s==s
      }}

    # method_name not found
    else
      nil
    end
  end

  # get *all* callable methods of an Object
  def callable_methods
    self.class == Object ? methods + private_methods : methods
  end

  # ...
end