Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:94642
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: error (pb1.pair.com: domain basereality.com from 209.85.161.176 cause and error)
MIME-Version: 1.0
In-Reply-To: <CAEsg9X3N_DT=tXr3gJtxtkk+=cnvp0o0WEz2fw8eCEJ0uPO14Q@mail.gmail.com>
References: <CAEsg9X3N_DT=tXr3gJtxtkk+=cnvp0o0WEz2fw8eCEJ0uPO14Q@mail.gmail.com>
Date: Sat, 23 Jul 2016 11:06:47 +0100
Message-ID: <CA+kxMuSVnaBRKNZJ3HLAYBZdyCgDfpwCBbSaFZ9=LA7BeKza-g@mail.gmail.com>
To: David Rodrigues <david.proweb@gmail.com>
Cc: PHP Internals <internals@lists.php.net>
Content-Type: text/plain; charset=UTF-8
Subject: Re: [PHP-DEV] RFC: lazy statements
From: danack@basereality.com (Dan Ackroyd)

Hi David,

On 21 July 2016 at 16:51, David Rodrigues <david.proweb@gmail.com> wrote:
> This Feature Request is about the implementation of lazy statements.

This looks to solve a problem very similar to the one solved by the
'Memoize' annotation in HHVM -
https://docs.hhvm.com/hack/attributes/special#__memoize

However the memoize functionality seems a lot clearer to me, as it's
less 'magic'; it doesn't make accessing a variable actually call a
function.


Larry Garfield wrote:
>> However, that also means there's an enormous potential for race
>> conditions.

I think s/race conditions/circular dependencies/ probably explain the
problem more clearly.

> I can think about how we can handle this, but I need a real case
> where this problem can exists.

This code has a circular dependency:

class Foo {
    public $a, $b;
    public __construct() {
        $this->a = lazy { return 1 + $this->b; }
        $this->b = lazy { return 1 + $this->a; }
    }
}

$foo = new Foo;
echo $foo->a;

$foo->a can't be resolved until $foo->b is resolved, and $foo->b can't
be resolved until $foo->a is resolved.

Although that is obvious in a trivial code example, when trying to use
a magic feature like this in complex code, where the circular
dependency involves, say, 10 items, then it become very hard to reason
about the code.

Because the 'memoization' of functions is less magic, it is much less
prone to this circular dependency problem.

cheers
Dan