I think Function Overloading in C++ is very meaningful. And
currently the case for me is: How I can make use of method/
function overloading in Ruby?
Besides you might tell me Ruby is designed to exclude method
overloading, can you tell me sth more for the Overloading purpose?
This is a common question. The short answer is that function
overloading is based on knowing the static types of the actual
arguments to a method and in Ruby the entire notion of 'static types
of the actual arguments' is pretty much non-existent.
The longer answer is that for Ruby to provide some sort of
overloading a new syntax for method definition would be required and
then the method lookup algorithm would have to be updated. Warning:
pseudo code ahead.
def do_something( a as Array)
#...
end
def do_something( a as Hash)
#...
end
def do_something(a)
#...
end
do_something([1,2]) # as Array version
do_something({1,2}) # as Hash version
do_something(1) # unspecified version
This would really complicate the method dispatch mechanism as the
class of every argument would have to be examined *each* time any
method is called. I used literal arrays, hashes, and integers in the
example but in general they would
just be arbitrary expressions. In any case some sort of algorithm
would have to be run each time a method was called. This would
drastically increase method call overhead in Ruby.
This is a lot of work when the programmer can achieve the same goal
with the existing language quite concisely:
def do_something(a)
case a
when Array
# work with array
when Hash
# work with hash
else
# assume integer
end
end
Same effect, no language changes, and the algorithm is explicit and
flexible rather than implicit and rigid.
There is yet another approach. Define different methods for
different arguments:
def do_something_with_array(a)
# assume a is an array
end
def do_something_with_hash(h)
# assume h is a hash
end
def do_something_with_int(i)
# assume i is an int
end
do_something_with_array([1,2])
do_something_with_hash({1,2})
do_something_with_int(3)
This is of course doing by hand what static overloading does
'automatically'. In Ruby you still end up doing regular method
lookup for do_something_with_array and company.
The bottom line is that Ruby already provides several methods to deal
with complex argument lists. Adding some sort of class declarations
to formal arguments goes against the grain of Ruby's design with
little if any benefit to outweigh
the added complexity.
P.S. I seem to remember that there was a considerable amount of
criticism in the C++ community about static function overloading vs.
dynamic dispatch. I'm not sure what the situation is today.
Gary Wright
