Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:112263
User-Agent: Cyrus-JMAP/3.3.0-622-g4a97c0b-fm-20201115.001-g4a97c0b3
Mime-Version: 1.0
Message-ID: <2369a5a3-3309-4131-81c1-4ebded96e61f@www.fastmail.com>
In-Reply-To: 
 <CAEsg9X3zx9sAdap3JTkua6g3jki8QcsHVixYfH_+9xwNg4wA1Q@mail.gmail.com>
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>
 <CAEsg9X3zx9sAdap3JTkua6g3jki8QcsHVixYfH_+9xwNg4wA1Q@mail.gmail.com>
Date: Fri, 20 Nov 2020 11:39:58 -0600
To: "php internals" <internals@lists.php.net>
Content-Type: text/plain
Subject: Re: [PHP-DEV] [RFC] Draft - Closure self reference
From: larry@garfieldtech.com ("Larry Garfield")

On Fri, Nov 20, 2020, at 10:01 AM, David Rodrigues wrote:
> > 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.

I kind of like that option, too.  The main question in my mind is whether that means the same variable is used internally and externally or not.  That is, my knee-jerk reaction when reading that was to ask if this would be confusing:

$fib = function $f(int $n): int { ... }

Viz, do $fib and $f need to match?

It looks from the example below like you're saying it's actually:

function $fib(int $n): int { ... }

Where $fib is then both the internal and external variable name.

That seems unexpected.  It may be the best way to go about it, but it feels surprising as a user space developer.

I do think something like that is probably the best way forward, though.

The other question of course is short-lambdas.  Would that mean this?

fn $fib(int $n): int => match($n) {
  0 => 0,
  1 => 1,
  default => $fib(n - 1) + $fib($n - 2),
};

If the function is inlined, does that mean the variable name leaks and thus remains in scope (and the closure thus using memory)?

array_map(fn $fib(int $n): int => match($n) {
  0 => 0,
  1 => 1,
  default => $fib(n - 1) + $fib($n - 2),
}, range(1, 6));

print $fib(5); // Does this work?

(No you shouldn't write it like that, but since Fibonacci is the example we're working with...)

--Larry Garfield