Duck typing alows true polymorfisim

(Eric Mahurin) #1

The title of this thread was almost like a post I made a year or so ago:

What you wrote still isn't as generic as it could be. This can handle more
than just numerics:

def sum enum
  enum.inject{ |total,current| total+current }

enum can be anything that responds to inject (likely an Enumerable) with a
block that takes 2 arguments where the first responds to +. If enum is an
Enumerable, this means the first element responds to + which returns
something that also continues to respond to +.

Now you can do this:

three = sum([1,2])
hello_world = sum(["hello","world"])
concatenated_lines = sum(anIO)

The simpler you can make the description of the duck-typing of a method, the
more generic and flexible it will be. By adding a 0 argument to inject, you
made the duck-typing a little more complex and stiffled it by only allowing
elments that can be added to 0.


On 8/25/06, <> wrote:

lets say you want a generic numerical algorithom like sum


def sum lst
  lst.inject(0){|total,current| total*current}

Java // i dont know if there is a numeric super class for numbers

class Sum{
  public static int sum(int[] lst){
    int total = 0;
    for(int current : lst){
    return total;
  // repeat for all other number types