@@ -46,7 +46,7 @@ discard block  | 
                                                    ||
| 46 | 46 | * @param mixed $value Adds value start of array.  | 
                                                        
| 47 | 47 | * @return array New array with value on head.  | 
                                                        
| 48 | 48 | */  | 
                                                        
| 49 | -    return function ($value) use ($array): array { | 
                                                        |
| 49 | +    return function($value) use ($array): array { | 
                                                        |
| 50 | 50 | array_unshift($array, $value);  | 
                                                        
| 51 | 51 | return $array;  | 
                                                        
| 52 | 52 | };  | 
                                                        
@@ -64,7 +64,7 @@ discard block  | 
                                                    ||
| 64 | 64 | * @param mixed $value Adds value end of array.  | 
                                                        
| 65 | 65 | * @return array<int|string, mixed> New array with value on tail.  | 
                                                        
| 66 | 66 | */  | 
                                                        
| 67 | -    return function ($value) use ($array): array { | 
                                                        |
| 67 | +    return function($value) use ($array): array { | 
                                                        |
| 68 | 68 | $array[] = $value;  | 
                                                        
| 69 | 69 | return $array;  | 
                                                        
| 70 | 70 | };  | 
                                                        
@@ -78,7 +78,7 @@ discard block  | 
                                                    ||
| 78 | 78 | */  | 
                                                        
| 79 | 79 | function head(array $array)  | 
                                                        
| 80 | 80 |  { | 
                                                        
| 81 | - return ! empty($array) ? array_values($array)[0] : null;  | 
                                                        |
| 81 | + return !empty($array) ? array_values($array)[0] : null;  | 
                                                        |
| 82 | 82 | }  | 
                                                        
| 83 | 83 | |
| 84 | 84 | /**  | 
                                                        
@@ -89,7 +89,7 @@ discard block  | 
                                                    ||
| 89 | 89 | */  | 
                                                        
| 90 | 90 | function tail(array $array)  | 
                                                        
| 91 | 91 |  { | 
                                                        
| 92 | - return ! empty($array) ? array_reverse($array, false)[0] : null;  | 
                                                        |
| 92 | + return !empty($array) ? array_reverse($array, false)[0] : null;  | 
                                                        |
| 93 | 93 | }  | 
                                                        
| 94 | 94 | |
| 95 | 95 | |
@@ -106,7 +106,7 @@ discard block  | 
                                                    ||
| 106 | 106 | * @param array<int|string, mixed> $array Array join  | 
                                                        
| 107 | 107 | * @return string.  | 
                                                        
| 108 | 108 | */  | 
                                                        
| 109 | -    return function (array $array) use ($glue): string { | 
                                                        |
| 109 | +    return function(array $array) use ($glue) : string { | 
                                                        |
| 110 | 110 | return $glue ? \join($glue, $array) : \join($array);  | 
                                                        
| 111 | 111 | };  | 
                                                        
| 112 | 112 | }  | 
                                                        
@@ -122,14 +122,14 @@ discard block  | 
                                                    ||
| 122 | 122 | function zip(array $additional, $default = null): Closure  | 
                                                        
| 123 | 123 |  { | 
                                                        
| 124 | 124 | $additional = array_values($additional);  | 
                                                        
| 125 | -    return function (array $array) use ($additional, $default) { | 
                                                        |
| 125 | +    return function(array $array) use ($additional, $default) { | 
                                                        |
| 126 | 126 | $array = array_values($array);  | 
                                                        
| 127 | 127 | return array_reduce(  | 
                                                        
| 128 | 128 | array_keys($array),  | 
                                                        
| 129 | -            function ($carry, $key) use ($array, $additional, $default): array { | 
                                                        |
| 129 | +            function($carry, $key) use ($array, $additional, $default): array { | 
                                                        |
| 130 | 130 | $carry[] = array(  | 
                                                        
| 131 | - $array[ $key ],  | 
                                                        |
| 132 | - array_key_exists($key, $additional) ? $additional[ $key ] : $default,  | 
                                                        |
| 131 | + $array[$key],  | 
                                                        |
| 132 | + array_key_exists($key, $additional) ? $additional[$key] : $default,  | 
                                                        |
| 133 | 133 | );  | 
                                                        
| 134 | 134 | return $carry;  | 
                                                        
| 135 | 135 | },  | 
                                                        
@@ -159,11 +159,11 @@ discard block  | 
                                                    ||
| 159 | 159 | * @param mixed $value Adds value to inner array if value set, else returns.  | 
                                                        
| 160 | 160 | * @return mixed[]|Closure  | 
                                                        
| 161 | 161 | */  | 
                                                        
| 162 | -    return function ($value = null) use ($inital) { | 
                                                        |
| 162 | +    return function($value = null) use ($inital) { | 
                                                        |
| 163 | 163 |          if ($value) { | 
                                                        
| 164 | 164 | $inital[] = $value;  | 
                                                        
| 165 | 165 | }  | 
                                                        
| 166 | - return ! is_null($value) ? arrayCompiler($inital) : $inital;  | 
                                                        |
| 166 | + return !is_null($value) ? arrayCompiler($inital) : $inital;  | 
                                                        |
| 167 | 167 | };  | 
                                                        
| 168 | 168 | }  | 
                                                        
| 169 | 169 | |
@@ -184,11 +184,11 @@ discard block  | 
                                                    ||
| 184 | 184 | * @param mixed $value  | 
                                                        
| 185 | 185 | * @return mixed[]|Closure  | 
                                                        
| 186 | 186 | */  | 
                                                        
| 187 | -    return function ($value = null) use ($validator, $inital) { | 
                                                        |
| 188 | -        if (! is_null($value) && $validator($value)) { | 
                                                        |
| 187 | +    return function($value = null) use ($validator, $inital) { | 
                                                        |
| 188 | +        if (!is_null($value) && $validator($value)) { | 
                                                        |
| 189 | 189 | $inital[] = $value;  | 
                                                        
| 190 | 190 | }  | 
                                                        
| 191 | - return ! is_null($value) ? arrayCompilerTyped($validator, $inital) : $inital;  | 
                                                        |
| 191 | + return !is_null($value) ? arrayCompilerTyped($validator, $inital) : $inital;  | 
                                                        |
| 192 | 192 | };  | 
                                                        
| 193 | 193 | }  | 
                                                        
| 194 | 194 | |
@@ -213,7 +213,7 @@ discard block  | 
                                                    ||
| 213 | 213 | * @param array<int|string, mixed> $source Array to filter  | 
                                                        
| 214 | 214 | * @return array<int|string, mixed> Filtered array.  | 
                                                        
| 215 | 215 | */  | 
                                                        
| 216 | -    return function (array $source) use ($callable): array { | 
                                                        |
| 216 | +    return function(array $source) use ($callable): array { | 
                                                        |
| 217 | 217 | return array_filter($source, $callable);  | 
                                                        
| 218 | 218 | };  | 
                                                        
| 219 | 219 | }  | 
                                                        
@@ -230,7 +230,7 @@ discard block  | 
                                                    ||
| 230 | 230 | * @param array<int|string, mixed> $source Array to filter  | 
                                                        
| 231 | 231 | * @return array<int|string, mixed> Filtered array.  | 
                                                        
| 232 | 232 | */  | 
                                                        
| 233 | -    return function (array $source) use ($callable): array { | 
                                                        |
| 233 | +    return function(array $source) use ($callable): array { | 
                                                        |
| 234 | 234 | return array_filter($source, $callable, \ARRAY_FILTER_USE_KEY);  | 
                                                        
| 235 | 235 | };  | 
                                                        
| 236 | 236 | }  | 
                                                        
@@ -248,7 +248,7 @@ discard block  | 
                                                    ||
| 248 | 248 | * @param array<int|string, mixed> $source Array to filter  | 
                                                        
| 249 | 249 | * @return array<int|string, mixed> Filtered array.  | 
                                                        
| 250 | 250 | */  | 
                                                        
| 251 | -    return function (array $source) use ($callables): array { | 
                                                        |
| 251 | +    return function(array $source) use ($callables): array { | 
                                                        |
| 252 | 252 | return array_filter($source, Comp\groupAnd(...$callables));  | 
                                                        
| 253 | 253 | };  | 
                                                        
| 254 | 254 | }  | 
                                                        
@@ -266,7 +266,7 @@ discard block  | 
                                                    ||
| 266 | 266 | * @param array<int|string, mixed> $source Array to filter  | 
                                                        
| 267 | 267 | * @return array<int|string, mixed> Filtered array.  | 
                                                        
| 268 | 268 | */  | 
                                                        
| 269 | -    return function (array $source) use ($callables): array { | 
                                                        |
| 269 | +    return function(array $source) use ($callables): array { | 
                                                        |
| 270 | 270 | return array_filter($source, Comp\groupOr(...$callables));  | 
                                                        
| 271 | 271 | };  | 
                                                        
| 272 | 272 | }  | 
                                                        
@@ -283,7 +283,7 @@ discard block  | 
                                                    ||
| 283 | 283 | * @param array<int|string, mixed> $array The array to filter  | 
                                                        
| 284 | 284 | * @return mixed|null The first element from the filtered array or null if filter returns empty  | 
                                                        
| 285 | 285 | */  | 
                                                        
| 286 | -    return function (array $array) use ($func) { | 
                                                        |
| 286 | +    return function(array $array) use ($func) { | 
                                                        |
| 287 | 287 | return head(array_filter($array, $func));  | 
                                                        
| 288 | 288 | };  | 
                                                        
| 289 | 289 | }  | 
                                                        
@@ -300,7 +300,7 @@ discard block  | 
                                                    ||
| 300 | 300 | * @param array<int|string, mixed> $array The array to filter  | 
                                                        
| 301 | 301 | * @return mixed|null The last element from the filtered array.  | 
                                                        
| 302 | 302 | */  | 
                                                        
| 303 | -    return function (array $array) use ($func) { | 
                                                        |
| 303 | +    return function(array $array) use ($func) { | 
                                                        |
| 304 | 304 | return tail(array_filter($array, $func));  | 
                                                        
| 305 | 305 | };  | 
                                                        
| 306 | 306 | }  | 
                                                        
@@ -320,7 +320,7 @@ discard block  | 
                                                    ||
| 320 | 320 | * @param array<int|string, mixed> $array The array to filter then map.  | 
                                                        
| 321 | 321 | * @return array<int|string, mixed>  | 
                                                        
| 322 | 322 | */  | 
                                                        
| 323 | -    return function (array $array) use ($filter, $map): array { | 
                                                        |
| 323 | +    return function(array $array) use ($filter, $map): array { | 
                                                        |
| 324 | 324 | return array_map($map, array_filter($array, $filter));  | 
                                                        
| 325 | 325 | };  | 
                                                        
| 326 | 326 | }  | 
                                                        
@@ -337,7 +337,7 @@ discard block  | 
                                                    ||
| 337 | 337 | * @param array<int|string, mixed> $array  | 
                                                        
| 338 | 338 | * @return int Count  | 
                                                        
| 339 | 339 | */  | 
                                                        
| 340 | -    return function (array $array) use ($function) { | 
                                                        |
| 340 | +    return function(array $array) use ($function) { | 
                                                        |
| 341 | 341 | return count(array_filter($array, $function));  | 
                                                        
| 342 | 342 | };  | 
                                                        
| 343 | 343 | }  | 
                                                        
@@ -356,7 +356,7 @@ discard block  | 
                                                    ||
| 356 | 356 | * @param mixed[] $array  | 
                                                        
| 357 | 357 |       * @return array{0:mixed[], 1:mixed[]} | 
                                                        
| 358 | 358 | */  | 
                                                        
| 359 | -    return function (array $array) use ($function): array { | 
                                                        |
| 359 | +    return function(array $array) use ($function): array { | 
                                                        |
| 360 | 360 | return array_reduce(  | 
                                                        
| 361 | 361 | $array,  | 
                                                        
| 362 | 362 | /**  | 
                                                        
@@ -364,12 +364,12 @@ discard block  | 
                                                    ||
| 364 | 364 | * @param mixed $element  | 
                                                        
| 365 | 365 |               * @return array{0:mixed[], 1:mixed[]} | 
                                                        
| 366 | 366 | */  | 
                                                        
| 367 | -            function ($carry, $element) use ($function): array { | 
                                                        |
| 367 | +            function($carry, $element) use ($function): array { | 
                                                        |
| 368 | 368 | $key = (bool) $function($element) ? 1 : 0;  | 
                                                        
| 369 | - $carry[ $key ][] = $element;  | 
                                                        |
| 369 | + $carry[$key][] = $element;  | 
                                                        |
| 370 | 370 | return $carry;  | 
                                                        
| 371 | 371 | },  | 
                                                        
| 372 | - array( array(), array() )  | 
                                                        |
| 372 | + array(array(), array())  | 
                                                        |
| 373 | 373 | );  | 
                                                        
| 374 | 374 | };  | 
                                                        
| 375 | 375 | }  | 
                                                        
@@ -386,7 +386,7 @@ discard block  | 
                                                    ||
| 386 | 386 | * @param mixed[] $array  | 
                                                        
| 387 | 387 | * @return bool  | 
                                                        
| 388 | 388 | */  | 
                                                        
| 389 | -    return function (array $array) use ($function): bool { | 
                                                        |
| 389 | +    return function(array $array) use ($function): bool { | 
                                                        |
| 390 | 390 |          foreach ($array as $value) { | 
                                                        
| 391 | 391 |              if (false === $function($value)) { | 
                                                        
| 392 | 392 | return false;  | 
                                                        
@@ -409,7 +409,7 @@ discard block  | 
                                                    ||
| 409 | 409 | * @param mixed[] $array  | 
                                                        
| 410 | 410 | * @return bool  | 
                                                        
| 411 | 411 | */  | 
                                                        
| 412 | -    return function (array $array) use ($function): bool { | 
                                                        |
| 412 | +    return function(array $array) use ($function): bool { | 
                                                        |
| 413 | 413 |          foreach ($array as $value) { | 
                                                        
| 414 | 414 |              if (true === $function($value)) { | 
                                                        
| 415 | 415 | return true;  | 
                                                        
@@ -440,7 +440,7 @@ discard block  | 
                                                    ||
| 440 | 440 | * @param mixed[] $array The array to map  | 
                                                        
| 441 | 441 | * @return mixed[]  | 
                                                        
| 442 | 442 | */  | 
                                                        
| 443 | -    return function (array $array) use ($func): array { | 
                                                        |
| 443 | +    return function(array $array) use ($func): array { | 
                                                        |
| 444 | 444 | return array_map($func, $array);  | 
                                                        
| 445 | 445 | };  | 
                                                        
| 446 | 446 | }  | 
                                                        
@@ -458,11 +458,11 @@ discard block  | 
                                                    ||
| 458 | 458 | * @param mixed[] $array The array to map  | 
                                                        
| 459 | 459 | * @return mixed[]  | 
                                                        
| 460 | 460 | */  | 
                                                        
| 461 | -    return function (array $array) use ($func): array { | 
                                                        |
| 461 | +    return function(array $array) use ($func): array { | 
                                                        |
| 462 | 462 | return array_reduce(  | 
                                                        
| 463 | 463 | array_keys($array),  | 
                                                        
| 464 | -            function ($carry, $key) use ($func, $array) { | 
                                                        |
| 465 | - $carry[ $func($key) ] = $array[ $key ];  | 
                                                        |
| 464 | +            function($carry, $key) use ($func, $array) { | 
                                                        |
| 465 | + $carry[$func($key)] = $array[$key];  | 
                                                        |
| 466 | 466 | return $carry;  | 
                                                        
| 467 | 467 | },  | 
                                                        
| 468 | 468 | array()  | 
                                                        
@@ -483,9 +483,9 @@ discard block  | 
                                                    ||
| 483 | 483 | * @param mixed[] $array The array to map  | 
                                                        
| 484 | 484 | * @return mixed[]  | 
                                                        
| 485 | 485 | */  | 
                                                        
| 486 | -    return function (array $array) use ($func, $data): array { | 
                                                        |
| 486 | +    return function(array $array) use ($func, $data): array { | 
                                                        |
| 487 | 487 | return array_map(  | 
                                                        
| 488 | -            function ($e) use ($data, $func) { | 
                                                        |
| 488 | +            function($e) use ($data, $func) { | 
                                                        |
| 489 | 489 | return $func($e, ...$data);  | 
                                                        
| 490 | 490 | },  | 
                                                        
| 491 | 491 | $array  | 
                                                        
@@ -505,9 +505,9 @@ discard block  | 
                                                    ||
| 505 | 505 | * @param mixed[] $array The array to map  | 
                                                        
| 506 | 506 | * @return mixed[]  | 
                                                        
| 507 | 507 | */  | 
                                                        
| 508 | -    return function (array $array) use ($func): array { | 
                                                        |
| 508 | +    return function(array $array) use ($func): array { | 
                                                        |
| 509 | 509 | return array_map(  | 
                                                        
| 510 | -            function ($key, $value) use ($func) { | 
                                                        |
| 510 | +            function($key, $value) use ($func) { | 
                                                        |
| 511 | 511 | return $func($value, $key);  | 
                                                        
| 512 | 512 | },  | 
                                                        
| 513 | 513 | $array,  | 
                                                        
@@ -528,9 +528,9 @@ discard block  | 
                                                    ||
| 528 | 528 | * @param mixed[] $array The array to map  | 
                                                        
| 529 | 529 | * @return void  | 
                                                        
| 530 | 530 | */  | 
                                                        
| 531 | -    return function (array $array) use ($func): void { | 
                                                        |
| 531 | +    return function(array $array) use ($func): void { | 
                                                        |
| 532 | 532 | array_map(  | 
                                                        
| 533 | -            function ($key, $value) use ($func) { | 
                                                        |
| 533 | +            function($key, $value) use ($func) { | 
                                                        |
| 534 | 534 | $func($key, $value);  | 
                                                        
| 535 | 535 | },  | 
                                                        
| 536 | 536 | array_keys($array),  | 
                                                        
@@ -552,7 +552,7 @@ discard block  | 
                                                    ||
| 552 | 552 | * @param mixed[] $array  | 
                                                        
| 553 | 553 | * @return mixed[]  | 
                                                        
| 554 | 554 | */  | 
                                                        
| 555 | -    return function (array $array) use ($n, $function): array { | 
                                                        |
| 555 | +    return function(array $array) use ($n, $function) : array { | 
                                                        |
| 556 | 556 | return array_reduce(  | 
                                                        
| 557 | 557 | $array,  | 
                                                        
| 558 | 558 | /**  | 
                                                        
@@ -560,7 +560,7 @@ discard block  | 
                                                    ||
| 560 | 560 | * @param mixed $element  | 
                                                        
| 561 | 561 | * @return mixed[]  | 
                                                        
| 562 | 562 | */  | 
                                                        
| 563 | -            function (array $carry, $element) use ($n, $function): array { | 
                                                        |
| 563 | +            function(array $carry, $element) use ($n, $function) : array { | 
                                                        |
| 564 | 564 |                  if (is_array($element) && (is_null($n) || $n > 0)) { | 
                                                        
| 565 | 565 | $carry = array_merge($carry, flatMap($function, $n ? $n - 1 : null)($element));  | 
                                                        
| 566 | 566 |                  } else { | 
                                                        
@@ -592,7 +592,7 @@ discard block  | 
                                                    ||
| 592 | 592 | * @param mixed[] $array The array to be grouped  | 
                                                        
| 593 | 593 | * @return mixed[] Grouped array.  | 
                                                        
| 594 | 594 | */  | 
                                                        
| 595 | -    return function (array $array) use ($function): array { | 
                                                        |
| 595 | +    return function(array $array) use ($function): array { | 
                                                        |
| 596 | 596 | return array_reduce(  | 
                                                        
| 597 | 597 | $array,  | 
                                                        
| 598 | 598 | /**  | 
                                                        
@@ -600,8 +600,8 @@ discard block  | 
                                                    ||
| 600 | 600 | * @param mixed $element  | 
                                                        
| 601 | 601 | * @return mixed[]  | 
                                                        
| 602 | 602 | */  | 
                                                        
| 603 | -            function ($carry, $item) use ($function): array { | 
                                                        |
| 604 | - $carry[ call_user_func($function, $item) ][] = $item;  | 
                                                        |
| 603 | +            function($carry, $item) use ($function): array { | 
                                                        |
| 604 | + $carry[call_user_func($function, $item)][] = $item;  | 
                                                        |
| 605 | 605 | return $carry;  | 
                                                        
| 606 | 606 | },  | 
                                                        
| 607 | 607 | array()  | 
                                                        
@@ -622,7 +622,7 @@ discard block  | 
                                                    ||
| 622 | 622 | * @param mixed[] $array Array to chunk  | 
                                                        
| 623 | 623 | * @return mixed[]  | 
                                                        
| 624 | 624 | */  | 
                                                        
| 625 | -    return function (array $array) use ($count, $preserveKeys): array { | 
                                                        |
| 625 | +    return function(array $array) use ($count, $preserveKeys): array { | 
                                                        |
| 626 | 626 | return array_chunk($array, max(1, $count), $preserveKeys);  | 
                                                        
| 627 | 627 | };  | 
                                                        
| 628 | 628 | }  | 
                                                        
@@ -640,7 +640,7 @@ discard block  | 
                                                    ||
| 640 | 640 | * @param mixed[] $array  | 
                                                        
| 641 | 641 | * @return mixed[]  | 
                                                        
| 642 | 642 | */  | 
                                                        
| 643 | -    return function (array $array) use ($column, $key): array { | 
                                                        |
| 643 | +    return function(array $array) use ($column, $key) : array { | 
                                                        |
| 644 | 644 | return array_column($array, $column, $key);  | 
                                                        
| 645 | 645 | };  | 
                                                        
| 646 | 646 | }  | 
                                                        
@@ -657,7 +657,7 @@ discard block  | 
                                                    ||
| 657 | 657 | * @param mixed[] $array Array to flatten  | 
                                                        
| 658 | 658 | * @return mixed[]  | 
                                                        
| 659 | 659 | */  | 
                                                        
| 660 | -    return function (array $array) use ($n): array { | 
                                                        |
| 660 | +    return function(array $array) use ($n) : array { | 
                                                        |
| 661 | 661 | return array_reduce(  | 
                                                        
| 662 | 662 | $array,  | 
                                                        
| 663 | 663 | /**  | 
                                                        
@@ -665,7 +665,7 @@ discard block  | 
                                                    ||
| 665 | 665 | * @param mixed|mixed[] $element  | 
                                                        
| 666 | 666 | * @return array<int|string, mixed>  | 
                                                        
| 667 | 667 | */  | 
                                                        
| 668 | -            function (array $carry, $element) use ($n): array { | 
                                                        |
| 668 | +            function(array $carry, $element) use ($n) : array { | 
                                                        |
| 669 | 669 | // Remove empty arrays.  | 
                                                        
| 670 | 670 |                  if (is_array($element) && empty($element)) { | 
                                                        
| 671 | 671 | return $carry;  | 
                                                        
@@ -696,7 +696,7 @@ discard block  | 
                                                    ||
| 696 | 696 | * @param mixed[] $array The array to have elements replaced from.  | 
                                                        
| 697 | 697 | * @return mixed[] Array with replacements.  | 
                                                        
| 698 | 698 | */  | 
                                                        
| 699 | -    return function (array $array) use ($with): array { | 
                                                        |
| 699 | +    return function(array $array) use ($with): array { | 
                                                        |
| 700 | 700 | return array_replace_recursive($array, ...$with);  | 
                                                        
| 701 | 701 | };  | 
                                                        
| 702 | 702 | }  | 
                                                        
@@ -713,7 +713,7 @@ discard block  | 
                                                    ||
| 713 | 713 | * @param mixed[] $array The array to have elements replaced from.  | 
                                                        
| 714 | 714 | * @return mixed[] Array with replacements.  | 
                                                        
| 715 | 715 | */  | 
                                                        
| 716 | -    return function (array $array) use ($with): array { | 
                                                        |
| 716 | +    return function(array $array) use ($with): array { | 
                                                        |
| 717 | 717 | return array_replace($array, ...$with);  | 
                                                        
| 718 | 718 | };  | 
                                                        
| 719 | 719 | }  | 
                                                        
@@ -730,7 +730,7 @@ discard block  | 
                                                    ||
| 730 | 730 | * @param mixed[] $array Array to do sum() on.  | 
                                                        
| 731 | 731 | * @return Number The total.  | 
                                                        
| 732 | 732 | */  | 
                                                        
| 733 | -    return function (array $array) use ($function) { | 
                                                        |
| 733 | +    return function(array $array) use ($function) { | 
                                                        |
| 734 | 734 | return array_sum(array_map($function, $array));  | 
                                                        
| 735 | 735 | };  | 
                                                        
| 736 | 736 | }  | 
                                                        
@@ -749,7 +749,7 @@ discard block  | 
                                                    ||
| 749 | 749 | $object = $object ?? new stdClass();  | 
                                                        
| 750 | 750 | |
| 751 | 751 | // Throws an exception if $object is not an object.  | 
                                                        
| 752 | -    if (! is_object($object)) { | 
                                                        |
| 752 | +    if (!is_object($object)) { | 
                                                        |
| 753 | 753 |          throw new \InvalidArgumentException('Object must be an object.'); | 
                                                        
| 754 | 754 | }  | 
                                                        
| 755 | 755 | |
@@ -757,10 +757,10 @@ discard block  | 
                                                    ||
| 757 | 757 | * @param mixed[] $array  | 
                                                        
| 758 | 758 | * @return object  | 
                                                        
| 759 | 759 | */  | 
                                                        
| 760 | -    return function (array $array) use ($object) { | 
                                                        |
| 760 | +    return function(array $array) use ($object) { | 
                                                        |
| 761 | 761 |          foreach ($array as $key => $value) { | 
                                                        
| 762 | 762 | // If key is not a string or numerical, skip it.  | 
                                                        
| 763 | -            if (! is_string($key) || is_numeric($key)) { | 
                                                        |
| 763 | +            if (!is_string($key) || is_numeric($key)) { | 
                                                        |
| 764 | 764 | continue;  | 
                                                        
| 765 | 765 | }  | 
                                                        
| 766 | 766 | |
@@ -793,7 +793,7 @@ discard block  | 
                                                    ||
| 793 | 793 | * @param mixed $data  | 
                                                        
| 794 | 794 | * @return string|null  | 
                                                        
| 795 | 795 | */  | 
                                                        
| 796 | -    return function ($data) use ($flags, $depth): ?string { | 
                                                        |
| 796 | +    return function($data) use ($flags, $depth): ?string { | 
                                                        |
| 797 | 797 | return \json_encode($data, $flags, max(1, $depth)) ?: null;  | 
                                                        
| 798 | 798 | };  | 
                                                        
| 799 | 799 | }  | 
                                                        
@@ -819,7 +819,7 @@ discard block  | 
                                                    ||
| 819 | 819 | * @param mixed[]$array The array to sort  | 
                                                        
| 820 | 820 | * @return mixed[] The sorted array (new array)  | 
                                                        
| 821 | 821 | */  | 
                                                        
| 822 | -    return function (array $array) use ($flag) { | 
                                                        |
| 822 | +    return function(array $array) use ($flag) { | 
                                                        |
| 823 | 823 | \sort($array, $flag);  | 
                                                        
| 824 | 824 | return $array;  | 
                                                        
| 825 | 825 | };  | 
                                                        
@@ -838,7 +838,7 @@ discard block  | 
                                                    ||
| 838 | 838 | * @param mixed[]$array The array to sort  | 
                                                        
| 839 | 839 | * @return mixed[] The sorted array (new array)  | 
                                                        
| 840 | 840 | */  | 
                                                        
| 841 | -    return function (array $array) use ($flag) { | 
                                                        |
| 841 | +    return function(array $array) use ($flag) { | 
                                                        |
| 842 | 842 | \rsort($array, $flag);  | 
                                                        
| 843 | 843 | return $array;  | 
                                                        
| 844 | 844 | };  | 
                                                        
@@ -857,7 +857,7 @@ discard block  | 
                                                    ||
| 857 | 857 | * @param mixed[]$array The array to sort  | 
                                                        
| 858 | 858 | * @return mixed[] The sorted array (new array)  | 
                                                        
| 859 | 859 | */  | 
                                                        
| 860 | -    return function (array $array) use ($flag) { | 
                                                        |
| 860 | +    return function(array $array) use ($flag) { | 
                                                        |
| 861 | 861 | \ksort($array, $flag);  | 
                                                        
| 862 | 862 | return $array;  | 
                                                        
| 863 | 863 | };  | 
                                                        
@@ -875,7 +875,7 @@ discard block  | 
                                                    ||
| 875 | 875 | * @param mixed[]$array The array to sort  | 
                                                        
| 876 | 876 | * @return mixed[] The sorted array (new array)  | 
                                                        
| 877 | 877 | */  | 
                                                        
| 878 | -    return function (array $array) use ($flag) { | 
                                                        |
| 878 | +    return function(array $array) use ($flag) { | 
                                                        |
| 879 | 879 | \krsort($array, $flag);  | 
                                                        
| 880 | 880 | return $array;  | 
                                                        
| 881 | 881 | };  | 
                                                        
@@ -894,7 +894,7 @@ discard block  | 
                                                    ||
| 894 | 894 | * @param mixed[]$array The array to sort  | 
                                                        
| 895 | 895 | * @return mixed[] The sorted array (new array)  | 
                                                        
| 896 | 896 | */  | 
                                                        
| 897 | -    return function (array $array) use ($flag) { | 
                                                        |
| 897 | +    return function(array $array) use ($flag) { | 
                                                        |
| 898 | 898 | \asort($array, $flag);  | 
                                                        
| 899 | 899 | return $array;  | 
                                                        
| 900 | 900 | };  | 
                                                        
@@ -913,7 +913,7 @@ discard block  | 
                                                    ||
| 913 | 913 | * @param mixed[]$array The array to sort  | 
                                                        
| 914 | 914 | * @return mixed[] The sorted array (new array)  | 
                                                        
| 915 | 915 | */  | 
                                                        
| 916 | -    return function (array $array) use ($flag) { | 
                                                        |
| 916 | +    return function(array $array) use ($flag) { | 
                                                        |
| 917 | 917 | \arsort($array, $flag);  | 
                                                        
| 918 | 918 | return $array;  | 
                                                        
| 919 | 919 | };  | 
                                                        
@@ -930,7 +930,7 @@ discard block  | 
                                                    ||
| 930 | 930 | * @param mixed[]$array The array to sort  | 
                                                        
| 931 | 931 | * @return mixed[] The sorted array (new array)  | 
                                                        
| 932 | 932 | */  | 
                                                        
| 933 | -    return function (array $array) { | 
                                                        |
| 933 | +    return function(array $array) { | 
                                                        |
| 934 | 934 | \natsort($array);  | 
                                                        
| 935 | 935 | return $array;  | 
                                                        
| 936 | 936 | };  | 
                                                        
@@ -947,7 +947,7 @@ discard block  | 
                                                    ||
| 947 | 947 | * @param mixed[]$array The array to sort  | 
                                                        
| 948 | 948 | * @return mixed[] The sorted array (new array)  | 
                                                        
| 949 | 949 | */  | 
                                                        
| 950 | -    return function (array $array) { | 
                                                        |
| 950 | +    return function(array $array) { | 
                                                        |
| 951 | 951 | \natcasesort($array);  | 
                                                        
| 952 | 952 | return $array;  | 
                                                        
| 953 | 953 | };  | 
                                                        
@@ -965,7 +965,7 @@ discard block  | 
                                                    ||
| 965 | 965 | * @param mixed[] $array The array to sort  | 
                                                        
| 966 | 966 | * @return mixed[] The sorted array (new array)  | 
                                                        
| 967 | 967 | */  | 
                                                        
| 968 | -    return function (array $array) use ($function) { | 
                                                        |
| 968 | +    return function(array $array) use ($function) { | 
                                                        |
| 969 | 969 | \uksort($array, $function);  | 
                                                        
| 970 | 970 | return $array;  | 
                                                        
| 971 | 971 | };  | 
                                                        
@@ -984,7 +984,7 @@ discard block  | 
                                                    ||
| 984 | 984 | * @param mixed[]$array The array to sort  | 
                                                        
| 985 | 985 | * @return mixed[] The sorted array (new array)  | 
                                                        
| 986 | 986 | */  | 
                                                        
| 987 | -    return function (array $array) use ($function) { | 
                                                        |
| 987 | +    return function(array $array) use ($function) { | 
                                                        |
| 988 | 988 | \uasort($array, $function);  | 
                                                        
| 989 | 989 | return $array;  | 
                                                        
| 990 | 990 | };  | 
                                                        
@@ -1004,7 +1004,7 @@ discard block  | 
                                                    ||
| 1004 | 1004 | * @param mixed[]$array The array to sort  | 
                                                        
| 1005 | 1005 | * @return mixed[] The sorted array (new array)  | 
                                                        
| 1006 | 1006 | */  | 
                                                        
| 1007 | -    return function (array $array) use ($function) { | 
                                                        |
| 1007 | +    return function(array $array) use ($function) { | 
                                                        |
| 1008 | 1008 | \usort($array, $function);  | 
                                                        
| 1009 | 1009 | return $array;  | 
                                                        
| 1010 | 1010 | };  | 
                                                        
@@ -1019,7 +1019,7 @@ discard block  | 
                                                    ||
| 1019 | 1019 | */  | 
                                                        
| 1020 | 1020 | function scan(callable $function, $initialValue): Closure  | 
                                                        
| 1021 | 1021 |  { | 
                                                        
| 1022 | -    return function (array $array) use ($function, $initialValue) { | 
                                                        |
| 1022 | +    return function(array $array) use ($function, $initialValue) { | 
                                                        |
| 1023 | 1023 | $carry[] = $initialValue;  | 
                                                        
| 1024 | 1024 |          foreach ($array as $key => $value) { | 
                                                        
| 1025 | 1025 | $initialValue = $function($initialValue, $value);  | 
                                                        
@@ -1038,7 +1038,7 @@ discard block  | 
                                                    ||
| 1038 | 1038 | */  | 
                                                        
| 1039 | 1039 | function scanR(callable $function, $initialValue): Closure  | 
                                                        
| 1040 | 1040 |  { | 
                                                        
| 1041 | -    return function (array $array) use ($function, $initialValue) { | 
                                                        |
| 1041 | +    return function(array $array) use ($function, $initialValue) { | 
                                                        |
| 1042 | 1042 | $carry[] = $initialValue;  | 
                                                        
| 1043 | 1043 |          foreach (array_reverse($array) as $key => $value) { | 
                                                        
| 1044 | 1044 | $initialValue = $function($initialValue, $value);  | 
                                                        
@@ -1061,7 +1061,7 @@ discard block  | 
                                                    ||
| 1061 | 1061 | * @param mixed[] $array  | 
                                                        
| 1062 | 1062 | * @return mixed  | 
                                                        
| 1063 | 1063 | */  | 
                                                        
| 1064 | -    return function (array $array) use ($callable, $initial) { | 
                                                        |
| 1064 | +    return function(array $array) use ($callable, $initial) { | 
                                                        |
| 1065 | 1065 | return array_reduce($array, $callable, $initial);  | 
                                                        
| 1066 | 1066 | };  | 
                                                        
| 1067 | 1067 | }  | 
                                                        
@@ -1079,7 +1079,7 @@ discard block  | 
                                                    ||
| 1079 | 1079 | * @param mixed[] $array  | 
                                                        
| 1080 | 1080 | * @return mixed  | 
                                                        
| 1081 | 1081 | */  | 
                                                        
| 1082 | -    return function (array $array) use ($callable, $initial) { | 
                                                        |
| 1082 | +    return function(array $array) use ($callable, $initial) { | 
                                                        |
| 1083 | 1083 | return array_reduce(\array_reverse($array), $callable, $initial);  | 
                                                        
| 1084 | 1084 | };  | 
                                                        
| 1085 | 1085 | }  | 
                                                        
@@ -1098,7 +1098,7 @@ discard block  | 
                                                    ||
| 1098 | 1098 | * @param mixed[] $array  | 
                                                        
| 1099 | 1099 | * @return mixed  | 
                                                        
| 1100 | 1100 | */  | 
                                                        
| 1101 | -    return function (array $array) use ($callable, $initial) { | 
                                                        |
| 1101 | +    return function(array $array) use ($callable, $initial) { | 
                                                        |
| 1102 | 1102 |          foreach ($array as $key => $value) { | 
                                                        
| 1103 | 1103 | $initial = $callable($initial, $key, $value);  | 
                                                        
| 1104 | 1104 | }  | 
                                                        
@@ -1124,7 +1124,7 @@ discard block  | 
                                                    ||
| 1124 | 1124 | * @param mixed[] $array  | 
                                                        
| 1125 | 1125 | * @return mixed[]  | 
                                                        
| 1126 | 1126 | */  | 
                                                        
| 1127 | -    return function (array $array) use ($count) { | 
                                                        |
| 1127 | +    return function(array $array) use ($count) { | 
                                                        |
| 1128 | 1128 | return \array_slice($array, 0, $count);  | 
                                                        
| 1129 | 1129 | };  | 
                                                        
| 1130 | 1130 | }  | 
                                                        
@@ -1145,7 +1145,7 @@ discard block  | 
                                                    ||
| 1145 | 1145 | |
| 1146 | 1146 | // If count is 0, return an empty array  | 
                                                        
| 1147 | 1147 |      if ($count === 0) { | 
                                                        
| 1148 | -        return function (array $array) { | 
                                                        |
| 1148 | +        return function(array $array) { | 
                                                        |
| 1149 | 1149 | return array();  | 
                                                        
| 1150 | 1150 | };  | 
                                                        
| 1151 | 1151 | }  | 
                                                        
@@ -1154,7 +1154,7 @@ discard block  | 
                                                    ||
| 1154 | 1154 | * @param mixed[] $array  | 
                                                        
| 1155 | 1155 | * @return mixed[]  | 
                                                        
| 1156 | 1156 | */  | 
                                                        
| 1157 | -    return function (array $array) use ($count) { | 
                                                        |
| 1157 | +    return function(array $array) use ($count) { | 
                                                        |
| 1158 | 1158 | return \array_slice($array, - $count);  | 
                                                        
| 1159 | 1159 | };  | 
                                                        
| 1160 | 1160 | }  | 
                                                        
@@ -1172,13 +1172,13 @@ discard block  | 
                                                    ||
| 1172 | 1172 | * @param mixed[] $array  | 
                                                        
| 1173 | 1173 | * @return mixed[]  | 
                                                        
| 1174 | 1174 | */  | 
                                                        
| 1175 | -    return function (array $array) use ($conditional) { | 
                                                        |
| 1175 | +    return function(array $array) use ($conditional) { | 
                                                        |
| 1176 | 1176 | $carry = array();  | 
                                                        
| 1177 | 1177 |          foreach ($array as $key => $value) { | 
                                                        
| 1178 | 1178 |              if (true === $conditional($value)) { | 
                                                        
| 1179 | 1179 | break;  | 
                                                        
| 1180 | 1180 | }  | 
                                                        
| 1181 | - $carry[ $key ] = $value;  | 
                                                        |
| 1181 | + $carry[$key] = $value;  | 
                                                        |
| 1182 | 1182 | }  | 
                                                        
| 1183 | 1183 | return $carry;  | 
                                                        
| 1184 | 1184 | };  | 
                                                        
@@ -1197,13 +1197,13 @@ discard block  | 
                                                    ||
| 1197 | 1197 | * @param mixed[] $array  | 
                                                        
| 1198 | 1198 | * @return mixed[]  | 
                                                        
| 1199 | 1199 | */  | 
                                                        
| 1200 | -    return function (array $array) use ($conditional) { | 
                                                        |
| 1200 | +    return function(array $array) use ($conditional) { | 
                                                        |
| 1201 | 1201 | $carry = array();  | 
                                                        
| 1202 | 1202 |          foreach ($array as $key => $value) { | 
                                                        
| 1203 | 1203 |              if (false === $conditional($value)) { | 
                                                        
| 1204 | 1204 | break;  | 
                                                        
| 1205 | 1205 | }  | 
                                                        
| 1206 | - $carry[ $key ] = $value;  | 
                                                        |
| 1206 | + $carry[$key] = $value;  | 
                                                        |
| 1207 | 1207 | }  | 
                                                        
| 1208 | 1208 | return $carry;  | 
                                                        
| 1209 | 1209 | };  |