OK, but I still think that shouldn't be part of the benchmark: let's say you have a `PropertyReader` interface, and you have `ReflectionPropertyReader` and `ClosurePropertyReader` implementations.

```php
class ReflectionPropertyReader {
    public function readProperty($object, $property) {
        $reflectionProperty = new ReflectionProperty($this->object, $this->propertyName);
        $reflectionProperty->setAccessible(true);
        return $reflectionProperty->getValue($this->object);
    }
}
```

The reflection object is created each time the method is called because we have to. There's no way to avoid it.

For the closure implementation, we can do a more optimized solution:

```php
class ClosurePropertyReader {
    private $closure;
    public function __construct() {
        $this->closure = function($object, $property) {
            return $object->$property;
        }
    }
    public function readProperty($object, $property) {
        return Closure::bind($this->closure, null, $this->object)
            ->__invoke($this->object, $this->property);
    }
}
```

Here I have a "generic" read closure, so I will not create it each time the `readProperty` method is called.

Sure, if it's called once, then there's no difference, but then caring about performances is moot.
If it's called several times, then the closure declaration shouldn't be accounted in the benchmark, since it's called once.