Multiple dispatch

Question

Hi. I understand how multiple dispatch works when you want to base the method called on the type of the parameter. However, I don't understand what you need to do if you'd like to base it off the type of two parameters.
For example, I have a class Hierarchy like the following:
public abstract class A
    String Text;
public class B extends A
    //I've ommitted some things for brevity.  It's just important that B is a subclass of A
public calss C extends A
    int intValue;
public class D extends A
    //What i'd like is to somehow be able to do the following:
    apply( B, C )
        //some stuff
    apply( B, B )
        //some other stuff
    //this could go on
}Can someone point me in the right direction? I've looked at the Visitor pattern and a few sites about multiple dispatch, but I can't figure out how to apply that to this particular situation.

Answer 1

If you have control over the types A-D, then you can either use double dispatch, which can require N^2 methods, or use your own method selection by a tag value. Tag values are sometimes faster, and don't necessarily require the class hierarchy is closed. Another advantage of tags is that you can do more intelligent dispatch, as you might for arithmetic type coercion.
External dispatch means don't have to pollute the classes with double dispatch methods, and makes it easier to do have more than one doubly dispatched method in a hierarchy:
// internal, class A and B extend Base
class A extends Base {
  int foo (Base arg1) { return b.accept_foo(this); }
  int bar (Base arg1) { return b.accept_bar(this); }
  int accept_foo (A arg1) { // foo A,A }
  int accept_foo (B arg1) { // foo A,B }
  int accept_bar (A arg1) { // foo A,A }
  int accept_bar (B arg1) { // foo A,B }
// class B is symmetric
// external
class A extends Base {
  public <T> accept (Selector<T> selector) { return selector.apply(this); }
interface Selector<T> {
  T apply(A arg) ;
  T apply(B arg);
abstract class AbstractFunctor2<T> implements Selector<Selector<T>> {
  // code similar to double selectors below, second selector calls abstract functions
class Foo extends AbstractFunctor2<Integer> {
  public Integer apply (A arg0, B arg1) { ... }
}Either technique can be curried for multiple dispatch.
Where performance is not critical, or you cannot modify the classes, you can use the instanceof operator. That doesn't prevent other users extending the types, but if there's no meaningful default operation for A, you get a runtime error.
External double dispatch and typeTag example:
package dispatch;
abstract class Base {
  static interface Selector <T> {
    T apply (A a);
    T apply (B b);
    T apply (C c);
  static interface Functor1 <T>  {
    T apply (Base arg0);
  static interface Functor2 <T>  {
    T apply (Base arg0, Base arg1);
  public abstract <T> T accept (Selector<T> selector) ;
  Base (int typeTag) { this.typeTag = typeTag; }
  final int typeTag;
class A extends Base {
  A (String value) {
    super(0xA);
    this.value = value;
  final String value;
  public <T> T accept (Selector<T> selector) { return selector.apply(this); }
class B extends Base {
  B (double value) {
    super(0xB);
    this.value = value;
  final double value;
  public <T> T accept (Selector<T> selector) { return selector.apply(this); }
class C extends Base {
  C (int value) {
    super(0xC);
    this.value = value;
  int value;
  public <T> T accept (Selector<T> selector) { return selector.apply(this); }
// external double dispatch using selector
// can keep going for treble, quadruple, with increasing cost of dispatch.
class DoubleDispatchSelector1 implements Base.Selector<Base.Selector<String>>, Base.Functor2<String> {
  public String apply (Base any0, Base any1) {
    return any1.accept(any0.accept(this));
  public Base.Selector<String> apply (final A arg0) {
    return new Base.Selector<String> () {
      public String apply (A arg1) {
        return "AA";// "DoubleDispatchSelector received A(" + arg0.value + ") A(" + arg1.value + ")";
      public String apply (B arg1) {
        return "AB"; // "DoubleDispatchSelector received A(" + arg0.value + ") B(" + arg1.value + ")";
      public String apply (C arg1) {
        return "AC"; // "DoubleDispatchSelector received A(" + arg0.value + ") C(" + arg1.value + ")";
  public Base.Selector<String> apply (final B arg0){
    return new Base.Selector<String> () {
      public String apply (A arg1) {
        return "BA"; // "DoubleDispatchSelector received B(" + arg0.value + ") A(" + arg1.value + ")";
      public String apply (B arg1) {
        return "BB"; // "DoubleDispatchSelector received B(" + arg0.value + ") B(" + arg1.value + ")";
      public String apply (C arg1) {
        return "BC"; // "DoubleDispatchSelector received B(" + arg0.value + ") C(" + arg1.value + ")";
  public Base.Selector<String> apply (final C arg0){
    return new Base.Selector<String> () {
      public String apply (A arg1) {
        return "CA"; // "DoubleDispatchSelector received C(" + arg0.value + ") A(" + arg1.value + ")";
      public String apply (B arg1) {
        return "CB"; // "DoubleDispatchSelector received C(" + arg0.value + ") B(" + arg1.value + ")";
      public String apply (C arg1) {
        return "CC"; // "DoubleDispatchSelector received C(" + arg0.value + ") C(" + arg1.value + ")";
// external double dispatch using selectors, second selectors cached for single threaded use
class DoubleDispatchSelector2 implements Base.Selector<Base.Selector<String>>, Base.Functor2<String> {
  public String apply (Base any0, Base any1) {
    return any1.accept(any0.accept(this));
  public Base.Selector<String> apply (A arg0) {
    selectorA.arg0 = arg0;
    return selectorA;
  public Base.Selector<String> apply (B arg0) {
    selectorB.arg0 = arg0;
    return selectorB;
  public Base.Selector<String> apply (C arg0) {
    selectorC.arg0 = arg0;
    return selectorC;
  // partial selectors created once only
  abstract static class PartialSelector <T> implements Base.Selector<String> {
    T arg0;
  PartialSelector<A> selectorA = new PartialSelector<A> () {
    public String apply (A arg1) {
      return "AA";// "DoubleDispatchSelector received A(" + arg0.value + ") A(" + arg1.value + ")";
    public String apply (B arg1) {
      return "AB"; // "DoubleDispatchSelector received A(" + arg0.value + ") B(" + arg1.value + ")";
    public String apply (C arg1) {
      return "AC"; // "DoubleDispatchSelector received A(" + arg0.value + ") C(" + arg1.value + ")";
  PartialSelector<B> selectorB = new PartialSelector<B> () {
    public String apply (A arg1) {
      return "BA"; // "DoubleDispatchSelector received B(" + arg0.value + ") A(" + arg1.value + ")";
    public String apply (B arg1) {
      return "BB"; // "DoubleDispatchSelector received B(" + arg0.value + ") B(" + arg1.value + ")";
    public String apply (C arg1) {
      return "BC"; // "DoubleDispatchSelector received B(" + arg0.value + ") C(" + arg1.value + ")";
  PartialSelector<C> selectorC = new PartialSelector<C> () {
    public String apply (A arg1) {
      return "CA"; // "DoubleDispatchSelector received C(" + arg0.value + ") A(" + arg1.value + ")";
    public String apply (B arg1) {
      return "CB"; // "DoubleDispatchSelector received C(" + arg0.value + ") B(" + arg1.value + ")";
    public String apply (C arg1) {
      return "CC"; // "DoubleDispatchSelector received C(" + arg0.value + ") C(" + arg1.value + ")";
// external double dispatch using typeTag
class DoubleDispatchOnTypeTags implements Base.Functor2<String> {
  public String apply (Base any0, Base any1) {
    switch ( (any0.typeTag << 4) | any1.typeTag ) {
      case 0xAA: return apply((A)any0, (A)any1);
      case 0xAB: return apply((A)any0, (B)any1);
      case 0xAC: return apply((A)any0, (C)any1);
      case 0xBA: return apply((B)any0, (A)any1);
      case 0xBB: return apply((B)any0, (B)any1);
      case 0xBC: return apply((B)any0, (C)any1);
      case 0xCA: return apply((C)any0, (A)any1);
      case 0xCB: return apply((C)any0, (B)any1);
      case 0xCC: return apply((C)any0, (C)any1);
      default: throw new IllegalArgumentException();
  public String apply (A arg0, A arg1) {
    return "AA"; // "DoubleDispatchOnTypeTags received A(" + arg0.value + ") A(" + arg1.value + ")";
  public String apply (A arg0, B arg1) {
    return "AB"; // "DoubleDispatchOnTypeTags received A(" + arg0.value + ") B(" + arg1.value + ")";
  public String apply (A arg0, C arg1) {
    return "AC"; // "DoubleDispatchOnTypeTags received A(" + arg0.value + ") C(" + arg1.value + ")";
  public String apply (B arg0, A arg1) {
    return "BA"; // "DoubleDispatchOnTypeTags received B(" + arg0.value + ") A(" + arg1.value + ")";
  public String apply (B arg0, B arg1) {
    return "BB"; // "DoubleDispatchOnTypeTags received B(" + arg0.value + ") B(" + arg1.value + ")";
  public String apply (B arg0, C arg1) {
    return "BC"; // "DoubleDispatchOnTypeTags received B(" + arg0.value + ") C(" + arg1.value + ")";
  public String apply (C arg0, A arg1) {
    return "CA"; // "DoubleDispatchOnTypeTags received C(" + arg0.value + ") A(" + arg1.value + ")";
  public String apply (C arg0, B arg1) {
    return "CB"; // "DoubleDispatchOnTypeTags received C(" + arg0.value + ") B(" + arg1.value + ")";
  public String apply (C arg0, C arg1) {
    return "CC"; // "DoubleDispatchOnTypeTags received C(" + arg0.value + ") C(" + arg1.value + ")";
// test harness
public class Dispatch {
  static Base[] items0 = { new A("red"),   new B(0.1), new C(1) };
  static Base[] items1 = { new A("green"), new B(0.2), new C(2) };
  static long time (Base.Functor2 functor, int iterations) {
    final long start = System.currentTimeMillis();
    for (int iter = 0; iter < iterations; ++iter)
      for (Base item0 : items0)
        for (Base item1 : items1)
          functor.apply(item0, item1);
    final long finish = System.currentTimeMillis();
    return finish - start;
  public static void main (String ...args) throws Exception {
    int iterations = args.length > 0 ? Integer.parseInt(args[0]) : 100000;
    for (int run = 0; run < 7; ++run) {
      System.out.println("DoubleDispatchSelector1:  " + time(new DoubleDispatchSelector1(), iterations));
      System.out.println("DoubleDispatchSelector2:  " + time(new DoubleDispatchSelector2(), iterations));
      System.out.println("DoubleDispatchOnTypeTags: " + time(new DoubleDispatchOnTypeTags(), iterations));
} The reason the string concatenations are commented out is that with that amount of work, it doesn't matter which one you use. If you have a lot less work in the methods, using tags is more efficient:
DoubleDispatchSelector1:  807
DoubleDispatchSelector2:  714
DoubleDispatchOnTypeTags: 281Deeper dispatches are possible, but N^^3 or more methods are rather a lot to handle. The typeTags variant gives direct access to the individual methods, which the selectors can be adjusted to do with an extra indirection. The typeTags variant isn't checked for type safety by the compiler.
Edited by: pm_kirkham on 01-Apr-2008 21:01