multiple-dispatch

I was wondering if there was a way to use Symbols for multiple dispatch, but also include a "catch-all method". i.e. something like function dispatchtest{alg<:Symbol}(T::Type{Val{alg}}) println("This is the generic dispatch. The algorithm is $alg") end function dispatchtest(T::Type{Val{:Euler}}) println("This is for the Euler algorithm!") end The second one works and matches what's in the manual, I'm just wondering how you get the first one to work. You can do it this way: julia> function dispatchtest{alg}(::Type{Val{alg}}) println("This is the generic dispatch. The algorithm is $alg") end

The problem of single dispatch is mostly familiar to people engaged in coding with statically typed languages like Java and C#. The basic idea is: While the runtime polymorphism allows us to dispatch to the right method call according to the type (runtime type) of receiver , for example: IAnimal mything = new Cat(); mything.chop(); The method call will be performed according to the runtime type of mything , namely Cat . This is the single dispatch capability (which is present in Java/C#). Now, if you need to dispatch not only on the runtime type of receiver, but on the types of (multiple)

I wondered if Java7's new invokedynamic bytecode instruction could be used to implement multiple dispatch for the Java language. Would the new API under java.lang.invoke be helpful to perform such a thing? The scenario I was thinking about looked as follows. (This looks like an application case for the visitor design pattern, but there may be reasons that this is not a viable option.) class A {} class A1 extends A {} class A2 extends A {} class SomeHandler { private void doHandle(A1 a1) { ... } private void doHandle(A2 a2) { ... } private void doHandle(A a) { ... } public void handle(A a) {

...or are they the same thing? I notice that each has its own Wikipedia entry: Polymorphism , Multiple Dispatch , but I'm having trouble seeing how the concepts differ. Edit: And how does Overloading fit into all this? Polymorphism is the facility that allows a language/program to make decisions during runtime on which method to invoke based on the types of the parameters sent to that method. The number of parameters used by the language/runtime determines the 'type' of polymorphism supported by a language. Single dispatch is a type of polymorphism where only one parameter is used (the

Can someone think of a good way to implement multiple dispatch with something like the Object::foo overloads below? class A { public: virtual void accept (Visitor&) = 0; }; class B : public A { virtual void accept (Visitor&) override; }; class C : public A { virtual void accept (Visitor&) override; }; class D : public A { virtual void accept (Visitor&) override; }; class Object { public: virtual double foo (A*, A*) { std::cout << "Object::foo A,A\n"; return 3.14; } virtual double foo (B*, B*) { std::cout << "Object::foo B,B\n"; return 3.14; } virtual double foo (B*, C*) { std::cout << "Object:

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