Return a Closure from a Factory

I have services that depend on request information. I'm trying to create a Factory Factory which will have the Dependency Injection container returns a factory (an anonymous function) that will create the services I want. So basically somthing like this:

class FooFactoryFactory {
  public static function create(ContainerInterface $container): callable {
     return static function (Request $request) use ($container) {
       $raz = request->get('param_raz');
       return new Bar(
           $container->get(LoggerInterface::class),
           $raz,
       );
     };
  }

}

The issue I have is that the Closure is properly created, but de Drupal's Dependency Injection Container class tries to set a proprty to the Closure. This cannot work and ends in a fatal error:

Closure object cannot have properties

Here is the place where it occurs:

// Drupal\Component\DependencyInjection\Container::createService() - Line 283-293
if (isset($definition['properties'])) {
  if ($definition['properties'] instanceof \stdClass) {
    $definition['properties'] = $this->resolveServicesAndParameters($definition['properties']);
  }
  foreach ($definition['properties'] as $key => $value) {
     $service->{$key} = $value;  // <-- Will not work for Closure
  }
}
...

So the questions I have:

• Is this by design? Meaning is it something thta is not wanted in term of coding practice?
• The error can be avoided if I manage to make sure, that the service I want to create does not have properties it it's definition. I just don't know how to achieve this.

Thanks for the help on this matter.

EDIT: This is basically what I'm trying to achieve:

  closure.factory.service:
    class: Drupal\some_module\ClosureFactoryService
  closure.service:
    class: Closure
    factory: [ '@closure.factory.service', getCallable ]

class ClosureFactoryService {
  public function getCallable(): Closure {
    return static function (int $arg): string {
      return sprintf('val %d', $arg);
    };
  }
}

I get: Closure object cannot have properties in Drupal\Component\DependencyInjection\Container->createService() (line 288...

In Drupal, the class for a service defined in a module .services.yml file doesn't need to implement create(ContainerInterface $container). It's not even requested to implement a specific PHP interface.

See one of the services Drupal core implements, for example the path_alias.manager service.

path_alias.manager:
  class: Drupal\path_alias\AliasManager
  arguments:
   - '@path_alias.repository'
   - '@path_alias.whitelist'
   - '@language_manager'
   - '@cache.data'

The AliasManager class that implements that service doesn't implement any create() method; it just implement the constructor, with the parameters defined in the same order the service arguments are listed.

public function __construct($alias_repository, AliasWhitelistInterface $whitelist, LanguageManagerInterface $language_manager, CacheBackendInterface $cache) {
  $this->pathAliasRepository = $alias_repository;
  $this->languageManager = $language_manager;
  $this->whitelist = $whitelist;
  $this->cache = $cache;
}

The classes that implement create(ContainerInterface $container) and which implement ContainerInjectionInterface, for example the CronForm class, don't return a closure from create(ContainerInterface $container); they actually only return an instance of themselves. See CronForm::create().

public static function create(ContainerInterface $container) {
  return new static($container->get('config.factory'),
    $container->get('state'),
    $container->get('cron'),
    $container->get('date.formatter'),
    $container->get('module_handler')
  );
}

If you want to implement a factory service in Drupal, you should take the cache_factory service as example to write your code.

cache_factory:
  class: Drupal\Core\Cache\CacheFactory
  arguments:
    - '@settings'
    - '%cache_default_bin_backends%'
  calls:
    - [setContainer, ['@service_container']]

A service that uses that service as factory is, for example, the cache.render service.

cache.render:
  class: Drupal\Core\Cache\CacheBackendInterface
  tags:
    - { name: cache.bin }
  factory:
    - '@cache_factory'
    - get
  arguments:
    - render

The factory key defines which service is the factory service and which method is called for that factory service; the arguments key define the arguments passed to that method. In this case, it's telling Drupal to instantiate the cache.render service by instantiating the cache_factory service and calling get('render') on that object.