Lazy objects

[arnaud-lb]

No description provided.

[davekok]

Hi there, I just saw the RFC for lazy object on https://wiki.php.net/rfc/lazy-objects. What I am rather worried about is that the problem is shifted to writing initializers. And that instead of initialing objects, you need to initialize initializers on every requests. And that later on down the path we need to figure out how to lazy load initializers.

Also I would like a simpler method for creating ghost objects. Something more akin to the new operator. Perhaps $a = new MyClass(...);. This would make sort of a callable and when you use it, it triggers the __construct function and creates the actual object.

The __construct arguments in this case must be dependency injected. So you don't need to know them. This could be done through argument initializers. For config PHP would need to be able to fetch the config from .env files or something. For shared objects some context would have to be added so PHP knows how to reuse existing objects.

Anyways, hope it helps. Great job for trying to tackle this.

[arnaud-lb]

Thank you for the feedback.

Currently we are targeting a Reflection-only API, but it doesn't preclude the addition of a more convenient syntax in the future.

For the use-case of creating a lazy instance that calls the constructor, the initializer can just be an arrow function that calls the constructor:

new ReflectionLazyObject(MyClass::class)->newInstanceLazyGhost(fn ($obj) => $obj->__construct());

Which could be easily shortened down in a library:

function lazyNew($class, ...$args) {
    return new ReflectionLazyObject($class)
        ->newInstanceLazyGhost(fn ($obj) => $obj->__construct(...$args));
}

lazyNew(MyClass::class, $arg0, $argN);

[davekok]

Could you explain how a developer should manage these initializers? And please don't so the framework does it.

The concern I am having is that by fixing lazy objects with initializers. The initializers become the problem.

[arnaud-lb]

I'm not sure what you mean by managing the initializers. Could explain what you mean? For most non-library/framework use-cases I would expect the initializer to just be an anonymous function calling the constructor, like fn ($obj) => $obj->__construct().

[davekok]

In the example you have given, you show how you can create a single lazy object. But usually you have many, say you have a 1000 of these lazy objects. How would je manage that? Creating a 1000 lazy objects on each call, seems a bit absurd. Lazy loading your lazy loaders leads to inception. And manually creating your lazy loaded objects when ever you need them, seems overkill, why not just create them?