$arr = array('Hello', 'world'); $arr();

That can lead to quite a bit of simplifications in code where you now have to check for is_array/is_callable/instanceof Closure and such. I like it.

On Sun, 5 Jun 2011 12:52:45 -0300
Felipe Pena felipensp@gmail.com wrote:

Hi all,
Reading our bug tracker I noticed a good feature request [1] from 2009 which
points to an interesting feature that I think makes sense for us, since we
are now working with $f() using objects and strings, and the array('class',
'method') is an old known for call_user_func()-like functions.

So, I wrote a patch [2] that allow such behavior to be consistent with
arrays. See some examples:

class Hello {
public function world($x) {
echo "Hello, $x\n"; return $this;
}
}

$f = array('Hello','world');
var_dump($f('you'));

$f = array(new Hello, 'foo');
$f();

All such calls match with the call_user_func() behavior related to magic
methods, static & non-static methods.

The array to be a valid callback should be a 2-element array, and it must be
for the first element object/string and for the second string only. (just
like our zend_is_callable() check and opcodes related to init call)

Any thoughts?

[1] - http://bugs.php.net/bug.php?id=47160
[2] - http://felipe.ath.cx/diff/fr47160.diff
phpt: http://felipe.ath.cx/diff/fr47160.phpt

--
Regards,
Felipe Pena

+1, very good job!

Hi all,
Reading our bug tracker I noticed a good feature request [1] from 2009 which
points to an interesting feature that I think makes sense for us, since we
are now working with $f() using objects and strings, and the array('class',
'method') is an old known for call_user_func()-like functions.

So, I wrote a patch [2] that allow such behavior to be consistent with
arrays. See some examples:

class Hello {
  public function world($x) {
     echo "Hello, $x\n"; return $this;
  }
}

$f = array('Hello','world');
var_dump($f('you'));

$f = array(new Hello, 'foo');
$f();

All such calls match with the call_user_func() behavior related to magic
methods, static & non-static methods.

The array to be a valid callback should be a 2-element array, and it must be
for the first element object/string and for the second string only. (just
like our zend_is_callable() check and opcodes related to init call)

Any thoughts?

[1] - http://bugs.php.net/bug.php?id=47160
[2] - http://felipe.ath.cx/diff/fr47160.diff
phpt: http://felipe.ath.cx/diff/fr47160.phpt

--
Regards,
Felipe Pena

--
Pierre

@pierrejoye | http://blog.thepimp.net | http://www.libgd.org

Hi all,
Reading our bug tracker I noticed a good feature request [1] from 2009
which
points to an interesting feature that I think makes sense for us, since we
are now working with $f() using objects and strings, and the array('class',
'method') is an old known for call_user_func()-like functions.

So, I wrote a patch [2] that allow such behavior to be consistent with
arrays. See some examples:

class Hello {
public function world($x) {
echo "Hello, $x\n"; return $this;
}
}

$f = array('Hello','world');
var_dump($f('you'));

$f = array(new Hello, 'foo');
$f();

All such calls match with the call_user_func() behavior related to magic
methods, static & non-static methods.

The array to be a valid callback should be a 2-element array, and it must
be
for the first element object/string and for the second string only. (just
like our zend_is_callable() check and opcodes related to init call)

Any thoughts?

[1] - http://bugs.php.net/bug.php?id=47160
[2] - http://felipe.ath.cx/diff/fr47160.diff
phpt: http://felipe.ath.cx/diff/fr47160.phpt

--
Regards,
Felipe Pena

+1

Tyrael

Hi!

So, I wrote a patch [2] that allow such behavior to be consistent with
arrays. See some examples:

Looks good. Only question I have is that we seem to have that code
(calling a function based on variable) in two places instead of one, I
wonder if it's necessary and if we could unify them...

Stanislav Malyshev, Software Architect
SugarCRM: http://www.sugarcrm.com/
(408)454-6900 ext. 227

-----Original Message-----
class Hello {
public function world($x) {
echo "Hello, $x\n"; return $this;
}
}

$f = array(new Hello, 'foo');
$f();

Am I the only one who doesn't understand what this one is supposed to do..?

Zeev

Hi,

recently I was surprised this didn't work. so +1 from me.

johannes

Hi all,
Reading our bug tracker I noticed a good feature request [1] from 2009 which
points to an interesting feature that I think makes sense for us, since we
are now working with $f() using objects and strings, and the array('class',
'method') is an old known for call_user_func()-like functions.

So, I wrote a patch [2] that allow such behavior to be consistent with
arrays. See some examples:

class Hello {
public function world($x) {
echo "Hello, $x\n"; return $this;
}
}

$f = array('Hello','world');
var_dump($f('you'));

$f = array(new Hello, 'foo');
$f();

All such calls match with the call_user_func() behavior related to magic
methods, static & non-static methods.

The array to be a valid callback should be a 2-element array, and it must be
for the first element object/string and for the second string only. (just
like our zend_is_callable() check and opcodes related to init call)

Any thoughts?

[1] - http://bugs.php.net/bug.php?id=47160
[2] - http://felipe.ath.cx/diff/fr47160.diff
phpt: http://felipe.ath.cx/diff/fr47160.phpt

Hi Felipe,

I like the idea. It makes indirect method calls less expensive.

I would add a hint to specializer, to eliminate small overhead for
regular function calls.

} else if (OP1_TYPE != IS_CONST &&
EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {

Thanks. Dmitry.

Hi all,
Reading our bug tracker I noticed a good feature request [1] from 2009 which
points to an interesting feature that I think makes sense for us, since we
are now working with $f() using objects and strings, and the array('class',
'method') is an old known for call_user_func()-like functions.

So, I wrote a patch [2] that allow such behavior to be consistent with
arrays. See some examples:

class Hello {
public function world($x) {
echo "Hello, $x\n"; return $this;
}
}

$f = array('Hello','world');
var_dump($f('you'));

$f = array(new Hello, 'foo');
$f();

All such calls match with the call_user_func() behavior related to magic
methods, static& non-static methods.

The array to be a valid callback should be a 2-element array, and it must be
for the first element object/string and for the second string only. (just
like our zend_is_callable() check and opcodes related to init call)

Any thoughts?

[1] - http://bugs.php.net/bug.php?id=47160
[2] - http://felipe.ath.cx/diff/fr47160.diff
phpt: http://felipe.ath.cx/diff/fr47160.phpt

<3

David

Hi all,
Reading our bug tracker I noticed a good feature request [1] from 2009 which
points to an interesting feature that I think makes sense for us, since we
are now working with $f() using objects and strings, and the array('class',
'method') is an old known for call_user_func()-like functions.

So, I wrote a patch [2] that allow such behavior to be consistent with
arrays. See some examples:

class Hello {
public function world($x) {
echo "Hello, $x\n"; return $this;
}
}

$f = array('Hello','world');
var_dump($f('you'));

$f = array(new Hello, 'foo');
$f();

All such calls match with the call_user_func() behavior related to magic
methods, static & non-static methods.

The array to be a valid callback should be a 2-element array, and it must be
for the first element object/string and for the second string only. (just
like our zend_is_callable() check and opcodes related to init call)

Any thoughts?

[1] - http://bugs.php.net/bug.php?id=47160
[2] - http://felipe.ath.cx/diff/fr47160.diff
phpt: http://felipe.ath.cx/diff/fr47160.phpt

--
Regards,
Felipe Pena

Hi all,
Reading our bug tracker I noticed a good feature request [1] from 2009 which
points to an interesting feature that I think makes sense for us, since we
are now working with $f() using objects and strings, and the array('class',
'method') is an old known for call_user_func()-like functions.

I like it.

I also think we should implement "callable" typehint.
A lot of framworks are now adopting Closure as a typehint for that,
which is annoying due to the fact you have to wrap anything else in a
closure just to pass that typehint.

Essentially the callable typehint would be the same as is_callable($arg, true);

That means I can pass in any string with a function name, an array
(with class+methodname), and a closure.

-Hannes

Reading our bug tracker I noticed a good feature request [1] from 2009
which points to an interesting feature that I think makes sense for
us, since we are now working with $f() using objects and strings, and
the array('class', 'method') is an old known for call_user_func()-like
functions.

So, I wrote a patch [2] that allow such behavior to be consistent with
arrays. See some examples:

class Hello {
public function world($x) {
echo "Hello, $x\n"; return $this;
}
}

$f = array('Hello','world');
var_dump($f('you'));

$f = array(new Hello, 'foo');
$f();

All such calls match with the call_user_func() behavior related to
magic methods, static & non-static methods.

The array to be a valid callback should be a 2-element array, and it
must be for the first element object/string and for the second string
only. (just like our zend_is_callable() check and opcodes related to
init call)

Any thoughts?

Huge +1 from me -- having to do constructs like the following have been
a huge headache for me:

if (is_callable($callback)) {
    if (is_object($callback) || is_string($callback)) {
        return $callback($arg);
    }

    return call_user_func($callback, $arg)
}

This would simplify that tremendously:

if (is_callable($callback)) {
    return $callback($arg);
}

--
Matthew Weier O'Phinney
Project Lead | matthew@zend.com
Zend Framework | http://framework.zend.com/
PGP key: http://framework.zend.com/zf-matthew-pgp-key.asc

Hi all,
Reading our bug tracker I noticed a good feature request [1] from 2009 which
points to an interesting feature that I think makes sense for us, since we
are now working with $f() using objects and strings, and the array('class',
'method') is an old known for call_user_func()-like functions.

[...]

Any thoughts?

Felipe,

How about collating the emails and examples and creating an RFC for it?

Chris

--
Email: christopher.jones@oracle.com
Tel: +1 650 506 8630
Blog: http://blogs.oracle.com/opal/