Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:117794
MIME-Version: 1.0
References: <627D3BCF.7020903@adviesenzo.nl> <628F685B.8090909@adviesenzo.nl>
In-Reply-To: <628F685B.8090909@adviesenzo.nl>
Date: Thu, 26 May 2022 19:23:08 +0100
Message-ID: <CA+kxMuQb3OXV-zSQBBiVXHgSt+u06MBOZgw-xqgMEJ05_i+ebw@mail.gmail.com>
To: Juliette Reinders Folmer <php-internals_nospam@adviesenzo.nl>
Cc: internals@lists.php.net
Content-Type: text/plain; charset="UTF-8"
Subject: Re: [PHP-DEV] Re: ***SPAM*** [PHP-DEV] [Discussion] Expand
 deprecation notice scope for partially supported callables
From: Danack@basereality.com (Dan Ackroyd)

Hey Julie,

On Thu, 26 May 2022 at 12:45, Juliette Reinders Folmer
<php-internals_nospam@adviesenzo.nl> wrote:
>
> I propose to open the vote on this RFC tomorrow.

Before you open the vote, please could you split the voting into two,
one for the is_callable, and one for the callable type check?

Rowan wrote in https://news-web.php.net/php.internals/117670:
> is that passing "99 red balloons" to an "int"
> parameter raised an E_NOTICE in PHP 7.x, so a "callable" parameter
> raising an E_DEPRECATED should be fine.

There's one issue.

When "99 red balloons" is coerced to an int, that is done once, and
then any further int type check will pass. For callables, it's pretty
common to pass them down a stack of code, e.g. similar to:

function foo(callable $fn, $data)
{
    $fn($data);
}

function bar(callable $fn, $data)
{
    return foo($fn);
}

function quux(callable $fn, $data)
{
    return bar($fn, $data);
}


function main(array $data)
{
    $fn = get_callable_from_input();
    if (is_callable($fn) === false) {
// give some error.
        return;
    }

    quux($data);
}

As far as I understand it, this code would give a deprecation notice
for each call level, which seems quite undesirable. Particularly if
the callable is being used in a loop.

Also, without a patch it's hard to guess what performance impact this
would have. I doubt it would be huge, but it probably wouldn't be zero
either. Performance wouldn't matter for is_callable, as that is
typically only done once per callable, but callable type checks are
done continuously.

cheers
Dan
Ack