> I think we somehow took a wrong path when OO got embraced as wholly as it did ...

Bizarro · on March 17, 2018

Yep, because it's forcing you to do awkward hierarchies that most people get wrong. And even if you get it right, it tends to be awkward a lot of the time.

I was always a big fan of CLOS (Of Common Lisp) and Dylan (poor Dylan).

By the way, the spiritual successor to Dylan (IMHO) Stanza http://lbstanza.org/ doesn't seem to get much love.

ZephyrP · on March 17, 2018

Multiple (virtual) dispatch is a central feature of C++ (and I suspect Java as well).

groovy2shoes · on March 17, 2018

Virtual dispatch in C++ and Java is dynamic dispatch, but it is singly so rather than multiply so as found in CLOS, Dylan, Julia, etc. If you want multiple dispatch in C++ and its kin, you need to jump through hoops with visitor patterns and such.

foota · on March 17, 2018

The difference confused me for a bit, but consider the following:

  Print(Vehicle v){
    print("vehicle");
  }

  Print(Car c){
    print("car");
  }

  Print(Boat b){
    print("boat");
  }

  Vehicle test = Boat();
  
  Print(test);

In a language with multi dispatch I believe this prints boat, whereas with single dispatch it prints vehicle.

lmitchell · on March 17, 2018

Not quite. Multiple dispatch (as mentioned in sibling comments) is basically 'virtual on both object and argument types', so like:

  class Vehicle {
    virtual void Collide(Vehicle other);
  }

  class Car {
    void Collide(Truck other) { /* hit a truck */ }
    void Collide(Car other) { /* hit another car */ }
  }

  class Truck {
    void Collide(Truck other) { /* hit another truck */ }
    void Collide(Car other) { /* hit a car */ }
  }

  Vehicle c = Car();
  Vehicle t = Truck();

  c.Collide(t); // with multiple dispatch, calls Car::Collide(Truck)

seanmcdirmid · on March 17, 2018

You are using static overloading on the argument rather than dynamic dispatch. If the static type of truck is obscured to a super class, your behavior won't be as expected. In general, overloading shouldn't be used as a replacement for dynamic dispatch, rather it should be used to accommodate multiple incompatible types (e.g. foo(X) and foo(Y) but never foo(Z) if X <: Z and Y <: Z unless foo(Z) maintains the behavior of foo(X) and foo(Y) given an x or a y under subsumption).

Multiple dispatch is typically meant to be purely dynamic in meaning, as wiki puts it:

> Multiple dispatch or multimethods is a feature of some programming languages in which a function or method can be dynamically dispatched based on the run-time (dynamic) type or, in the more general case some other attribute, of more than one of its arguments.[1]

(https://en.wikipedia.org/wiki/Multiple_dispatch)

yorwba · on March 17, 2018

The static type of both c and t is Vehicle, but by dynamic multiple dispatch Car::Collide(Truck) is selected. That's not how C++ works, but the example was exactly about illustrating how C++ doesn't work.

barrkel · on March 17, 2018

Multiple dispatch is overriding virtual member functions on argument types, not just receiver type.

Overloading and overriding are duals; the former is statically determined, the latter dynamically determined. Just like you can overload on the full argument list, multiple dispatch lets you override on the full argument list. This lets you do things like implement the visitor pattern without double dispatch. And C++ doesn't support it without libraries.

zenhack · on March 17, 2018

Unless it's via some new-fangled C++ feature I haven't heard of yet, I'm pretty sure C++ doesn't have multiple dispatch. Can you elaborate on what you're referring to?

bstamour · on March 17, 2018

C++ doesn't have multiple dispatch. I think the OP was referring to multiple inheritance, which is not the same thing.

ZephyrP · on March 17, 2018

I was thinking of runtime single dispatch with compile-time type of the arguments to that function.

bstamour · on March 17, 2018

So virtual function overloading?

Can you give a small bit of sample code to demonstrate what you mean?

ZephyrP · on March 18, 2018

just ordinary virtual function that discriminates upon arguments (at compile-time).

zenhack · on March 18, 2018

Yeah, multiple dispatch implies more than one argument involved in the dispatch decision at runtime. So that's not the same thing.