Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:94693
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain gmail.com designates 209.85.220.182 as permitted sender)
MIME-Version: 1.0
In-Reply-To: <CA+kxMuSexGGh3jf5kC=D03PZ+jBK3+B_nbcCp=Pr-ASoaX9_2A@mail.gmail.com>
References: <CAEsg9X3N_DT=tXr3gJtxtkk+=cnvp0o0WEz2fw8eCEJ0uPO14Q@mail.gmail.com>
 <c0be45ca-864c-92e6-5ed5-8a5cad86577b@gmail.com> <CAEsg9X0V8ojwyocgjujCX0C3KKAwzYZ+rUWRgRvwtR5H6QjSHQ@mail.gmail.com>
 <CA+kxMuSexGGh3jf5kC=D03PZ+jBK3+B_nbcCp=Pr-ASoaX9_2A@mail.gmail.com>
Date: Mon, 25 Jul 2016 00:46:26 -0300
Message-ID: <CAEsg9X2QGOsOkE_E5YhQes7qrq=XgxJMG9OGLrnnuaBLeiPF9A@mail.gmail.com>
To: Dan Ackroyd <danack@basereality.com>
Cc: Stanislav Malyshev <smalyshev@gmail.com>, PHP Internals <internals@lists.php.net>
Content-Type: text/plain; charset=UTF-8
Subject: Re: [PHP-DEV] RFC: lazy statements
From: david.proweb@gmail.com (David Rodrigues)

Dan Ackroyd wrote:
> Yes, but the difference is in the surprise factor.
>
> Two functions having a circular dependency ==> not too astonishing,
> and easy to think about.
>
> Reading the value of a variable having a circular dependency ==> give
> up programming to become a farmer.

Okay, so we can avoid circular dependencies (in sense of find
where a circular dependency occur) by creating a progression
system over lazy objects.

Something like:

Lazy {
    progress { DEFINED, EXECUTING, FINISHED };
    statement
}

For instance, when you defines a lazy statement, it states is
set as "defined". When you starts execution over it, it changes
the states to "executing". After it finish, it change states to
"finished". This last state is the final value of variable, basically.

So, in case of a lazy statement be called on "executing" phase,
it should throw an error.

For instance:

    $b = null;
    $a = lazy use ($b) { return $b; }
    $b = lazy use ($a) { return $a; }

In this case, both $a and $b are on state "defined".

    echo $a;

When I call $a now, it set states to "executing".
In this case, it'll try read $b that is lazy too.
$b is now "executing" too.
Now $b will try to read $a, but $a already is "executing"
So PHP should throw an error like "cyclic execution on line x".



But in all way, lazy statements should not be used on all places
I should not substitute default variable, mainly because it should
be less performatic (not too much, I guess).

Lazy statements should be used only in case where the
variable contents is very complex (high cost) and very few
useful in all requests. And where methods or functions is not too
viable.

Example:

class Foo {
    public $something = lazy {
        // do complex things.
        return $complexValue;
    };
}

$foo = new Foo;
$foo->something++;

Instead of:

class Foo {
    private $something;

    public function getSomething() {
        if (!$this->something) {
            // do complex things.
            $this->something = $complexValue;
        }

        return $this->something;
    }

    public function setSomething($value) {
        $this->something = $value;
    }
}

$foo = new Foo;
$fooSomething = $foo->getSomething();
$fooSomething++;
$foo->setSomething($fooSomething);