Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:112262
MIME-Version: 1.0
References: <CA+kxMuRjJ5B_ykNXeMZhAd6iduh-VEk7CNP0vNuZp9fjka5_HQ@mail.gmail.com>
 <CAAKU0u=cHBO1r=vA9_KdXzrPGzQuiCksPTPYZZB5d0mSfrDxfw@mail.gmail.com>
 <CAJmy8YF2Un=Di_xOL=dnQ8nhOHO4ZbyptXz4PRLnYY=zZDzK1A@mail.gmail.com>
 <CA+kxMuTm+UorKQ=YU96c_k6H-c3CVhmA7gu12K-6Sf532Qrpag@mail.gmail.com>
 <55e200cf-ed16-e935-4e09-728ce3362cba@gmx.de> <CAEsg9X2w=Bty-4oVsN1ac6+J6PFko7XAajGfk4os7cruQS8Yxw@mail.gmail.com>
 <CAESVnVp42zB6paMoBfKAfDF8kdH3_3-8KZkvk=AzPESmH57C9Q@mail.gmail.com>
In-Reply-To: <CAESVnVp42zB6paMoBfKAfDF8kdH3_3-8KZkvk=AzPESmH57C9Q@mail.gmail.com>
Date: Fri, 20 Nov 2020 13:01:39 -0300
Message-ID: <CAEsg9X3zx9sAdap3JTkua6g3jki8QcsHVixYfH_+9xwNg4wA1Q@mail.gmail.com>
To: PHP internals <internals@lists.php.net>
Content-Type: multipart/alternative; boundary="0000000000007a7cba05b48bf6fb"
Subject: Re: [PHP-DEV] [RFC] Draft - Closure self reference
From: david.proweb@gmail.com (David Rodrigues)

--0000000000007a7cba05b48bf6fb
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

> Is it `returnType as $thing` ?  That doesn't read well, but I don't see
us making return type movable.  as/use should be placable in either order,
but maybe we give them required order anyway?

I don't know if that would be a problem, because today we can have it
"function(): Type use($x)", so "Type use($x)"? I have to agree that it may
sound strange at first, but I also can't imagine many ways of doing things
differently without creating more complexities.

(1) function as $lambda (... $args): returnType use ($captures...) {}
(2) function (... $args) as $lambda: returnType use ($captures...) {}
(3) function (... $args): returnType as $lambda use ($captures...) {} //
original suggestion
(4) function (... $args): returnType use ($captures...) as $lambda {}
(4.b) function (... $args): returnType as $lambda {} // without use() will
be same as (3)

Or, define a "inline function" with its own name, visible only within the
scope itself. Similar to how JS works.

(5) function $lambda(... $args): returnType use ($captures...) {}

To be honest, as I typed what came to mind, I ended up preferring this last
option.

JS way:

function fb(n) {
  if (n =3D=3D=3D 0) return 0;
  if (n =3D=3D=3D 1) return 1;

  return fb(n - 1) + fb(n - 2);
}

PHP (self-referenced) way:

function $fb($n): int {
  if ($n =3D=3D=3D 0) return 0;
  if ($n =3D=3D=3D 1) return 1;

  return $fb($n - 1) + $fb($n - 2);
}

Currently PHP will accepts the same JS solution, but it will exposes fb()
to global scope and could causes errors:

function test() {
  function fb($n): int
  {
    if ($n =3D=3D=3D 0) return 0;
    if ($n =3D=3D=3D 1) return 1;

    return fb($n - 1) + fb($n - 2);
  }

  var_dump(fb(10));
}

test();
test(); // Fatal error: Cannot redeclare fb()


Atenciosamente,
David Rodrigues


Em sex., 20 de nov. de 2020 =C3=A0s 12:14, Sara Golemon <pollita@php.net>
escreveu:

> On Wed, Nov 11, 2020 at 12:37 PM David Rodrigues <david.proweb@gmail.com>
> wrote:
>
>> My suggestion is to reuse the keyword `as` to set a variable that will
>> represent its own closure. It is more flexible once that we could choose
>> any name and reuse in nested closures. It is pretty similar to how SQL
>> works too.
>>
>> function fn1() as $lambda1 {
>>     return function() as $lambda2 use ($lambda1) {
>>         return [ gettype($lambda1), gettype($lambda2) ];
>>     };
>> }
>>
>>
> My initial reaction to this is:  Technically doable (easy even), but look=
s
> a bit... ugly? weird? surprising?
>
> I think my main objection to it is how much is now stacked after the
> parameter list:
>
> function($args...) : returnType as $local use ($captures...) {
>   ...
> };
>
> That's a lot of... stuff (granted, we have most of it already) and how it
> looks when stacked together gets funky.
>
> Is it `returnType as $thing` ?  That doesn't read well, but I don't see u=
s
> making return type movable.  as/use should be placable in either order, b=
ut
> maybe we give them required order anyway?
>
> TLDR; Long winded way to say I'm not inherently against this, and I like
> the idea of a lambda being able to recurse (not that I can ever recall
> having use for it, but maybe I fell back on named functions for that), I
> just think it's getting a bit wordy.
>
> -Sara
>

--0000000000007a7cba05b48bf6fb--