single-dispatch

I'm trying to understand what single and multiple dispatch are, exactly. I just read this: http://en.wikipedia.org/wiki/Multiple_dispatch And from that definition is seems to me that C# and VB.Net are multiple-dispatch, even though the choice of which overload to call is made at compile-time. Am I correct here, or am I missing something? Thanks! OK, I understood the subtle difference where function overloading is different from multiple-dispatch. Basically, the difference is whether which method to call is chosen at run-time or compile-time. Now, I know everybody's said this, but without a

I read in a book that "you can't create traditional 'classes' in julia with single-dispatch-style methods like obj.myfunc() " ... and I thought that sounded more like a challenge than a fact. So here's my JavaClass type with public / private fields and methods just for the sheer shock and horror factor of having something ugly like this in Julia, after all the trouble the devs have gone to to avoid it: type JavaClass # Public fields name::String # Public methods getName::Function setName::Function getX::Function getY::Function setX::Function setY::Function # Primary Constructor - "through Whom

Python 3.4 added the ability to define function overloading with static methods. This is essentially the example from the documentation: from functools import singledispatch class TestClass(object): @singledispatch def test_method(arg, verbose=False): if verbose: print("Let me just say,", end=" ") print(arg) @test_method.register(int) def _(arg): print("Strength in numbers, eh?", end=" ") print(arg) @test_method.register(list) def _(arg): print("Enumerate this:") for i, elem in enumerate(arg): print(i, elem) if __name__ == '__main__': TestClass.test_method(55555) TestClass.test_method([33, 22,