Morning internals,
While discussing some of the details of the first class callable RFC, it
became apparent that fake closures (created by Closure::fromCallable) are
not currently comparable in a useful way.
Although this is not directly related to the first class callable feature,
it's likely that the proliferation of this kind of code will follow, so now
seems like a good time to fix the problem.
https://github.com/php/php-src/pull/7223
Any objections to merging that in master ?
Cheers
Joe
Morning internals,
While discussing some of the details of the first class callable RFC, it
became apparent that fake closures (created by Closure::fromCallable) are
not currently comparable in a useful way.Although this is not directly related to the first class callable feature,
it's likely that the proliferation of this kind of code will follow, so now
seems like a good time to fix the problem.https://github.com/php/php-src/pull/7223
Any objections to merging that in master ?
To clarify: What this implements is that
$strlen1 = Closure::fromCallable('strlen');
$strlen2 = Closure::fromCallable('strlen');
var_dump($strlen1 == $strlen2);
// bool(true) with this patch, previously bool(false)
The same would also apply to the first-class callable syntax, i.e. after
this patch strlen(...) == strlen(...) would return true.
Regards,
Nikita
Morning internals,
While discussing some of the details of the first class callable RFC, it
became apparent that fake closures (created by Closure::fromCallable) are
not currently comparable in a useful way.Although this is not directly related to the first class callable feature,
it's likely that the proliferation of this kind of code will follow, so now
seems like a good time to fix the problem.https://github.com/php/php-src/pull/7223
Any objections to merging that in master ?
To clarify: What this implements is that
$strlen1 = Closure::fromCallable('strlen');
$strlen2 = Closure::fromCallable('strlen');
var_dump($strlen1 == $strlen2);
// bool(true) with this patch, previously bool(false)The same would also apply to the first-class callable syntax, i.e. after
this patch strlen(...) == strlen(...) would return true.Regards,
Nikita
Seems reasonable on the surface. My main question is how far that extends. Does it work only for Closure::fromCallable()/FCC syntax? What if the argument is not a string? How deep does the comparison go for, say, objects and methods?
class C {
public function beep(string $a): string { return $a . 'beep'; }
}
$c1 = new C();
$c2 = new C();
$strlen1 = Closure::fromCallable([$c1, 'beep']);
$strlen1b = Closure::fromCallable([$c1, 'beep']);
$strlen2 = Closure::fromCallable([$c2, 'beep']);
// What do these do?
var_dump($strlen1 == $strlen1b);
var_dump($strlen1 == $strlen2);
--Larry Garfield
The test included is quite comprehensive.
Cheers
Joe
Morning internals,
While discussing some of the details of the first class callable RFC,
it
became apparent that fake closures (created by Closure::fromCallable)
are
not currently comparable in a useful way.Although this is not directly related to the first class callable
feature,
it's likely that the proliferation of this kind of code will follow,
so now
seems like a good time to fix the problem.https://github.com/php/php-src/pull/7223
Any objections to merging that in master ?
To clarify: What this implements is that
$strlen1 = Closure::fromCallable('strlen');
$strlen2 = Closure::fromCallable('strlen');
var_dump($strlen1 == $strlen2);
// bool(true) with this patch, previously bool(false)The same would also apply to the first-class callable syntax, i.e. after
this patch strlen(...) == strlen(...) would return true.Regards,
NikitaSeems reasonable on the surface. My main question is how far that
extends. Does it work only for Closure::fromCallable()/FCC syntax? What
if the argument is not a string? How deep does the comparison go for, say,
objects and methods?class C {
public function beep(string $a): string { return $a . 'beep'; }
}$c1 = new C();
$c2 = new C();$strlen1 = Closure::fromCallable([$c1, 'beep']);
$strlen1b = Closure::fromCallable([$c1, 'beep']);
$strlen2 = Closure::fromCallable([$c2, 'beep']);// What do these do?
var_dump($strlen1 == $strlen1b);
var_dump($strlen1 == $strlen2);--Larry Garfield
--
To unsubscribe, visit: https://www.php.net/unsub.php
Le 09/07/2021 à 10:45, Joe Watkins a écrit :
Morning internals,
While discussing some of the details of the first class callable RFC, it
became apparent that fake closures (created by Closure::fromCallable) are
not currently comparable in a useful way.Although this is not directly related to the first class callable feature,
it's likely that the proliferation of this kind of code will follow, so now
seems like a good time to fix the problem.https://github.com/php/php-src/pull/7223
Any objections to merging that in master ?
Cheers
Joe
I don't see where I would actually compare callables, and I'm not an
engine maintainer, but from my point of view, this patch makes sense.
Regards,
--
Pierre
Le 09/07/2021 à 10:45, Joe Watkins a écrit :
Morning internals,
While discussing some of the details of the first class callable RFC, it
became apparent that fake closures (created by Closure::fromCallable) are
not currently comparable in a useful way.Although this is not directly related to the first class callable
feature,
it's likely that the proliferation of this kind of code will follow, so
now
seems like a good time to fix the problem.https://github.com/php/php-src/pull/7223
Any objections to merging that in master ?
Cheers
JoeI don't see where I would actually compare callables, and I'm not an
engine maintainer, but from my point of view, this patch makes sense.
I'm also not sure where this would be actually useful (though I'm okay with
including it, as the functionality itself seems sensible). As Patrick
Allaert suggested this, maybe he can comment on some use cases.
Regards,
Nikita
Le lun. 12 juil. 2021 à 09:51, Nikita Popov nikita.ppv@gmail.com a écrit :
I'm also not sure where this would be actually useful (though I'm okay
with including it, as the functionality itself seems sensible). As Patrick
Allaert suggested this, maybe he can comment on some use cases.
I can't really see a useful case either, it was more rhetorical.
For a feeling I can't explain much, I was caring less about:
Closure::fromCallable('strlen') == Closure::fromCallable('strlen')
than:
strlen(...) == strlen(...)
I know they are technically identical, but I see the first construct as a
function call while the second one looks more like a language construct
"referencing" (sorry for not using a more adequate verb) the same function.
Anyway, I don't have a strong opinion on it.
Regards,
Patrick
Le lun. 12 juil. 2021 à 11:42, Patrick ALLAERT patrickallaert@php.net a
écrit :
Le lun. 12 juil. 2021 à 09:51, Nikita Popov nikita.ppv@gmail.com a
écrit :I'm also not sure where this would be actually useful (though I'm okay
with including it, as the functionality itself seems sensible). As Patrick
Allaert suggested this, maybe he can comment on some use cases.I can't really see a useful case either, it was more rhetorical.
Maybe:
if ($f == unlink(...)) {
logging("Deleting $x");
}
$f($x);