Passed
Pull Request — develop (#64)
by Glynn
02:31
created
src/arrays.php 1 patch
Spacing   +77 added lines, -77 removed lines patch added patch discarded remove patch
@@ -46,7 +46,7 @@  discard block
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
 block discarded – undo
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
     };
Please login to merge, or discard this patch.