Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:123664
Precedence: bulk
MIME-Version: 1.0
References: <CAOWwgpmbq5VRrZQvUXDsKiNK4r6+bFA4VxnjQ_U=h8T9r0o3DA@mail.gmail.com>
 <ab83af79-0669-47dd-a3cb-ab72327ae174@bastelstu.be> <CAP1Jc13JWVg99AULgzrGXcoCWJtJZGz+nr_VoyUocw8n5n5sfQ@mail.gmail.com>
 <1118bbcd-a7b4-47bf-bf35-1a36ab4628e1@bastelstu.be> <CAP1Jc11vNiazMRL8Y-4NcJhsEkg6kgFNKLymTGfEPYRv114oTA@mail.gmail.com>
 <d9798141-8957-4152-a1ae-f2abcfcc036c@app.fastmail.com> <CAP1Jc11R1P_c2vwRrSZ01X4cUBYvLukj9iYEYyqM+Hemriv3pw@mail.gmail.com>
 <b71effbb-e267-44bc-b11c-e6dbf4784a88@app.fastmail.com> <CAP1Jc10EagLDV5s9zPBz=xqK-eGg_byBe2Twne1Jin28S+zb3w@mail.gmail.com>
In-Reply-To: <CAP1Jc10EagLDV5s9zPBz=xqK-eGg_byBe2Twne1Jin28S+zb3w@mail.gmail.com>
Date: Tue, 18 Jun 2024 19:45:00 +0200
Message-ID: <CAP1Jc10nkYctLsDWXUi+S-QdZ-J8zrfnEsw7ZAAjsHx9u5JQuQ@mail.gmail.com>
Subject: Re: [PHP-DEV] [RFC] Lazy Objects
To: Larry Garfield <larry@garfieldtech.com>
Cc: php internals <internals@lists.php.net>
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
From: arnaud.lb@gmail.com (Arnaud Le Blanc)

Hi Larry,

Following your feedback we propose to amend the API as follows:

```
class ReflectionClass
{
    public function newLazyProxy(callable $factory, int $options): object {=
}

    public function newLazyGhost(callable $initializer, int $options): obje=
ct {}

    public function resetAsLazyProxy(object $object, callable
$factory, int $options): void {}

    public function resetAsLazyGhost(object $object, callable
$initializer, int $options): void {}

    public function initialize(object $object): object {}

    public function isInitialized(object $object): bool {}

    // existing methods
}

class ReflectionProperty
{
    public function setRawValueWithoutInitialization(object $object,
mixed $value): void {}

    public function skipInitialization(object $object): void {}

    // existing methods
}
```

Comments / rationale:
- Adding methods on ReflectionClass instead of ReflectionObject is
better from a performance point of view, as mentioned earlier
- Keeping the word "Lazy" in method names is clearer, especially for
"newLazyProxy" as a the "Proxy" pattern has many uses-cases that are
not related to laziness. However we removed the word "Instance" to
make the names shorter.
- We have renamed "make" methods to "reset", following your feedback
about the word "make". It should better convey the behavior of these
methods, and clarify that it's modifying the object in-place as well
as resetting its state
- setRawValueWithoutInitialization() has the same behavior as
setRawValue() (from the hooks RFC), except it doesn't trigger
initialization
- Renamed $initializer to $factory for proxy methods

WDYT?

Best Regards,
Arnaud

On Sun, Jun 16, 2024 at 3:46=E2=80=AFPM Arnaud Le Blanc <arnaud.lb@gmail.co=
m> wrote:
>
> On Sat, Jun 15, 2024 at 7:13=E2=80=AFPM Larry Garfield <larry@garfieldtec=
h.com> wrote:
> > > In practice I expect there will be two kinds of ghost initializers:
> > > - Those that just call one public method of the object, such as the c=
onstructor
> > > - Those that initialize everything with ReflectionProperty::setValue(=
)
> > > as in the Doctrine example in the "About Lazy-Loading strategies"
> > > section
> > I'm still missing an example with ::bind().  Actually, I tried to write=
 a version of what I think the intent is and couldn't figure out how. :-)
> >
> > $init =3D function() use ($c) {
> >   $this->a =3D $c->get(ServiceA::class);
> >   $this->b =3D $c->get(ServiceB::class);
> > }
> >
> > $service =3D new ReflectionLazyObjectFactory(Service::class, $init);
> >
> > // We need to bind $init to $service now, but we can't because $init is=
 already registered as the initializer for $service, and binding creates a =
new closure object, not modifying the existing one.  So, how does this even=
 work?
>
> Oh I see. Yes you will not be able to bind $this in a simple way here,
> but you could bind the scope. This modified example will work:
>
> ```
> $init =3D function($object) use ($c) {
>   $object->a =3D $c->get(ServiceA::class);
>   $object->b =3D $c->get(ServiceB::class);
> }
> $service =3D new ReflectionLazyObjectFactory(Service::class,
> $init->bindTo(null, Service::class));
> ```
>
> If you really want to bind $this you could achieve it in a more convolute=
d way:
>
> ```
> $init =3D function($object) use ($c) {
>   (function () use ($c) {
>     $this->a =3D $c->get(ServiceA::class);
>     $this->b =3D $c->get(ServiceB::class);
>   })->bindTo($object)();
> }
> $service =3D new ReflectionLazyObjectFactory(Service::class, $init);
> ```
>
> This is inconvenient, but the need or use-case is not clear to me.
> Could you describe some use-cases where you would hand-write
> initializers like this? Do you feel that the proposal should provide
> an easier way to change $this and/or the scope?
>
> > > In practice we expect that makeInstanceLazy*() methods will not be
> > > used on fully initialized objects, and that the flag will be set most
> > > of the time, but as it is the API is safe by default.
> >
> > In the case an object does not have a destructor, it won't make a diffe=
rence either way, correct?
>
> Yes
>
> > >> I find it interesting that your examples list DICs as a use case for=
 proxies, when I would have expected that to fit ghosts better.  The common=
 pattern, I would think, would be:
> > > The RFC didn't make it clear enough that the example was about the
> > > factory case specifically.
> >
> > Ah, got it.  That makes more sense.
> >
> > Which makes me ask if the $initializer of a proxy should actually be ca=
lled $factory?  Since that's basically what it's doing,
>
> Good point, $factory would be a good name for this parameter.
>
> > and I'm unclear what it would do with the proxy object itself that's pa=
ssed in.
>
> Passing the factory itself as argument could be used to make decisions
> based on the value of some initialized field, or on the class of the
> object, or on its identity. I think Nicolas had a real use-case where
> he detects clones based on the identity of the object:
>
> ```
> $init =3D function ($object) use (&$originalObject) {
>     if ($object !=3D=3D $originalObject) {
>         // we are initializing a clone
>     }
> };
> $originalObject =3D $reflector->newProxyInstance($init);
> ```
>
> This was on ghosts, but I think it's also a valid use-case example for pr=
oxies.
>
> > >> ReflectionLazyObjectFactory is a terrible name.  Sorry, it is. :-)  =
Especially if it's subclassing ReflectionClass.  If it were its own thing, =
maybe, but it's still too verbose.  I know you don't want to put more on th=
e "dumping ground" fo ReflectionClass, but honestly, that feels more ergono=
mic to me.  That way the following are all siblings:
> > >>
> > >> newInstance(...$args)
> > >> newInstanceWithoutConstructor(...$args)
> > >> newGhostInstance($init)
> > >> newProxyInstance($init)
> > >>
> > >> That feels a lot more sensible and ergonomic to me.  isInitialized()=
, initialized(), etc. also feel like they make more sense as methods on Ref=
lectionObject, not as static methods on a random new class.
> > >
> > > Thank you for the suggestion. We will check if this fits the
> > > use-cases. Moving some methods on ReflectionObject may have negative
> > > performance implications as it requires creating a dedicated instance
> > > for each object. Some use-cases rely on caching the reflectors for
> > > performance.
> > >
> > > Best Regards,
> > > Arnaud
> >
> > I'm not clear why there's a performance difference, but I haven't looke=
d at the reflection implementation in, well, ever. :-)
>
> What I meant is that creating an instance (not necessarily of
> ReflectionObject, but of any class) is more expensive than just doing
> nothing. The first two loops below would be fine, but the last one
> would be slower. This can make an important difference in a hot path.
>
> ```
> foreach ($objects as $object) {
>     ReflectionLazyObject::isInitialized($object);
> }
>
> $reflector =3D new ReflectionClass(SomeClass::class);
> foreach ($objects as $object) {
>     $reflector->isInitialized($object);
> }
>
> foreach ($objects as $object) {
>     $reflector =3D new ReflectionObject($object);
>     $reflector->isInitialized($object);
> }
> ```
>
> > If it has to be a separate object, please don't make it extend Reflecti=
onClass but still give it useful dynamic methods rather than static methods=
.  Or perhaps even do something like
> >
> > $ghost =3D new ReflectionGhostInstance(SomeClass::class, $init);
> > $proxy  =3D new ReflectionProxyINstance(SOmeClass::class, $init);
> >
> > And be done with it.  (I'm just spitballing here.  As I said, I like th=
e feature, I just want to ensure the ergonomics are as good as possible.)
>
> Thank you for your help. We will think about a better API.