On Sep 3, 12:26 am, Robert Klemme <shortcut... / googlemail.com> wrote:
> On 02.09.2007 14:48, pongba wrote:
>
>
>
> > Matz once replied on Cedric's blog that
>
> > I am not against "method overloading", but it very easily leads to
> > optional static typing in the language, which changes the language
> > very drastically, since you need to specify "type" to overload
> > arguments. Without well-thought design, it can "destroy" the language
> > and its culture. I have not yet got that well-thought design of method
> > overloading.
>
> > This is a very general argument, what concerns me is that if, for
> > instance, we have Matrix and Graph, and we'd like to be able to draw
> > both of them (the two 'draw's would have the same semantic but
> > different implementation logic), how 're we going to be able to
> > overload draw on Matrix and Graph like what we do in C++ or Java:
>
> > void draw(Matrix);
> > void draw(Graph);
>
> > One might argue that 'draw' should actually be a member function of
> > Matrix and Graph so the problem is moot. But then there's two more
> > problems:
>
> > 1. if we can't modify Matrix or Graph, and writing a non-member 'draw'
> > is the only thing we can do to extend the interface of them, and we
> > actually can write 'draw' in terms of the public interface of Matrix
> > and Graph.
>
> Somehow I miss something in this sentence.  You write "if..." but I do
> not see any "then".  So what exactly are you trying to say / ask here?
>
> You can usually change classes.  Also, there are numerous ways to
> implement dispatching on argument types, for example this one:
>
> class Drawer
>    @draw = Hash.new(lambda {|x| raise "Cannot draw #{x.inspect}"}).
>      merge(Matrix => lambda {|x| puts "Drawing Matrix #{x.inspect}"},
>        Graph => lambda {|x| puts "Drawing Graph #{x.inspect}"})
>
>    def draw(obj)
>      self.class.instance_eval {@draw}[obj.class][obj]
>    end
> end
>
> irb(main):012:0> Drawer.new.draw(Matrix.new)
> Drawing Matrix #<Matrix:0x7ff62e38>
> => nil
> irb(main):013:0> Drawer.new.draw(Graph.new)
> Drawing Graph #<Graph:0x7ff5fe54>
> => nil
> irb(main):014:0> Drawer.new.draw("foo")
> RuntimeError: Cannot draw "foo"
>          from (irb):4
>          from (irb):9:in `[]'
>          from (irb):9:in `draw'
>          from (irb):14
>          from :0
> irb(main):015:0>
>
> There are others, you can find some of them in the Ruby Garden Wiki
> (which seems to be unavailable ATM).
>
> > 2. if '1' doesn't matter (because in ruby we actually can add new
> > methods to an existing class), then can you please give another more
> > qualified example?
>
> Example for what?
>
> Kind regards
>
>         robert

Sorry, I meant 'what if' :-)
There're lots of ways to implement them, among which the more
automatic one is the StrongType module. But they all rely on explicit
dynamic type-switch, which isn't as clear as the "traditional"
overloading mechanism(i.e. draw(Matrix); draw(Graph); ).
I don't whether there're other problem related to this approach since
I'm a ruby-newbie.