Idea for better function callbacks (another syntactic sugar)

Den fre. 26. okt. 2018 kl. 17.43 skrev Larry Garfield larry@garfieldtech.com:

I believe the proposal for short lambas (which should get resurrected at some
point) would handle this case well enough as well as help a dozen other
things. To wit:

array_filter($names, |$x| ==> trim($x))

I still fail to see why it would be considered to have that over a
perfectly encapsulted string for a callback, using a lambda/closure is
just an extra runtime call for syntax sugar, that seems poor in my
eyes.

What would be ideal here, would be for functions to be first class
citizens in callback contexts, like in C to avoid the quotation,
however it clashes with constants. A hack you can do in userland could
be something like:

const trim = 'trim';
array_filter($names, trim);

In my opinion "ideal" here is that our symbol tables are merged, so
referring to "trim" in any context will resolve to at most one symbol,
and that we also have a short-closure syntax for times when there
isn't a perfect function to use.

In the next version of PHP I would really like to see some warnings
for when symbol names get re-used so that in the future we can merge
them with less of a BC break.

пт, 26 окт. 2018 г. в 18:57, Kalle Sommer Nielsen kalle@php.net:

Den fre. 26. okt. 2018 kl. 17.43 skrev Larry Garfield <
larry@garfieldtech.com>:

I believe the proposal for short lambas (which should get resurrected at
some
point) would handle this case well enough as well as help a dozen other
things. To wit:

array_filter($names, |$x| ==> trim($x))

I still fail to see why it would be considered to have that over a
perfectly encapsulted string for a callback, using a lambda/closure is
just an extra runtime call for syntax sugar, that seems poor in my
eyes.

Right click on function::trim - Find Usages. Basically allows to find all
usages of a given function, including the callback usage.

What would be ideal here, would be for functions to be first class
citizens in callback contexts, like in C to avoid the quotation,
however it clashes with constants. A hack you can do in userland could
be something like:

const trim = 'trim';
array_filter($names, trim);

--
regards,

Kalle Sommer Nielsen
kalle@php.net

--

--
Arvīds Godjuks

+371 26 851 664
arvids.godjuks@gmail.com
Skype: psihius
Telegram: @psihius https://t.me/psihius

Sorry for a bunch of replies that simply have lost a lot of context.. I'll
try to summarize it all here:

I believe the proposal for short lambas (which should get resurrected at
some
point) would handle this case well enough as well as help a dozen other
things. To wit:

array_filter($names, |$x| ==> trim($x))

--Larry Garfield

I don't think it's quite the same, and although I can agree that short
lambdas look better then normal in this context, I would still prefer
function::trim

In my opinion "ideal" here is that our symbol tables are merged, so
referring to "trim" in any context will resolve to at most one symbol

That sounds like a plan, and if there is a reasonable support for that,
then we could just have array_filter($arr, trim) - then its way better than
my proposal, and should also work with class methods.

Right click on function::trim - Find Usages. Basically allows to find
all
usages of a given function, including the callback usage.

Yeah, that was part of the idea, the other being to make these callbacks
semantically different from strings. Its just weird that a string is
callable, isn't it?

And about methods? How it should works if I wants to call a method from a
custom class? It should be function::CustomClass::someMethod?

My proposal would not work for methods. function::CustomClass::someMethod -
that doesn't look great at all, at least to me.

My proposal would not work for methods. function::CustomClass::someMethod

• that doesn't look great at all, at least to me.

On Fri, Oct 26, 2018 at 6:08 PM David Rodrigues david.proweb@gmail.com
wrote:

Em sex, 26 de out de 2018 às 09:30, Crocodile crocodile2u@gmail.com
escreveu:

Hi internals!

I have this idea of improving the way to specify callbacks for good old
PHP
functions. For instance, I have this piece of code:

---

array_filter($names, 'trim')

The callback function name is specified as a string, which makes it
not-so-obvious, although this is definitely a PHP way. An alternative
would
be to rewrite this using a lambda:

---

array_filter($names, function($name) { return trim($name); })

This is way more wordy, and I bet most of us will go for the first
option.

What if we had a more clear way of specifying those callbacks? I suggest
the following:

---

array_filter($names, function::trim)

And about methods? How it should works if I wants to call a method from a
custom class? It should be function::CustomClass::someMethod?

It is, I believe, more clear then a simple string, just a bit more
wordy,
and since "function" is a reserved word which never had anything to do
with
"::", the lexer/parser could probably find a way to deal with this kind
of
syntax (well, honestly, this part is totally unclear for me because I
only
work with PHP from userland).

Does anyone else find this could be a good addition? Or is it not worth
considering? Or maybe I am missing some obvious pitfalls?

Cheers,
Victor

Best regards,
Victor Bolshov

--
David Rodrigues

--
Best regards,
Victor Bolshov

--
Best regards,
Victor Bolshov