Passed
Push — develop ( 043d9e...f86ba6 )
by Glynn
04:23 queued 01:54
created
src/arrays.php 1 patch
Spacing   +71 added lines, -71 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
@@ -506,7 +506,7 @@  discard block
 block discarded – undo
506 506
      * @param mixed[] $array
507 507
      * @return mixed[]
508 508
      */
509
-    return function (array $array) use ($n, $function): array {
509
+    return function(array $array) use ($n, $function) : array {
510 510
         return array_reduce(
511 511
             $array,
512 512
             /**
@@ -514,7 +514,7 @@  discard block
 block discarded – undo
514 514
              * @param mixed $element
515 515
              * @return mixed[]
516 516
              */
517
-            function (array $carry, $element) use ($n, $function): array {
517
+            function(array $carry, $element) use ($n, $function) : array {
518 518
                 if (is_array($element) && (is_null($n) || $n > 0)) {
519 519
                     $carry = array_merge($carry, flatMap($function, $n ? $n - 1 : null)($element));
520 520
                 } else {
@@ -546,7 +546,7 @@  discard block
 block discarded – undo
546 546
      * @param mixed[] $array The array to be grouped
547 547
      * @return mixed[] Grouped array.
548 548
      */
549
-    return function (array $array) use ($function): array {
549
+    return function(array $array) use ($function): array {
550 550
         return array_reduce(
551 551
             $array,
552 552
             /**
@@ -554,8 +554,8 @@  discard block
 block discarded – undo
554 554
              * @param mixed $element
555 555
              * @return mixed[]
556 556
              */
557
-            function ($carry, $item) use ($function): array {
558
-                $carry[ call_user_func($function, $item) ][] = $item;
557
+            function($carry, $item) use ($function): array {
558
+                $carry[call_user_func($function, $item)][] = $item;
559 559
                 return $carry;
560 560
             },
561 561
             array()
@@ -576,7 +576,7 @@  discard block
 block discarded – undo
576 576
      * @param mixed[] $array Array to chunk
577 577
      * @return mixed[]
578 578
      */
579
-    return function (array $array) use ($count, $preserveKeys): array {
579
+    return function(array $array) use ($count, $preserveKeys): array {
580 580
         return array_chunk($array, max(1, $count), $preserveKeys);
581 581
     };
582 582
 }
@@ -594,7 +594,7 @@  discard block
 block discarded – undo
594 594
      * @param mixed[] $array
595 595
      * @return mixed[]
596 596
      */
597
-    return function (array $array) use ($column, $key): array {
597
+    return function(array $array) use ($column, $key) : array {
598 598
         return array_column($array, $column, $key);
599 599
     };
600 600
 }
@@ -611,7 +611,7 @@  discard block
 block discarded – undo
611 611
      * @param mixed[] $array Array to flatten
612 612
      * @return mixed[]
613 613
      */
614
-    return function (array $array) use ($n): array {
614
+    return function(array $array) use ($n) : array {
615 615
         return array_reduce(
616 616
             $array,
617 617
             /**
@@ -619,7 +619,7 @@  discard block
 block discarded – undo
619 619
              * @param mixed|mixed[] $element
620 620
              * @return array<int|string, mixed>
621 621
              */
622
-            function (array $carry, $element) use ($n): array {
622
+            function(array $carry, $element) use ($n) : array {
623 623
                 // Remove empty arrays.
624 624
                 if (is_array($element) && empty($element)) {
625 625
                     return $carry;
@@ -650,7 +650,7 @@  discard block
 block discarded – undo
650 650
      * @param mixed[] $array The array to have elements replaced from.
651 651
      * @return mixed[] Array with replacements.
652 652
      */
653
-    return function (array $array) use ($with): array {
653
+    return function(array $array) use ($with): array {
654 654
         return array_replace_recursive($array, ...$with);
655 655
     };
656 656
 }
@@ -667,7 +667,7 @@  discard block
 block discarded – undo
667 667
      * @param mixed[] $array The array to have elements replaced from.
668 668
      * @return mixed[] Array with replacements.
669 669
      */
670
-    return function (array $array) use ($with): array {
670
+    return function(array $array) use ($with): array {
671 671
         return array_replace($array, ...$with);
672 672
     };
673 673
 }
@@ -684,7 +684,7 @@  discard block
 block discarded – undo
684 684
      * @param mixed[] $array Array to do sum() on.
685 685
      * @return Number The total.
686 686
      */
687
-    return function (array $array) use ($function) {
687
+    return function(array $array) use ($function) {
688 688
         return array_sum(array_map($function, $array));
689 689
     };
690 690
 }
@@ -705,7 +705,7 @@  discard block
 block discarded – undo
705 705
      * @param mixed[] $array
706 706
      * @return object
707 707
      */
708
-    return function (array $array) use ($object): object {
708
+    return function(array $array) use ($object): object {
709 709
         foreach ($array as $key => $value) {
710 710
             $key            = is_string($key) ? $key : (string) $key;
711 711
             $object->{$key} = $value;
@@ -733,7 +733,7 @@  discard block
 block discarded – undo
733 733
      * @param mixed $data
734 734
      * @return string|null
735 735
      */
736
-    return function ($data) use ($flags, $depth): ?string {
736
+    return function($data) use ($flags, $depth): ?string {
737 737
         return \json_encode($data, $flags, max(1, $depth)) ?: null;
738 738
     };
739 739
 }
@@ -759,7 +759,7 @@  discard block
 block discarded – undo
759 759
      *  @param mixed[]$array The array to sort
760 760
      *  @return mixed[] The sorted array (new array)
761 761
      */
762
-    return function (array $array) use ($flag) {
762
+    return function(array $array) use ($flag) {
763 763
         \sort($array, $flag);
764 764
         return $array;
765 765
     };
@@ -778,7 +778,7 @@  discard block
 block discarded – undo
778 778
      *  @param mixed[]$array The array to sort
779 779
      *  @return mixed[] The sorted array (new array)
780 780
      */
781
-    return function (array $array) use ($flag) {
781
+    return function(array $array) use ($flag) {
782 782
         \rsort($array, $flag);
783 783
         return $array;
784 784
     };
@@ -797,7 +797,7 @@  discard block
 block discarded – undo
797 797
      *  @param mixed[]$array The array to sort
798 798
      *  @return mixed[] The sorted array (new array)
799 799
      */
800
-    return function (array $array) use ($flag) {
800
+    return function(array $array) use ($flag) {
801 801
         \ksort($array, $flag);
802 802
         return $array;
803 803
     };
@@ -815,7 +815,7 @@  discard block
 block discarded – undo
815 815
      *  @param mixed[]$array The array to sort
816 816
      *  @return mixed[] The sorted array (new array)
817 817
      */
818
-    return function (array $array) use ($flag) {
818
+    return function(array $array) use ($flag) {
819 819
         \krsort($array, $flag);
820 820
         return $array;
821 821
     };
@@ -834,7 +834,7 @@  discard block
 block discarded – undo
834 834
      *  @param mixed[]$array The array to sort
835 835
      *  @return mixed[] The sorted array (new array)
836 836
      */
837
-    return function (array $array) use ($flag) {
837
+    return function(array $array) use ($flag) {
838 838
         \asort($array, $flag);
839 839
         return $array;
840 840
     };
@@ -853,7 +853,7 @@  discard block
 block discarded – undo
853 853
      *  @param mixed[]$array The array to sort
854 854
      *  @return mixed[] The sorted array (new array)
855 855
      */
856
-    return function (array $array) use ($flag) {
856
+    return function(array $array) use ($flag) {
857 857
         \arsort($array, $flag);
858 858
         return $array;
859 859
     };
@@ -870,7 +870,7 @@  discard block
 block discarded – undo
870 870
      *  @param mixed[]$array The array to sort
871 871
      *  @return mixed[] The sorted array (new array)
872 872
      */
873
-    return function (array $array) {
873
+    return function(array $array) {
874 874
         \natsort($array);
875 875
         return $array;
876 876
     };
@@ -887,7 +887,7 @@  discard block
 block discarded – undo
887 887
      *  @param mixed[]$array The array to sort
888 888
      *  @return mixed[] The sorted array (new array)
889 889
      */
890
-    return function (array $array) {
890
+    return function(array $array) {
891 891
         \natcasesort($array);
892 892
         return $array;
893 893
     };
@@ -905,7 +905,7 @@  discard block
 block discarded – undo
905 905
      *  @param mixed[] $array The array to sort
906 906
      *  @return mixed[] The sorted array (new array)
907 907
      */
908
-    return function (array $array) use ($function) {
908
+    return function(array $array) use ($function) {
909 909
         \uksort($array, $function);
910 910
         return $array;
911 911
     };
@@ -924,7 +924,7 @@  discard block
 block discarded – undo
924 924
      *  @param mixed[]$array The array to sort
925 925
      *  @return mixed[] The sorted array (new array)
926 926
      */
927
-    return function (array $array) use ($function) {
927
+    return function(array $array) use ($function) {
928 928
         \uasort($array, $function);
929 929
         return $array;
930 930
     };
@@ -944,7 +944,7 @@  discard block
 block discarded – undo
944 944
      *  @param mixed[]$array The array to sort
945 945
      *  @return mixed[] The sorted array (new array)
946 946
      */
947
-    return function (array $array) use ($function) {
947
+    return function(array $array) use ($function) {
948 948
         \usort($array, $function);
949 949
         return $array;
950 950
     };
@@ -959,7 +959,7 @@  discard block
 block discarded – undo
959 959
  */
960 960
 function scan(callable $function, $initialValue): Closure
961 961
 {
962
-    return function (array $array) use ($function, $initialValue) {
962
+    return function(array $array) use ($function, $initialValue) {
963 963
         $carry[] = $initialValue;
964 964
         foreach ($array as $key => $value) {
965 965
             $initialValue = $function($initialValue, $value);
@@ -978,7 +978,7 @@  discard block
 block discarded – undo
978 978
  */
979 979
 function scanR(callable $function, $initialValue): Closure
980 980
 {
981
-    return function (array $array) use ($function, $initialValue) {
981
+    return function(array $array) use ($function, $initialValue) {
982 982
         $carry[] = $initialValue;
983 983
         foreach (array_reverse($array) as $key => $value) {
984 984
             $initialValue = $function($initialValue, $value);
@@ -1001,7 +1001,7 @@  discard block
 block discarded – undo
1001 1001
      * @param mixed[] $array
1002 1002
      * @return mixed
1003 1003
      */
1004
-    return function (array $array) use ($callable, $initial) {
1004
+    return function(array $array) use ($callable, $initial) {
1005 1005
         return array_reduce($array, $callable, $initial);
1006 1006
     };
1007 1007
 }
@@ -1019,7 +1019,7 @@  discard block
 block discarded – undo
1019 1019
      * @param mixed[] $array
1020 1020
      * @return mixed
1021 1021
      */
1022
-    return function (array $array) use ($callable, $initial) {
1022
+    return function(array $array) use ($callable, $initial) {
1023 1023
         return array_reduce(\array_reverse($array), $callable, $initial);
1024 1024
     };
1025 1025
 }
@@ -1038,7 +1038,7 @@  discard block
 block discarded – undo
1038 1038
      * @param mixed[] $array
1039 1039
      * @return mixed
1040 1040
      */
1041
-    return function (array $array) use ($callable, $initial) {
1041
+    return function(array $array) use ($callable, $initial) {
1042 1042
         foreach ($array as $key => $value) {
1043 1043
             $initial = $callable($initial, $key, $value);
1044 1044
         }
@@ -1064,7 +1064,7 @@  discard block
 block discarded – undo
1064 1064
      * @param mixed[] $array
1065 1065
      * @return mixed[]
1066 1066
      */
1067
-    return function (array $array) use ($count) {
1067
+    return function(array $array) use ($count) {
1068 1068
         return \array_slice($array, 0, $count);
1069 1069
     };
1070 1070
 }
@@ -1085,7 +1085,7 @@  discard block
 block discarded – undo
1085 1085
 
1086 1086
     // If count is 0, return an empty array
1087 1087
     if ($count === 0) {
1088
-        return function (array $array) {
1088
+        return function(array $array) {
1089 1089
             return array();
1090 1090
         };
1091 1091
     }
@@ -1094,7 +1094,7 @@  discard block
 block discarded – undo
1094 1094
      * @param mixed[] $array
1095 1095
      * @return mixed[]
1096 1096
      */
1097
-    return function (array $array) use ($count) {
1097
+    return function(array $array) use ($count) {
1098 1098
         return \array_slice($array, - $count);
1099 1099
     };
1100 1100
 }
@@ -1112,13 +1112,13 @@  discard block
 block discarded – undo
1112 1112
      * @param mixed[] $array
1113 1113
      * @return mixed[]
1114 1114
      */
1115
-    return function (array $array) use ($conditional) {
1115
+    return function(array $array) use ($conditional) {
1116 1116
         $carry = array();
1117 1117
         foreach ($array as $key => $value) {
1118 1118
             if (true === $conditional($value)) {
1119 1119
                 break;
1120 1120
             }
1121
-            $carry[ $key ] = $value;
1121
+            $carry[$key] = $value;
1122 1122
         }
1123 1123
         return $carry;
1124 1124
     };
@@ -1137,13 +1137,13 @@  discard block
 block discarded – undo
1137 1137
      * @param mixed[] $array
1138 1138
      * @return mixed[]
1139 1139
      */
1140
-    return function (array $array) use ($conditional) {
1140
+    return function(array $array) use ($conditional) {
1141 1141
         $carry = array();
1142 1142
         foreach ($array as $key => $value) {
1143 1143
             if (false === $conditional($value)) {
1144 1144
                 break;
1145 1145
             }
1146
-            $carry[ $key ] = $value;
1146
+            $carry[$key] = $value;
1147 1147
         }
1148 1148
         return $carry;
1149 1149
     };
Please login to merge, or discard this patch.