@@ -223,7 +223,7 @@ discard block  | 
                                                    ||
| 223 | 223 | private function createCacheItem(): void  | 
                                                        
| 224 | 224 |      { | 
                                                        
| 225 | 225 | $this->createCacheItem = Closure::bind(  | 
                                                        
| 226 | -            static function (string $key, $value, bool $isHit): CacheItemInterface { | 
                                                        |
| 226 | +            static function(string $key, $value, bool $isHit): CacheItemInterface { | 
                                                        |
| 227 | 227 | $item = new CacheItem();  | 
                                                        
| 228 | 228 | $item->key = $key;  | 
                                                        
| 229 | 229 | $item->value = $v = $isHit ? $value : null;  | 
                                                        
@@ -256,7 +256,7 @@ discard block  | 
                                                    ||
| 256 | 256 | private function mergeByLifetime(callable $getId): void  | 
                                                        
| 257 | 257 |      { | 
                                                        
| 258 | 258 | $this->mergeByLifetime = Closure::bind(  | 
                                                        
| 259 | -            static function ($deferred, &$expiredIds) use ($getId): array { | 
                                                        |
| 259 | +            static function($deferred, &$expiredIds) use ($getId): array { | 
                                                        |
| 260 | 260 | $byLifetime = [];  | 
                                                        
| 261 | 261 | $now = \microtime(true);  | 
                                                        
| 262 | 262 | $expiredIds = [];  | 
                                                        
@@ -137,7 +137,7 @@ discard block  | 
                                                    ||
| 137 | 137 |              } elseif (null !== $fallback) { | 
                                                        
| 138 | 138 | $result[$key] = $this->save(  | 
                                                        
| 139 | 139 | $key,  | 
                                                        
| 140 | -                    function (CacheItemInterface $item, bool $save) use ($key, $fallback) { | 
                                                        |
| 140 | +                    function(CacheItemInterface $item, bool $save) use ($key, $fallback) { | 
                                                        |
| 141 | 141 | return $fallback(...[$key, &$item, &$save]);  | 
                                                        
| 142 | 142 | },  | 
                                                        
| 143 | 143 | $beta  | 
                                                        
@@ -148,7 +148,7 @@ discard block  | 
                                                    ||
| 148 | 148 | }  | 
                                                        
| 149 | 149 | |
| 150 | 150 | return \array_map(  | 
                                                        
| 151 | -            function ($value) { | 
                                                        |
| 151 | +            function($value) { | 
                                                        |
| 152 | 152 |                  if ($value instanceof CacheItemInterface) { | 
                                                        
| 153 | 153 | return $value->get();  | 
                                                        
| 154 | 154 | }  | 
                                                        
@@ -187,7 +187,7 @@ discard block  | 
                                                    ||
| 187 | 187 | static $setExpired;  | 
                                                        
| 188 | 188 | |
| 189 | 189 | $setExpired = Closure::bind(  | 
                                                        
| 190 | -            static function (CacheItem $item): ?int { | 
                                                        |
| 190 | +            static function(CacheItem $item): ?int { | 
                                                        |
| 191 | 191 |                  if (null === $item->expiry) { | 
                                                        
| 192 | 192 | return null;  | 
                                                        
| 193 | 193 | }  | 
                                                        
@@ -199,12 +199,12 @@ discard block  | 
                                                    ||
| 199 | 199 | );  | 
                                                        
| 200 | 200 | |
| 201 | 201 |          if ($this->storage instanceof PhpCachePool) { | 
                                                        
| 202 | -            $setExpired = static function (PhpCacheItem $item): ?int { | 
                                                        |
| 202 | +            $setExpired = static function(PhpCacheItem $item): ?int { | 
                                                        |
| 203 | 203 | return $item->getExpirationTimestamp();  | 
                                                        
| 204 | 204 | };  | 
                                                        
| 205 | 205 | }  | 
                                                        
| 206 | 206 | |
| 207 | -        $callback = function (CacheItemInterface $item, bool $save) use ($key, $callback) { | 
                                                        |
| 207 | +        $callback = function(CacheItemInterface $item, bool $save) use ($key, $callback) { | 
                                                        |
| 208 | 208 | // don't wrap nor save recursive calls  | 
                                                        
| 209 | 209 |              if (isset($this->computing[$key])) { | 
                                                        
| 210 | 210 | $value = $callback(...[&$item, &$save]);  | 
                                                        
@@ -250,7 +250,7 @@ discard block  | 
                                                    ||
| 250 | 250 | |
| 251 | 251 | return $this->load(  | 
                                                        
| 252 | 252 | $key,  | 
                                                        
| 253 | -            function (CacheItemInterface $item, bool $save) use ($callback, $key) { | 
                                                        |
| 253 | +            function(CacheItemInterface $item, bool $save) use ($callback, $key) { | 
                                                        |
| 254 | 254 | $dependencies = \array_merge(\array_slice($key, 1), [&$item, &$save]);  | 
                                                        
| 255 | 255 | |
| 256 | 256 | return $callback(...$dependencies);  | 
                                                        
@@ -264,7 +264,7 @@ discard block  | 
                                                    ||
| 264 | 264 | */  | 
                                                        
| 265 | 265 | public function wrap(callable $callback, ?float $beta = null): callable  | 
                                                        
| 266 | 266 |      { | 
                                                        
| 267 | -        return function () use ($callback, $beta) { | 
                                                        |
| 267 | +        return function() use ($callback, $beta) { | 
                                                        |
| 268 | 268 | return $this->call($callback, $beta);  | 
                                                        
| 269 | 269 | };  | 
                                                        
| 270 | 270 | }  |