[PHP-INTERNALS] Multi-Method Dispatch in PHP 5.1?

Hi George,
an integer can be represented as string or the float can be also a string and in this case
it won't work but it works for situation where the programmer knows what he is doing. Joe
average won't need the language feature thus won't need to implement it even in userland.
Sebastian's case was about classes and an object cannot be anything else but object
protected function doSomething_objectBar_objectFoo($bar, $foo) {}
public function doSomething() {
$args = func_get_args();
$method_name = __FUNCTION__;
foreach ($args as $v) {
$type = $v;
$method_name .= "_".gettype($v);
if ($type === "object") $method_name .= get_class($v);
}

Of course this is quite fast :/

Cheers,
Andrey

ah, the code has an error and I found more efficient way (for objects no need of string
compare):
<?php
class Fubar {
protected function doSomething_integer_integer_double($i1,$i2,$f) {
$a = func_get_args();var_dump(__METHOD__, $a);
}
protected function doSomething_integer_double($i,$f) {
$a = func_get_args();var_dump(__METHOD__, $a);
}
protected function doSomething_objectFubar($fub) {
$a = func_get_args();var_dump(__METHOD__, $a);
}

public function doSomething() {
$args = func_get_args();
$method_name = __FUNCTION__;
foreach ($args as $v) {
$method_name .= "_".gettype($v);
if (FALSE !==($c_name = get_class($v))) {
$method_name .= $c_name;
}
}
if (method_exists($this, $method_name)) {
return call_user_func_array(array($this, $method_name), $args);
}
}
}//class fubar

$a = new fubar();
$a->doSomething(1, 2.0);
$a->doSomething(3,4, 5.0);
$a->doSomething($a);
?>

OTOH hinting for array (internally) will be nice also.

Cheers,
Andrey

Now I do a
<?php
class barfoo extends foobar {
}

$barfoo = new barfoo();
$barfoo->doSomething($barfoo);
?>

And it won't work anymore,so I can't extend te class anymore without
changing the class foobar....

johannes

Yepp :/

Andrey

Arrays are the only complex type that we can't hint, I'd love to see
this sort of thing implemented.

John

Hello John,

Wednesday, April 21, 2004, 11:34:01 AM, you wrote:
Not completely right, we miss resources also.

Actually I think multi-method dispatching for PHP is A Bad Thing[tm].

Multi-method dispatching is necessary for statically checked, inflexible
languages without default parameters like Java. PHP has other means of
handling the most common problems this tries to solve and having two
methods of the same name is more confusing than helping IMHO.

PINJ,
- Chris

That's probably why Common Lisp, a language way more dynamic than PHP,
provides you with a complete implementation of multiple dispatch. How
exactly do you think are default parameters related to the issue, anyway?
I assume you are you aware of what dynamic dispatch is trying to solve
-- could you give an example of the 'other means' you are referring to?

Cheers,
Michael

If it makes any difference...

I would say no way to multi method dispatch. PHP, in my understanding, was
a loosely typed language, and this is straining against that very
concept. In the rare case that one needs multi-method dispatch, they can
use a format such as:

class xyz
{
public function Foo($p1 = NULL, $p2 = NULL)
{
if($p1 instanceof Bar && is_numeric($p2))
{
//do something or
return $this->Foo_Bar_Int($p1, $p2);
}
elseif($p1 instanceof OtherBar && is_null($p2))
{
//do something or
return $this->Foo_Otherbar($p1);
}
}

...

}


~Jason

Java uses multi-method dispatch to work around missing default values:
function foo($a, $some_flag) { ... }
function foo($a) { foo($a, false); }
instead of
function foo($a, $some_flag = false) { ... }
Whatever example I'd give you'd probably say it's not the relevant one.
But if you give me a use case for dynamic dispatch I show you how I'd do
it in PHP. Maybe we should take that off list though and present just
the result of our research :-)

- Chris

Yes please ;)

I don't want to prolong this discussion but I agree with the people who are
against multi-method dispatch. I don't think it makes much sense in PHP,
and I think that in the few places where someone really feels they need it,
it can be implemented in user-land. It's just going to complicate the
language for a small minority of people who feel they need this feature.

Andi

But at the same time, it would be nice to have a standardised multi-method
syntax or code - or users might develop their own weird and wacky,
inconsistent ways of implementing it. Perhaps the code submitted before
could be included in the PHP documentation, telling users on how they could
emulate this style of code?

Jevon

Well yeah, we were presumably talking about different things, hence the
question :) What you are talking about is a certain kind of "compile
time" polymorphism, where the appropriate method is chosen at compile time.

I was referring to "runtime" polymorphism, i.e. the _dispatch_ is done
on not only on one type (as with the type of the $object in an
$object->method() call), but on 2 types (as in multimethod($rect,$circle)).

I'm pretty sure that Sebastian was referring to the same mechanism, as
his example would need dispatch on 2 types, too, in order to work.

Also, I think functions which are dispatched using multiple types might
as well be global functions, because usually (?) there is no such thing
as a "first class" and "second class" dispatchee (is that a word?). For
instance, consider:

function collides(Rect $rect, Rect $circle) { ... }
function collides(Rect $rect, Circle $circle) { ... }
Naw, I didn't want to piss you of, just check whether we were dealing
with the same thing. :)
Yeah, well, you will show me the visitor pattern, which is an inferior
work-around for the lack of multiple dispatch (because it only works
well for closed sets of classes, although having it work for an open set
of classes like with dynamic dispatch on the $this 'pointer' is desirable).

For a typical example, you might want to check out the Gang of Four book
(Visitor pattern, which simulates multiple dispatch for multiple = 2) or
consider above's collides() example.

The main difference between the 'isinstance' solution someone on this
list posted is that you do not have to _modify_ a big large collides()
function, but you just keep adding the new cases.

This is like with inheritance -- you use inheritance and dynamic
dispatch on the $this 'pointer' in order to avoid series of 'isinstance'
checks.

Anyway, I'm not really sure whether dynamic dispatch is appropriate in
PHP myself, but I felt like pointing out the differences between static
and dynamic dispatch might be important. ;)

Cheers,
Michael