Re: Multi-method

Jean-Marc Bourguet wrote:
> Is there such a technique allowing to dispatch on the type of several
> parameters
> - in time proportionnal to the number of dispatching parameter
> - in such a way that independant compilation is possible.


Base technique: Do a cascading dispatch, using a vtable for every
dispatching parameter.
I.e. for
      foo(x, y)
you'll have a dispatch table for x, then, for every entry in that table,
another dispatch table for y.
This will give a polynomial growth in the number of parameters, but you
can exploit that programmers try to arrange stuff so that the actual
number of routines is linear. IOW arrange your table compression scheme
so that it mimicks the ways programmers organize their multiple dispatch.


Note that independent compilation and multiple dispatch are at odds
conceptually. If you have
      function foo(Animal, Animal)
and
      function foo(Animal, Cow)
      function foo(Cow, Animal)
a call with a run-time type combination giving
      foo(Cow, Cow)
will be ambiguous. If all these code snippets are in different modules,
you'll need a link-time check anyway (IOW you don't have separate
compilation anymore, unless you write your own linker - in which case
the linker could in principle do anything that's traditionally
associated with the compiler's tasks, such as dataflow analysis to
determine which calls could go directly to a routine instead of through
a vtable, with subsequent inlining - that's one of the most important
optimizations for OO languages, and you can't do it before link time ina
multi-dispatch language).




Just my 2c.
Joachim

Return to the comp.compilers page.
Search the comp.compilers archives again.