Ruby MultiMethods -

Supports general dispatch using clojure style multi-methods.  This can be used
for anything from basic function overloading to a function dispatch based on arbitrary complexity.

The basic syntax starts off with something like this:

class Square

  def chicken1 *args
    return :chicken1
  end

  def self.chicken2 *args
    return :chicken2
  end

  defmulti :chicken, lambda { |args| args[1].class }
  defmethod :chicken, Fixnum, instance_method(:chicken1)
  defmethod :chicken, String, method(:chicken2)
  defmethod :chicken, :default, lambda { puts 'in chicken default' }

end

Here, we are defining a new instance, multi_method called 'chicken' with a general
dispatch fn that examines the class of the first argument.  Any subsequent calls
to our_square.chicken() will dispatch to the first defmethod encountered which matches this
criteria.  

Eg. some_instance_of_square.chicken(3)     will trigger a call to an instance level method called chicken1
    some_instance_of_square.chicken("fun') will trigger a call to a class level method called chicken2

Note that to parameters are passed to both the general dispatch fn and the
individual defmethod using the varargs syntax.

The last defmethod is marked as 'default' and will be called if no previously
declared defmethods match. If no default exists and no other defmethod matches,
an exception will be thrown. As you can see, the method which is ultimately called can be an
instance method, class method or even a lambda.  

If you just need a one-shot dispatch -perhaps to avoid an ugly conditional- and
would prefer to avoid permanently polluting the class namespace, try someting
like this:

  class Square

    def tuna1 *args
      return :tuna1
    end

    def self.tuna2 *args
      return :tuna2
    end

    def tuna_gateway *args
      defmulti_local do  
        defmulti :tuna, lambda{ |args| args[0] + args[1] }
        defmethod :tuna, 2, self.class.instance_method(:tuna1)
        defmethod :tuna, 4, self.class.method(:tuna2)
        defmethod :tuna, :default, lambda{ |args| @default_fn = :tuna_default }

        tuna(*args) 
      end
    end

  end
  
The call to the tuna method within tuna_gateway will dispatch by adding it's
first two arguments.  If they sum to 2, the tuna1 instance method is called.  If
they sum to 4, the tuna2 class method is called. If they sum to neither 2 or 4,
the default lamba will be called.  This just works like above with the only
distinction being that  the tuna multimethod exists only inside of the defmulti_local
block.  Once execution leaves said block, all the nescessary class
meta-programming is unwound leaving no permanent trace of the defmulti.


Finally, you can optionally provide a series of dispatch functions for each
defmulti instead of a single 'general dispatch fn'.  Check this out:

  defmulti :chicken
  defmethod :chicken, lambda{ |args| args[0].class == Fixnum && args[1].class == Fixnum }, instance_method(:chicken1)
  defmethod :chicken, lambda{ |args| args[0].class == String && args[1].class  == String }, method(:chicken2)
  defmethod :chicken, :default, lambda { puts 'in chicken default' }

Notice that no generald dispatch mechanism is provided by the defmulti.
Instead, each defmethod declares its own predicate.  The first defmethod who's
predicate returns true becomes the target of the dispatch.
Eg. our_square.chicken( 'red', 'blue') would dispatch to the chicken2 class
method because its first two parameters are Strings.