[QUESTION / PROPOSAL] Is there a way to lazy load listeners? about event HOT 5 CLOSED

$emitter->addListener("some.event", $container->get("listener");

<?php

use League\Container\ContainerInterface;
use League\Event\EmitterTrait;
use League\Event\EmitterInterface;

class LazyEmitter implements EmitterInterface
{
    use EmitterTrait;

    protected $container;

    /**
     * You have to add listeners to your container
     *
     * You should register them as singletons
     *
     * @param ContainerInterface $container
     */
    public function __construct(ContainerInterface $container)
    {
        $this->container = $container;
    }

    public function emit($event)
    {
        // ensure event is an event object
        // get its name: $name
        if (!$this->container->isSingleton($name)) {
            $listeners = $this->container[$name];
            is_array($listeners) or $listeners = [$listeners];

            foreach ($listeners as $listener) {
                $this->getEmitter()->addListener($name, $listener);
            }
        }

        return call_user_func_array([$this->getEmitter(), 'emit'], func_get_args());
    }
}

<?php

class LazyListener implements ListenerInterface
{
    protected $container;
    protected $containerKey;
    protected $listener;

    public function __construct(Container $container, $containerKey,)
    {
        $this->container = $container;
        $this->containerKey = $containerKey;
    }

    public function handle(EventInterface $event)
    {
        $arguments = [$event] + func_get_args();
        $listener = $this->resolveListener();

        return call_user_func_array([$listener, 'handle'], $arguments);
    }

    protected function resolveListener()
    {
        if (! $this->listener) {
            $this->listener = $this->container->get($this->containerKey);
        }

        return $this->listener;
    }

    public function getContainerKey()
    {
        return $this->containerKey;
    }

    public function isListener($listener)
    {
        if ($listeners instanceof LazyListener && $this->containerKey === $listener->getContainerKey) {
            return true;
        }

        return false;
    }
}

$container = new Container();
// .. configure container to have the listener which needs deps
$emitter = new Emitter;
$emitter->addListener('event.name', new LazyListener($container, 'some.dependency.key'));
$emitter->emit('event.name');

public function addListener($event, $listener, $priority = self::P_NORMAL)
{
    // I just remove this to make sure I can pass reference only
    // $listener = $this->ensureListener($listener);

    if (! isset($this->listeners[$event])) {
        $this->listeners[$event] = [];
    }

    $this->listeners[$event][] = [$listener, $priority];
    $this->clearSortedListeners($event);
    return $this;
}

protected function invokeListeners($name, EventInterface $event, array $arguments)
{
    $listeners = $this->getListeners($name);

    foreach ($listeners as $listener) {
        if ($event->isPropagationStopped()) {
            break;
        }

        // resolve listener
        $listener = $this->ensureListener($listener);

        call_user_func_array([$listener, 'handle'], $arguments);
    }
}

protected function ensureListener($listener)
{
    if ($listener instanceof ListenerInterface) {
        return $listener;
    }

    if (is_callable($listener)) {
        return CallbackListener::fromCallable($listener);
    }

    // If we pass reference in containter then resolve it
    if (($listener = $this->container->get($listener)) != null) {
        return $listener
    }

    throw new InvalidArgumentException('Listeners should be be ListenerInterface, Closure or callable. Received type: '.gettype($listener));
}