gin0115 / pinkcrab_function_constructors

src/arrays.php

Indentation +543 added lines, -543 removed lines

@@ -41,14 +41,14 @@ 
  * @return Closure(mixed):array<int|string, mixed>
  */
 function pushHead( array $array ): Closure {
-	/**
-	 * @param mixed $value Adds value start of array.
-	 * @return array New array with value on head.
-	 */
-	return function ( $value ) use ( $array ): array {
-		array_unshift( $array, $value );
-		return $array;
-	};
+    /**
+     * @param mixed $value Adds value start of array.
+     * @return array New array with value on head.
+     */
+    return function ( $value ) use ( $array ): array {
+        array_unshift( $array, $value );
+        return $array;
+    };
 }
 
 /**
@@ -58,14 +58,14 @@ 
  * @return Closure(mixed):array<int|string, mixed>
  */
 function pushTail( array $array ): Closure {
-	/**
-	 * @param mixed $value Adds value end of array.
-	 * @return array<int|string, mixed> New array with value on tail.
-	 */
-	return function ( $value ) use ( $array ): array {
-		$array[] = $value;
-		return $array;
-	};
+    /**
+     * @param mixed $value Adds value end of array.
+     * @return array<int|string, mixed> New array with value on tail.
+     */
+    return function ( $value ) use ( $array ): array {
+        $array[] = $value;
+        return $array;
+    };
 }
 
 /**
@@ -75,7 +75,7 @@ 
  * @return mixed Will return the first value is array is not empty, else null.
  */
 function head( array $array ) {
-	return ! empty( $array ) ? array_values( $array )[0] : null;
+    return ! empty( $array ) ? array_values( $array )[0] : null;
 }
 
 /**
@@ -85,7 +85,7 @@ 
  * @return mixed Will return the last value is array is not empty, else null.
  */
 function tail( array $array ) {
-	return ! empty( $array ) ? array_reverse( $array, false )[0] : null;
+    return ! empty( $array ) ? array_reverse( $array, false )[0] : null;
 }
 
 
@@ -97,13 +97,13 @@ 
  *
  */
 function toString( ?string $glue = null ): Closure {
-	/**
-	 * @param array<int|string, mixed> $array Array join
-	 * @return string.
-	 */
-	return function ( array $array ) use ( $glue ): string {
-		return $glue ? \join( $glue, $array ) : \join( $array );
-	};
+    /**
+     * @param array<int|string, mixed> $array Array join
+     * @return string.
+     */
+    return function ( array $array ) use ( $glue ): string {
+        return $glue ? \join( $glue, $array ) : \join( $array );
+    };
 }
 
 /**
@@ -115,21 +115,21 @@ 
  *
  */
 function zip( array $additional, $default = null ): Closure {
-	$additional = array_values( $additional );
-	return function ( array $array ) use ( $additional, $default ) {
-		$array = array_values( $array );
-		return array_reduce(
-			array_keys( $array ),
-			function ( $carry, $key ) use ( $array, $additional, $default ): array {
-				$carry[] = array(
-					$array[ $key ],
-					array_key_exists( $key, $additional ) ? $additional[ $key ] : $default,
-				);
-				return $carry;
-			},
-			array()
-		);
-	};
+    $additional = array_values( $additional );
+    return function ( array $array ) use ( $additional, $default ) {
+        $array = array_values( $array );
+        return array_reduce(
+            array_keys( $array ),
+            function ( $carry, $key ) use ( $array, $additional, $default ): array {
+                $carry[] = array(
+                    $array[ $key ],
+                    array_key_exists( $key, $additional ) ? $additional[ $key ] : $default,
+                );
+                return $carry;
+            },
+            array()
+        );
+    };
 }
 
 
@@ -148,16 +148,16 @@ 
  * @return Closure
  */
 function arrayCompiler( array $inital = array() ): Closure {
-	/**
-	 * @param mixed $value Adds value to inner array if value set, else returns.
-	 * @return mixed[]|Closure
-	 */
-	return function ( $value = null ) use ( $inital ) {
-		if ( $value ) {
-			$inital[] = $value;
-		}
-		return ! is_null( $value ) ? arrayCompiler( $inital ) : $inital;
-	};
+    /**
+     * @param mixed $value Adds value to inner array if value set, else returns.
+     * @return mixed[]|Closure
+     */
+    return function ( $value = null ) use ( $inital ) {
+        if ( $value ) {
+            $inital[] = $value;
+        }
+        return ! is_null( $value ) ? arrayCompiler( $inital ) : $inital;
+    };
 }
 
 /**
@@ -169,19 +169,19 @@ 
  * @return Closure
  */
 function arrayCompilerTyped( callable $validator, array $inital = array() ): Closure {
-	// Ensure all is validated from initial.
-	$inital = array_filter( $inital, $validator );
-
-	/**
-	 * @param mixed $value
-	 * @return mixed[]|Closure
-	 */
-	return function ( $value = null ) use ( $validator, $inital ) {
-		if ( ! is_null( $value ) && $validator( $value ) ) {
-			$inital[] = $value;
-		}
-		return ! is_null( $value ) ? arrayCompilerTyped( $validator, $inital ) : $inital;
-	};
+    // Ensure all is validated from initial.
+    $inital = array_filter( $inital, $validator );
+
+    /**
+     * @param mixed $value
+     * @return mixed[]|Closure
+     */
+    return function ( $value = null ) use ( $validator, $inital ) {
+        if ( ! is_null( $value ) && $validator( $value ) ) {
+            $inital[] = $value;
+        }
+        return ! is_null( $value ) ? arrayCompilerTyped( $validator, $inital ) : $inital;
+    };
 }
 
 
@@ -200,13 +200,13 @@ 
  * @return Closure(array<int|string, mixed>):array<int|string, mixed>
  */
 function filter( callable $callable ): Closure {
-	/**
-	 * @param array<int|string, mixed> $source Array to filter
-	 * @return array<int|string, mixed> Filtered array.
-	 */
-	return function ( array $source ) use ( $callable ): array {
-		return array_filter( $source, $callable );
-	};
+    /**
+     * @param array<int|string, mixed> $source Array to filter
+     * @return array<int|string, mixed> Filtered array.
+     */
+    return function ( array $source ) use ( $callable ): array {
+        return array_filter( $source, $callable );
+    };
 }
 
 /**
@@ -216,13 +216,13 @@ 
  * @return Closure(array<int|string, mixed>):array<int|string, mixed>
  */
 function filterKey( callable $callable ): Closure {
-	/**
-	 * @param array<int|string, mixed> $source Array to filter
-	 * @return array<int|string, mixed> Filtered array.
-	 */
-	return function ( array $source ) use ( $callable ): array {
-		return array_filter( $source, $callable, \ARRAY_FILTER_USE_KEY );
-	};
+    /**
+     * @param array<int|string, mixed> $source Array to filter
+     * @return array<int|string, mixed> Filtered array.
+     */
+    return function ( array $source ) use ( $callable ): array {
+        return array_filter( $source, $callable, \ARRAY_FILTER_USE_KEY );
+    };
 }
 
 /**
@@ -233,13 +233,13 @@ 
  * @return Closure(array<int|string, mixed>):array<int|string, mixed>
  */
 function filterAnd( callable ...$callables ): Closure {
-	/**
-	 * @param array<int|string, mixed> $source Array to filter
-	 * @return array<int|string, mixed> Filtered array.
-	 */
-	return function ( array $source ) use ( $callables ): array {
-		return array_filter( $source, Comp\groupAnd( ...$callables ) );
-	};
+    /**
+     * @param array<int|string, mixed> $source Array to filter
+     * @return array<int|string, mixed> Filtered array.
+     */
+    return function ( array $source ) use ( $callables ): array {
+        return array_filter( $source, Comp\groupAnd( ...$callables ) );
+    };
 }
 
 /**
@@ -250,13 +250,13 @@ 
  * @return Closure(array<int|string, mixed>):array<int|string, mixed>
  */
 function filterOr( callable ...$callables ): Closure {
-	/**
-	 * @param array<int|string, mixed> $source Array to filter
-	 * @return array<int|string, mixed> Filtered array.
-	 */
-	return function ( array $source ) use ( $callables ): array {
-		return array_filter( $source, Comp\groupOr( ...$callables ) );
-	};
+    /**
+     * @param array<int|string, mixed> $source Array to filter
+     * @return array<int|string, mixed> Filtered array.
+     */
+    return function ( array $source ) use ( $callables ): array {
+        return array_filter( $source, Comp\groupOr( ...$callables ) );
+    };
 }
 
 /**
@@ -266,13 +266,13 @@ 
  * @return Closure(array<int|string, mixed>):?mixed
  */
 function filterFirst( callable $func ): Closure {
-	/**
-	 * @param array<int|string, mixed> $array The array to filter
-	 * @return mixed|null The first element from the filtered array or null if filter returns empty
-	 */
-	return function ( array $array ) use ( $func ) {
-		return head( array_filter( $array, $func ) );
-	};
+    /**
+     * @param array<int|string, mixed> $array The array to filter
+     * @return mixed|null The first element from the filtered array or null if filter returns empty
+     */
+    return function ( array $array ) use ( $func ) {
+        return head( array_filter( $array, $func ) );
+    };
 }
 
 /**
@@ -282,13 +282,13 @@ 
  * @return Closure(array<int|string, mixed>):?mixed
  */
 function filterLast( callable $func ): Closure {
-	/**
-	 * @param array<int|string, mixed> $array The array to filter
-	 * @return mixed|null The last element from the filtered array.
-	 */
-	return function ( array $array ) use ( $func ) {
-		return tail( array_filter( $array, $func ) );
-	};
+    /**
+     * @param array<int|string, mixed> $array The array to filter
+     * @return mixed|null The last element from the filtered array.
+     */
+    return function ( array $array ) use ( $func ) {
+        return tail( array_filter( $array, $func ) );
+    };
 }
 
 /**
@@ -301,13 +301,13 @@ 
  * @return Closure(array<int|string, mixed>):array<int|string, mixed>
  */
 function filterMap( callable $filter, callable $map ): Closure {
-	/**
-	 * @param array<int|string, mixed> $array The array to filter then map.
-	 * @return array<int|string, mixed>
-	 */
-	return function ( array $array ) use ( $filter, $map ): array {
-		return array_map( $map, array_filter( $array, $filter ) );
-	};
+    /**
+     * @param array<int|string, mixed> $array The array to filter then map.
+     * @return array<int|string, mixed>
+     */
+    return function ( array $array ) use ( $filter, $map ): array {
+        return array_map( $map, array_filter( $array, $filter ) );
+    };
 }
 
 /**
@@ -317,13 +317,13 @@ 
  * @return Closure(array<int|string, mixed>):int
  */
 function filterCount( callable $function ): Closure {
-	/**
-	 * @param array<int|string, mixed> $array
-	 * @return int Count
-	 */
-	return function ( array $array ) use ( $function ) {
-		return count( array_filter( $array, $function ) );
-	};
+    /**
+     * @param array<int|string, mixed> $array
+     * @return int Count
+     */
+    return function ( array $array ) use ( $function ) {
+        return count( array_filter( $array, $function ) );
+    };
 }
 
 /**
@@ -335,26 +335,26 @@ 
  * @return Closure(mixed[]):array{0:mixed[], 1:mixed[]}
  */
 function partition( callable $function ): Closure {
-	/**
-	 * @param mixed[] $array
-	 * @return array{0:mixed[], 1:mixed[]}
-	 */
-	return function ( array $array ) use ( $function ): array {
-		return array_reduce(
-			$array,
-			/**
-			 * @param array{0:mixed[], 1:mixed[]} $carry
-			 * @param mixed $element
-			 * @return array{0:mixed[], 1:mixed[]}
-			 */
-			function ( $carry, $element ) use ( $function ): array {
-				$key             = (bool) $function( $element ) ? 1 : 0;
-				$carry[ $key ][] = $element;
-				return $carry;
-			},
-			array( array(), array() )
-		);
-	};
+    /**
+     * @param mixed[] $array
+     * @return array{0:mixed[], 1:mixed[]}
+     */
+    return function ( array $array ) use ( $function ): array {
+        return array_reduce(
+            $array,
+            /**
+             * @param array{0:mixed[], 1:mixed[]} $carry
+             * @param mixed $element
+             * @return array{0:mixed[], 1:mixed[]}
+             */
+            function ( $carry, $element ) use ( $function ): array {
+                $key             = (bool) $function( $element ) ? 1 : 0;
+                $carry[ $key ][] = $element;
+                return $carry;
+            },
+            array( array(), array() )
+        );
+    };
 }
 
 /**
@@ -364,18 +364,18 @@ 
  * @return Closure(mixed[]):bool
  */
 function filterAll( callable $function ): Closure {
-	/**
-	 * @param mixed[] $array
-	 * @return bool
-	 */
-	return function ( array $array ) use ( $function ): bool {
-		foreach ( $array as $value ) {
-			if ( false === $function( $value ) ) {
-				return false;
-			}
-		}
-		return true;
-	};
+    /**
+     * @param mixed[] $array
+     * @return bool
+     */
+    return function ( array $array ) use ( $function ): bool {
+        foreach ( $array as $value ) {
+            if ( false === $function( $value ) ) {
+                return false;
+            }
+        }
+        return true;
+    };
 }
 
 
@@ -386,18 +386,18 @@ 
  * @return Closure(mixed[]):bool
  */
 function filterAny( callable $function ): Closure {
-	/**
-	 * @param mixed[] $array
-	 * @return bool
-	 */
-	return function ( array $array ) use ( $function ): bool {
-		foreach ( $array as $value ) {
-			if ( true === $function( $value ) ) {
-				return true;
-			}
-		}
-		return false;
-	};
+    /**
+     * @param mixed[] $array
+     * @return bool
+     */
+    return function ( array $array ) use ( $function ): bool {
+        foreach ( $array as $value ) {
+            if ( true === $function( $value ) ) {
+                return true;
+            }
+        }
+        return false;
+    };
 }
 
 
@@ -416,13 +416,13 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function map( callable $func ): Closure {
-	/**
-	 * @param mixed[] $array The array to map
-	 * @return mixed[]
-	 */
-	return function ( array $array ) use ( $func ): array {
-		return array_map( $func, $array );
-	};
+    /**
+     * @param mixed[] $array The array to map
+     * @return mixed[]
+     */
+    return function ( array $array ) use ( $func ): array {
+        return array_map( $func, $array );
+    };
 }
 
 /**
@@ -433,20 +433,20 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function mapKey( callable $func ): Closure {
-	/**
-	 * @param mixed[] $array The array to map
-	 * @return mixed[]
-	 */
-	return function ( array $array ) use ( $func ): array {
-		return array_reduce(
-			array_keys( $array ),
-			function ( $carry, $key ) use ( $func, $array ) {
-				$carry[ $func( $key ) ] = $array[ $key ];
-				return $carry;
-			},
-			array()
-		);
-	};
+    /**
+     * @param mixed[] $array The array to map
+     * @return mixed[]
+     */
+    return function ( array $array ) use ( $func ): array {
+        return array_reduce(
+            array_keys( $array ),
+            function ( $carry, $key ) use ( $func, $array ) {
+                $carry[ $func( $key ) ] = $array[ $key ];
+                return $carry;
+            },
+            array()
+        );
+    };
 }
 
 /**
@@ -457,18 +457,18 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function mapWith( callable $func, ...$data ): Closure {
-	/**
-	 * @param mixed[] $array The array to map
-	 * @return mixed[]
-	 */
-	return function ( array $array ) use ( $func, $data ): array {
-		return array_map(
-			function ( $e ) use ( $data, $func ) {
-				return $func( $e, ...$data );
-			},
-			$array
-		);
-	};
+    /**
+     * @param mixed[] $array The array to map
+     * @return mixed[]
+     */
+    return function ( array $array ) use ( $func, $data ): array {
+        return array_map(
+            function ( $e ) use ( $data, $func ) {
+                return $func( $e, ...$data );
+            },
+            $array
+        );
+    };
 }
 
 /**
@@ -478,19 +478,19 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function mapWithKey( callable $func ): Closure {
-	/**
-	 * @param mixed[] $array The array to map
-	 * @return mixed[]
-	 */
-	return function ( array $array ) use ( $func ): array {
-		return array_map(
-			function ( $key, $value ) use ( $func ) {
-				return $func( $value, $key );
-			},
-			$array,
-			array_keys( $array )
-		);
-	};
+    /**
+     * @param mixed[] $array The array to map
+     * @return mixed[]
+     */
+    return function ( array $array ) use ( $func ): array {
+        return array_map(
+            function ( $key, $value ) use ( $func ) {
+                return $func( $value, $key );
+            },
+            $array,
+            array_keys( $array )
+        );
+    };
 }
 
 /**
@@ -500,19 +500,19 @@ 
  * @return Closure(mixed[]):void
  */
 function each( callable $func ): Closure {
-	/**
-	 * @param mixed[] $array The array to map
-	 * @return void
-	 */
-	return function ( array $array ) use ( $func ): void {
-		array_map(
-			function ( $key, $value ) use ( $func ) {
-				$func( $key, $value );
-			},
-			array_keys( $array ),
-			$array
-		);
-	};
+    /**
+     * @param mixed[] $array The array to map
+     * @return void
+     */
+    return function ( array $array ) use ( $func ): void {
+        array_map(
+            function ( $key, $value ) use ( $func ) {
+                $func( $key, $value );
+            },
+            array_keys( $array ),
+            $array
+        );
+    };
 }
 
 /**
@@ -523,29 +523,29 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function flatMap( callable $function, ?int $n = null ): Closure {
-	/**
-	 * @param mixed[] $array
-	 * @return mixed[]
-	 */
-	return function ( array $array ) use ( $n, $function ): array {
-		return array_reduce(
-			$array,
-			/**
-			 * @param mixed[] $carry
-			 * @param mixed $element
-			 * @return mixed[]
-			 */
-			function ( array $carry, $element ) use ( $n, $function ): array {
-				if ( is_array( $element ) && ( is_null( $n ) || $n > 0 ) ) {
-					$carry = array_merge( $carry, flatMap( $function, $n ? $n - 1 : null )( $element ) );
-				} else {
-					$carry[] = is_array( $element ) ? $element : $function( $element );
-				}
-				return $carry;
-			},
-			array()
-		);
-	};
+    /**
+     * @param mixed[] $array
+     * @return mixed[]
+     */
+    return function ( array $array ) use ( $n, $function ): array {
+        return array_reduce(
+            $array,
+            /**
+             * @param mixed[] $carry
+             * @param mixed $element
+             * @return mixed[]
+             */
+            function ( array $carry, $element ) use ( $n, $function ): array {
+                if ( is_array( $element ) && ( is_null( $n ) || $n > 0 ) ) {
+                    $carry = array_merge( $carry, flatMap( $function, $n ? $n - 1 : null )( $element ) );
+                } else {
+                    $carry[] = is_array( $element ) ? $element : $function( $element );
+                }
+                return $carry;
+            },
+            array()
+        );
+    };
 }
 
 /*
@@ -562,25 +562,25 @@ 
  * @return Closure(mixed):mixed[]
  */
 function groupBy( callable $function ): Closure {
-	/**
-	 * @param mixed[] $array The array to be grouped
-	 * @return mixed[] Grouped array.
-	 */
-	return function ( array $array ) use ( $function ): array {
-		return array_reduce(
-			$array,
-			/**
-			 * @param mixed[] $carry
-			 * @param mixed $element
-			 * @return mixed[]
-			 */
-			function ( $carry, $item ) use ( $function ): array {
-				$carry[ call_user_func( $function, $item ) ][] = $item;
-				return $carry;
-			},
-			array()
-		);
-	};
+    /**
+     * @param mixed[] $array The array to be grouped
+     * @return mixed[] Grouped array.
+     */
+    return function ( array $array ) use ( $function ): array {
+        return array_reduce(
+            $array,
+            /**
+             * @param mixed[] $carry
+             * @param mixed $element
+             * @return mixed[]
+             */
+            function ( $carry, $item ) use ( $function ): array {
+                $carry[ call_user_func( $function, $item ) ][] = $item;
+                return $carry;
+            },
+            array()
+        );
+    };
 }
 
 /**
@@ -591,13 +591,13 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function chunk( int $count, bool $preserveKeys = false ): Closure {
-	/**
-	 * @param mixed[] $array Array to chunk
-	 * @return mixed[]
-	 */
-	return function ( array $array ) use ( $count, $preserveKeys ): array {
-		return array_chunk( $array, max( 1, $count ), $preserveKeys );
-	};
+    /**
+     * @param mixed[] $array Array to chunk
+     * @return mixed[]
+     */
+    return function ( array $array ) use ( $count, $preserveKeys ): array {
+        return array_chunk( $array, max( 1, $count ), $preserveKeys );
+    };
 }
 
 /**
@@ -608,13 +608,13 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function column( string $column, ?string $key = null ): Closure {
-	/**
-	 * @param mixed[] $array
-	 * @return mixed[]
-	 */
-	return function ( array $array ) use ( $column, $key ): array {
-		return array_column( $array, $column, $key );
-	};
+    /**
+     * @param mixed[] $array
+     * @return mixed[]
+     */
+    return function ( array $array ) use ( $column, $key ): array {
+        return array_column( $array, $column, $key );
+    };
 }
 
 /**
@@ -624,35 +624,35 @@ 
  * @return Closure(mixed[] $var): mixed[]
  */
 function flattenByN( ?int $n = null ): Closure {
-	/**
-	 * @param mixed[] $array Array to flatten
-	 * @return mixed[]
-	 */
-	return function ( array $array ) use ( $n ): array {
-		return array_reduce(
-			$array,
-			/**
-			 * @param array<int|string, mixed> $carry
-			 * @param mixed|mixed[] $element
-			 * @return array<int|string, mixed>
-			 */
-			function ( array $carry, $element ) use ( $n ): array {
-				// Remove empty arrays.
-				if ( is_array( $element ) && empty( $element ) ) {
-					return $carry;
-				}
-				// If the element is an array and we are still flattening, call again
-				if ( is_array( $element ) && ( is_null( $n ) || $n > 0 ) ) { // @phpstan-ignore-line
-					$carry = array_merge( $carry, flattenByN( $n ? $n - 1 : null )( $element ) );
-				} else {
-					// Else just add the element.
-					$carry[] = $element;
-				}
-				return $carry;
-			},
-			array()
-		);
-	};
+    /**
+     * @param mixed[] $array Array to flatten
+     * @return mixed[]
+     */
+    return function ( array $array ) use ( $n ): array {
+        return array_reduce(
+            $array,
+            /**
+             * @param array<int|string, mixed> $carry
+             * @param mixed|mixed[] $element
+             * @return array<int|string, mixed>
+             */
+            function ( array $carry, $element ) use ( $n ): array {
+                // Remove empty arrays.
+                if ( is_array( $element ) && empty( $element ) ) {
+                    return $carry;
+                }
+                // If the element is an array and we are still flattening, call again
+                if ( is_array( $element ) && ( is_null( $n ) || $n > 0 ) ) { // @phpstan-ignore-line
+                    $carry = array_merge( $carry, flattenByN( $n ? $n - 1 : null )( $element ) );
+                } else {
+                    // Else just add the element.
+                    $carry[] = $element;
+                }
+                return $carry;
+            },
+            array()
+        );
+    };
 }
 
 /**
@@ -662,13 +662,13 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function replaceRecursive( array ...$with ): Closure {
-	/**
-	 * @param mixed[] $array The array to have elements replaced from.
-	 * @return mixed[] Array with replacements.
-	 */
-	return function ( array $array ) use ( $with ): array {
-		return array_replace_recursive( $array, ...$with );
-	};
+    /**
+     * @param mixed[] $array The array to have elements replaced from.
+     * @return mixed[] Array with replacements.
+     */
+    return function ( array $array ) use ( $with ): array {
+        return array_replace_recursive( $array, ...$with );
+    };
 }
 
 /**
@@ -678,13 +678,13 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function replace( array ...$with ): Closure {
-	/**
-	 * @param mixed[] $array The array to have elements replaced from.
-	 * @return mixed[] Array with replacements.
-	 */
-	return function ( array $array ) use ( $with ): array {
-		return array_replace( $array, ...$with );
-	};
+    /**
+     * @param mixed[] $array The array to have elements replaced from.
+     * @return mixed[] Array with replacements.
+     */
+    return function ( array $array ) use ( $with ): array {
+        return array_replace( $array, ...$with );
+    };
 }
 
 /**
@@ -694,13 +694,13 @@ 
  * @return Closure(mixed[]):Number
  */
 function sumWhere( callable $function ): Closure {
-	/**
-	 * @param mixed[] $array Array to do sum() on.
-	 * @return Number The total.
-	 */
-	return function ( array $array ) use ( $function ) {
-		return array_sum( array_map( $function, $array ) );
-	};
+    /**
+     * @param mixed[] $array Array to do sum() on.
+     * @return Number The total.
+     */
+    return function ( array $array ) use ( $function ) {
+        return array_sum( array_map( $function, $array ) );
+    };
 }
 
 /**
@@ -713,27 +713,27 @@ 
  * @throws InvalidArgumentException If property does not exist or is not public.
  */
 function toObject( ?object $object = null ): Closure {
-	$object = $object ?? new stdClass();
-
-	/**
-	 * @param mixed[] $array
-	 * @return object
-	 */
-	return function ( array $array ) use ( $object ): object {
-		foreach ( $array as $key => $value ) {
-			// If key is not a string or numerical, skip it.
-			if ( ! is_string( $key ) || is_numeric( $key ) ) {
-				continue;
-			}
-
-			try {
-				$object->{$key} = $value;
-			} catch ( \Throwable $th ) {
-				throw new \InvalidArgumentException( "Property {$key} does not exist or is not public." );
-			}
-		}
-		return $object;
-	};
+    $object = $object ?? new stdClass();
+
+    /**
+     * @param mixed[] $array
+     * @return object
+     */
+    return function ( array $array ) use ( $object ): object {
+        foreach ( $array as $key => $value ) {
+            // If key is not a string or numerical, skip it.
+            if ( ! is_string( $key ) || is_numeric( $key ) ) {
+                continue;
+            }
+
+            try {
+                $object->{$key} = $value;
+            } catch ( \Throwable $th ) {
+                throw new \InvalidArgumentException( "Property {$key} does not exist or is not public." );
+            }
+        }
+        return $object;
+    };
 }
 
 /**
@@ -750,13 +750,13 @@ 
  *            JSON_UNESCAPED_SLASHES, JSON_UNESCAPED_UNICODE, JSON_THROW_ON_ERROR
  */
 function toJson( int $flags = 0, int $depth = 512 ): Closure {
-	/**
-	 * @param mixed $data
-	 * @return string|null
-	 */
-	return function ( $data ) use ( $flags, $depth ): ?string {
-		return \json_encode( $data, $flags, max( 1, $depth ) ) ?: null;
-	};
+    /**
+     * @param mixed $data
+     * @return string|null
+     */
+    return function ( $data ) use ( $flags, $depth ): ?string {
+        return \json_encode( $data, $flags, max( 1, $depth ) ) ?: null;
+    };
 }
 
 
@@ -775,14 +775,14 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function sort( int $flag = SORT_REGULAR ): Closure {
-	/**
-	 *  @param mixed[]$array The array to sort
-	 *  @return mixed[] The sorted array (new array)
-	 */
-	return function ( array $array ) use ( $flag ) {
-		\sort( $array, $flag );
-		return $array;
-	};
+    /**
+     *  @param mixed[]$array The array to sort
+     *  @return mixed[] The sorted array (new array)
+     */
+    return function ( array $array ) use ( $flag ) {
+        \sort( $array, $flag );
+        return $array;
+    };
 }
 
 /**
@@ -793,14 +793,14 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function rsort( int $flag = SORT_REGULAR ): Closure {
-	/**
-	 *  @param mixed[]$array The array to sort
-	 *  @return mixed[] The sorted array (new array)
-	 */
-	return function ( array $array ) use ( $flag ) {
-		\rsort( $array, $flag );
-		return $array;
-	};
+    /**
+     *  @param mixed[]$array The array to sort
+     *  @return mixed[] The sorted array (new array)
+     */
+    return function ( array $array ) use ( $flag ) {
+        \rsort( $array, $flag );
+        return $array;
+    };
 }
 
 
@@ -811,14 +811,14 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function ksort( int $flag = SORT_REGULAR ): Closure {
-	/**
-	 *  @param mixed[]$array The array to sort
-	 *  @return mixed[] The sorted array (new array)
-	 */
-	return function ( array $array ) use ( $flag ) {
-		\ksort( $array, $flag );
-		return $array;
-	};
+    /**
+     *  @param mixed[]$array The array to sort
+     *  @return mixed[] The sorted array (new array)
+     */
+    return function ( array $array ) use ( $flag ) {
+        \ksort( $array, $flag );
+        return $array;
+    };
 }
 
 /**
@@ -828,14 +828,14 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function krsort( int $flag = SORT_REGULAR ): Closure {
-	/**
-	 *  @param mixed[]$array The array to sort
-	 *  @return mixed[] The sorted array (new array)
-	 */
-	return function ( array $array ) use ( $flag ) {
-		\krsort( $array, $flag );
-		return $array;
-	};
+    /**
+     *  @param mixed[]$array The array to sort
+     *  @return mixed[] The sorted array (new array)
+     */
+    return function ( array $array ) use ( $flag ) {
+        \krsort( $array, $flag );
+        return $array;
+    };
 }
 
 /**
@@ -846,14 +846,14 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function asort( int $flag = SORT_REGULAR ): Closure {
-	/**
-	 *  @param mixed[]$array The array to sort
-	 *  @return mixed[] The sorted array (new array)
-	 */
-	return function ( array $array ) use ( $flag ) {
-		\asort( $array, $flag );
-		return $array;
-	};
+    /**
+     *  @param mixed[]$array The array to sort
+     *  @return mixed[] The sorted array (new array)
+     */
+    return function ( array $array ) use ( $flag ) {
+        \asort( $array, $flag );
+        return $array;
+    };
 }
 
 /**
@@ -864,14 +864,14 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function arsort( int $flag = SORT_REGULAR ): Closure {
-	/**
-	 *  @param mixed[]$array The array to sort
-	 *  @return mixed[] The sorted array (new array)
-	 */
-	return function ( array $array ) use ( $flag ) {
-		\arsort( $array, $flag );
-		return $array;
-	};
+    /**
+     *  @param mixed[]$array The array to sort
+     *  @return mixed[] The sorted array (new array)
+     */
+    return function ( array $array ) use ( $flag ) {
+        \arsort( $array, $flag );
+        return $array;
+    };
 }
 
 /**
@@ -880,14 +880,14 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function natsort(): Closure {
-	/**
-	 *  @param mixed[]$array The array to sort
-	 *  @return mixed[] The sorted array (new array)
-	 */
-	return function ( array $array ) {
-		\natsort( $array );
-		return $array;
-	};
+    /**
+     *  @param mixed[]$array The array to sort
+     *  @return mixed[] The sorted array (new array)
+     */
+    return function ( array $array ) {
+        \natsort( $array );
+        return $array;
+    };
 }
 
 /**
@@ -896,14 +896,14 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function natcasesort(): Closure {
-	/**
-	 *  @param mixed[]$array The array to sort
-	 *  @return mixed[] The sorted array (new array)
-	 */
-	return function ( array $array ) {
-		\natcasesort( $array );
-		return $array;
-	};
+    /**
+     *  @param mixed[]$array The array to sort
+     *  @return mixed[] The sorted array (new array)
+     */
+    return function ( array $array ) {
+        \natcasesort( $array );
+        return $array;
+    };
 }
 
 /**
@@ -913,14 +913,14 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function uksort( callable $function ): Closure {
-	/**
-	 *  @param mixed[] $array The array to sort
-	 *  @return mixed[] The sorted array (new array)
-	 */
-	return function ( array $array ) use ( $function ) {
-		\uksort( $array, $function );
-		return $array;
-	};
+    /**
+     *  @param mixed[] $array The array to sort
+     *  @return mixed[] The sorted array (new array)
+     */
+    return function ( array $array ) use ( $function ) {
+        \uksort( $array, $function );
+        return $array;
+    };
 }
 
 /**
@@ -931,14 +931,14 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function uasort( callable $function ): Closure {
-	/**
-	 *  @param mixed[]$array The array to sort
-	 *  @return mixed[] The sorted array (new array)
-	 */
-	return function ( array $array ) use ( $function ) {
-		\uasort( $array, $function );
-		return $array;
-	};
+    /**
+     *  @param mixed[]$array The array to sort
+     *  @return mixed[] The sorted array (new array)
+     */
+    return function ( array $array ) use ( $function ) {
+        \uasort( $array, $function );
+        return $array;
+    };
 }
 
 
@@ -950,14 +950,14 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function usort( callable $function ): Closure {
-	/**
-	 *  @param mixed[]$array The array to sort
-	 *  @return mixed[] The sorted array (new array)
-	 */
-	return function ( array $array ) use ( $function ) {
-		\usort( $array, $function );
-		return $array;
-	};
+    /**
+     *  @param mixed[]$array The array to sort
+     *  @return mixed[] The sorted array (new array)
+     */
+    return function ( array $array ) use ( $function ) {
+        \usort( $array, $function );
+        return $array;
+    };
 }
 
 /**
@@ -968,14 +968,14 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function scan( callable $function, $initialValue ): Closure {
-	return function ( array $array ) use ( $function, $initialValue ) {
-		$carry[] = $initialValue;
-		foreach ( $array as $key => $value ) {
-			$initialValue = $function( $initialValue, $value );
-			$carry[]      = $initialValue;
-		}
-		return $carry;
-	};
+    return function ( array $array ) use ( $function, $initialValue ) {
+        $carry[] = $initialValue;
+        foreach ( $array as $key => $value ) {
+            $initialValue = $function( $initialValue, $value );
+            $carry[]      = $initialValue;
+        }
+        return $carry;
+    };
 }
 
 /**
@@ -986,14 +986,14 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function scanR( callable $function, $initialValue ): Closure {
-	return function ( array $array ) use ( $function, $initialValue ) {
-		$carry[] = $initialValue;
-		foreach ( array_reverse( $array ) as $key => $value ) {
-			$initialValue = $function( $initialValue, $value );
-			$carry[]      = $initialValue;
-		}
-		return \array_reverse( $carry );
-	};
+    return function ( array $array ) use ( $function, $initialValue ) {
+        $carry[] = $initialValue;
+        foreach ( array_reverse( $array ) as $key => $value ) {
+            $initialValue = $function( $initialValue, $value );
+            $carry[]      = $initialValue;
+        }
+        return \array_reverse( $carry );
+    };
 }
 
 /**
@@ -1004,13 +1004,13 @@ 
  * @return Closure(mixed[]):mixed
  */
 function fold( callable $callable, $initial = array() ): Closure {
-	/**
-	 * @param mixed[] $array
-	 * @return mixed
-	 */
-	return function ( array $array ) use ( $callable, $initial ) {
-		return array_reduce( $array, $callable, $initial );
-	};
+    /**
+     * @param mixed[] $array
+     * @return mixed
+     */
+    return function ( array $array ) use ( $callable, $initial ) {
+        return array_reduce( $array, $callable, $initial );
+    };
 }
 
 /**
@@ -1021,13 +1021,13 @@ 
  * @return Closure(mixed[]):mixed
  */
 function foldR( callable $callable, $initial = array() ): Closure {
-	/**
-	 * @param mixed[] $array
-	 * @return mixed
-	 */
-	return function ( array $array ) use ( $callable, $initial ) {
-		return array_reduce( \array_reverse( $array ), $callable, $initial );
-	};
+    /**
+     * @param mixed[] $array
+     * @return mixed
+     */
+    return function ( array $array ) use ( $callable, $initial ) {
+        return array_reduce( \array_reverse( $array ), $callable, $initial );
+    };
 }
 
 /**
@@ -1039,16 +1039,16 @@ 
  * @return Closure(mixed[]):mixed
  */
 function foldKeys( callable $callable, $initial = array() ): Closure {
-	/**
-	 * @param mixed[] $array
-	 * @return mixed
-	 */
-	return function ( array $array ) use ( $callable, $initial ) {
-		foreach ( $array as $key => $value ) {
-			$initial = $callable( $initial, $key, $value );
-		}
-		return $initial;
-	};
+    /**
+     * @param mixed[] $array
+     * @return mixed
+     */
+    return function ( array $array ) use ( $callable, $initial ) {
+        foreach ( $array as $key => $value ) {
+            $initial = $callable( $initial, $key, $value );
+        }
+        return $initial;
+    };
 }
 
 /**
@@ -1059,18 +1059,18 @@ 
  * @throws \InvalidArgumentException if count is negative
  */
 function take( int $count = 1 ): Closure {
-	// throw InvalidArgumentException if count is negative
-	if ( $count < 0 ) {
-		throw new \InvalidArgumentException( __FUNCTION__ . ' count must be greater than or equal to 0' );
-	}
-
-	/**
-	 * @param mixed[] $array
-	 * @return mixed[]
-	 */
-	return function ( array $array ) use ( $count ) {
-		return \array_slice( $array, 0, $count );
-	};
+    // throw InvalidArgumentException if count is negative
+    if ( $count < 0 ) {
+        throw new \InvalidArgumentException( __FUNCTION__ . ' count must be greater than or equal to 0' );
+    }
+
+    /**
+     * @param mixed[] $array
+     * @return mixed[]
+     */
+    return function ( array $array ) use ( $count ) {
+        return \array_slice( $array, 0, $count );
+    };
 }
 
 /**
@@ -1081,25 +1081,25 @@ 
  * @throws \InvalidArgumentException if count is negative
  */
 function takeLast( int $count = 1 ): Closure {
-	// throw InvalidArgumentException if count is negative
-	if ( $count < 0 ) {
-		throw new \InvalidArgumentException( __FUNCTION__ . ' count must be greater than or equal to 0' );
-	}
-
-	// If count is 0, return an empty array
-	if ( $count === 0 ) {
-		return function ( array $array ) {
-			return array();
-		};
-	}
-
-	/**
-	 * @param mixed[] $array
-	 * @return mixed[]
-	 */
-	return function ( array $array ) use ( $count ) {
-		return \array_slice( $array, - $count );
-	};
+    // throw InvalidArgumentException if count is negative
+    if ( $count < 0 ) {
+        throw new \InvalidArgumentException( __FUNCTION__ . ' count must be greater than or equal to 0' );
+    }
+
+    // If count is 0, return an empty array
+    if ( $count === 0 ) {
+        return function ( array $array ) {
+            return array();
+        };
+    }
+
+    /**
+     * @param mixed[] $array
+     * @return mixed[]
+     */
+    return function ( array $array ) use ( $count ) {
+        return \array_slice( $array, - $count );
+    };
 }
 
 /**
@@ -1110,20 +1110,20 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function takeUntil( callable $conditional ): Closure {
-	/**
-	 * @param mixed[] $array
-	 * @return mixed[]
-	 */
-	return function ( array $array ) use ( $conditional ) {
-		$carry = array();
-		foreach ( $array as $key => $value ) {
-			if ( true === $conditional( $value ) ) {
-				break;
-			}
-			$carry[ $key ] = $value;
-		}
-		return $carry;
-	};
+    /**
+     * @param mixed[] $array
+     * @return mixed[]
+     */
+    return function ( array $array ) use ( $conditional ) {
+        $carry = array();
+        foreach ( $array as $key => $value ) {
+            if ( true === $conditional( $value ) ) {
+                break;
+            }
+            $carry[ $key ] = $value;
+        }
+        return $carry;
+    };
 }
 
 /**
@@ -1134,18 +1134,18 @@ 
  * @return Closure(mixed[]):mixed[]
  */
 function takeWhile( callable $conditional ): Closure {
-	/**
-	 * @param mixed[] $array
-	 * @return mixed[]
-	 */
-	return function ( array $array ) use ( $conditional ) {
-		$carry = array();
-		foreach ( $array as $key => $value ) {
-			if ( false === $conditional( $value ) ) {
-				break;
-			}
-			$carry[ $key ] = $value;
-		}
-		return $carry;
-	};
+    /**
+     * @param mixed[] $array
+     * @return mixed[]
+     */
+    return function ( array $array ) use ( $conditional ) {
+        $carry = array();
+        foreach ( $array as $key => $value ) {
+            if ( false === $conditional( $value ) ) {
+                break;
+            }
+            $carry[ $key ] = $value;
+        }
+        return $carry;
+    };
 }

Spacing +201 added lines, -201 removed lines

@@ -40,13 +40,13 @@ 
  * @param array<int|string, mixed> $array
  * @return Closure(mixed):array<int|string, mixed>
  */
-function pushHead( array $array ): Closure {
+function pushHead(array $array): Closure {
 	/**
 	 * @param mixed $value Adds value start of array.
 	 * @return array New array with value on head.
 	 */
-	return function ( $value ) use ( $array ): array {
-		array_unshift( $array, $value );
+	return function($value) use ($array): array {
+		array_unshift($array, $value);
 		return $array;
 	};
 }
@@ -57,12 +57,12 @@ 
  * @param array<int|string, mixed> $array
  * @return Closure(mixed):array<int|string, mixed>
  */
-function pushTail( array $array ): Closure {
+function pushTail(array $array): Closure {
 	/**
 	 * @param mixed $value Adds value end of array.
 	 * @return array<int|string, mixed> New array with value on tail.
 	 */
-	return function ( $value ) use ( $array ): array {
+	return function($value) use ($array): array {
 		$array[] = $value;
 		return $array;
 	};
@@ -74,8 +74,8 @@ 
  * @param array<int|string, mixed> $array The array.
  * @return mixed Will return the first value is array is not empty, else null.
  */
-function head( array $array ) {
-	return ! empty( $array ) ? array_values( $array )[0] : null;
+function head(array $array) {
+	return !empty($array) ? array_values($array)[0] : null;
 }
 
 /**
@@ -84,8 +84,8 @@ 
  * @param array<int|string, mixed> $array
  * @return mixed Will return the last value is array is not empty, else null.
  */
-function tail( array $array ) {
-	return ! empty( $array ) ? array_reverse( $array, false )[0] : null;
+function tail(array $array) {
+	return !empty($array) ? array_reverse($array, false)[0] : null;
 }
 
 
@@ -96,13 +96,13 @@ 
  * @return Closure(array<int|string, mixed>):string
  *
  */
-function toString( ?string $glue = null ): Closure {
+function toString(?string $glue = null): Closure {
 	/**
 	 * @param array<int|string, mixed> $array Array join
 	 * @return string.
 	 */
-	return function ( array $array ) use ( $glue ): string {
-		return $glue ? \join( $glue, $array ) : \join( $array );
+	return function(array $array) use ($glue) : string {
+		return $glue ? \join($glue, $array) : \join($array);
 	};
 }
 
@@ -114,16 +114,16 @@ 
  * @return Closure(array<mixed>):array<array{mixed, mixed}>
  *
  */
-function zip( array $additional, $default = null ): Closure {
-	$additional = array_values( $additional );
-	return function ( array $array ) use ( $additional, $default ) {
-		$array = array_values( $array );
+function zip(array $additional, $default = null): Closure {
+	$additional = array_values($additional);
+	return function(array $array) use ($additional, $default) {
+		$array = array_values($array);
 		return array_reduce(
-			array_keys( $array ),
-			function ( $carry, $key ) use ( $array, $additional, $default ): array {
+			array_keys($array),
+			function($carry, $key) use ($array, $additional, $default): array {
 				$carry[] = array(
-					$array[ $key ],
-					array_key_exists( $key, $additional ) ? $additional[ $key ] : $default,
+					$array[$key],
+					array_key_exists($key, $additional) ? $additional[$key] : $default,
 				);
 				return $carry;
 			},
@@ -147,16 +147,16 @@ 
  * @param mixed[] $inital Sets up the inner value.
  * @return Closure
  */
-function arrayCompiler( array $inital = array() ): Closure {
+function arrayCompiler(array $inital = array()): Closure {
 	/**
 	 * @param mixed $value Adds value to inner array if value set, else returns.
 	 * @return mixed[]|Closure
 	 */
-	return function ( $value = null ) use ( $inital ) {
-		if ( $value ) {
+	return function($value = null) use ($inital) {
+		if ($value) {
 			$inital[] = $value;
 		}
-		return ! is_null( $value ) ? arrayCompiler( $inital ) : $inital;
+		return !is_null($value) ? arrayCompiler($inital) : $inital;
 	};
 }
 
@@ -168,19 +168,19 @@ 
  * @param mixed[] $inital The inital data to start with
  * @return Closure
  */
-function arrayCompilerTyped( callable $validator, array $inital = array() ): Closure {
+function arrayCompilerTyped(callable $validator, array $inital = array()): Closure {
 	// Ensure all is validated from initial.
-	$inital = array_filter( $inital, $validator );
+	$inital = array_filter($inital, $validator);
 
 	/**
 	 * @param mixed $value
 	 * @return mixed[]|Closure
 	 */
-	return function ( $value = null ) use ( $validator, $inital ) {
-		if ( ! is_null( $value ) && $validator( $value ) ) {
+	return function($value = null) use ($validator, $inital) {
+		if (!is_null($value) && $validator($value)) {
 			$inital[] = $value;
 		}
-		return ! is_null( $value ) ? arrayCompilerTyped( $validator, $inital ) : $inital;
+		return !is_null($value) ? arrayCompilerTyped($validator, $inital) : $inital;
 	};
 }
 
@@ -199,13 +199,13 @@ 
  * @param callable $callable The function to apply to the array.
  * @return Closure(array<int|string, mixed>):array<int|string, mixed>
  */
-function filter( callable $callable ): Closure {
+function filter(callable $callable): Closure {
 	/**
 	 * @param array<int|string, mixed> $source Array to filter
 	 * @return array<int|string, mixed> Filtered array.
 	 */
-	return function ( array $source ) use ( $callable ): array {
-		return array_filter( $source, $callable );
+	return function(array $source) use ($callable): array {
+		return array_filter($source, $callable);
 	};
 }
 
@@ -215,13 +215,13 @@ 
  * @param callable $callable The function to apply to the array.
  * @return Closure(array<int|string, mixed>):array<int|string, mixed>
  */
-function filterKey( callable $callable ): Closure {
+function filterKey(callable $callable): Closure {
 	/**
 	 * @param array<int|string, mixed> $source Array to filter
 	 * @return array<int|string, mixed> Filtered array.
 	 */
-	return function ( array $source ) use ( $callable ): array {
-		return array_filter( $source, $callable, \ARRAY_FILTER_USE_KEY );
+	return function(array $source) use ($callable): array {
+		return array_filter($source, $callable, \ARRAY_FILTER_USE_KEY);
 	};
 }
 
@@ -232,13 +232,13 @@ 
  * @param callable ...$callables
  * @return Closure(array<int|string, mixed>):array<int|string, mixed>
  */
-function filterAnd( callable ...$callables ): Closure {
+function filterAnd(callable ...$callables): Closure {
 	/**
 	 * @param array<int|string, mixed> $source Array to filter
 	 * @return array<int|string, mixed> Filtered array.
 	 */
-	return function ( array $source ) use ( $callables ): array {
-		return array_filter( $source, Comp\groupAnd( ...$callables ) );
+	return function(array $source) use ($callables): array {
+		return array_filter($source, Comp\groupAnd(...$callables));
 	};
 }
 
@@ -249,13 +249,13 @@ 
  * @param callable ...$callables
  * @return Closure(array<int|string, mixed>):array<int|string, mixed>
  */
-function filterOr( callable ...$callables ): Closure {
+function filterOr(callable ...$callables): Closure {
 	/**
 	 * @param array<int|string, mixed> $source Array to filter
 	 * @return array<int|string, mixed> Filtered array.
 	 */
-	return function ( array $source ) use ( $callables ): array {
-		return array_filter( $source, Comp\groupOr( ...$callables ) );
+	return function(array $source) use ($callables): array {
+		return array_filter($source, Comp\groupOr(...$callables));
 	};
 }
 
@@ -265,13 +265,13 @@ 
  * @param callable $func
  * @return Closure(array<int|string, mixed>):?mixed
  */
-function filterFirst( callable $func ): Closure {
+function filterFirst(callable $func): Closure {
 	/**
 	 * @param array<int|string, mixed> $array The array to filter
 	 * @return mixed|null The first element from the filtered array or null if filter returns empty
 	 */
-	return function ( array $array ) use ( $func ) {
-		return head( array_filter( $array, $func ) );
+	return function(array $array) use ($func) {
+		return head(array_filter($array, $func));
 	};
 }
 
@@ -281,13 +281,13 @@ 
  * @param callable $func
  * @return Closure(array<int|string, mixed>):?mixed
  */
-function filterLast( callable $func ): Closure {
+function filterLast(callable $func): Closure {
 	/**
 	 * @param array<int|string, mixed> $array The array to filter
 	 * @return mixed|null The last element from the filtered array.
 	 */
-	return function ( array $array ) use ( $func ) {
-		return tail( array_filter( $array, $func ) );
+	return function(array $array) use ($func) {
+		return tail(array_filter($array, $func));
 	};
 }
 
@@ -300,13 +300,13 @@ 
  * @param callable(mixed):mixed $map Function to map results of filter function.
  * @return Closure(array<int|string, mixed>):array<int|string, mixed>
  */
-function filterMap( callable $filter, callable $map ): Closure {
+function filterMap(callable $filter, callable $map): Closure {
 	/**
 	 * @param array<int|string, mixed> $array The array to filter then map.
 	 * @return array<int|string, mixed>
 	 */
-	return function ( array $array ) use ( $filter, $map ): array {
-		return array_map( $map, array_filter( $array, $filter ) );
+	return function(array $array) use ($filter, $map): array {
+		return array_map($map, array_filter($array, $filter));
 	};
 }
 
@@ -316,13 +316,13 @@ 
  * @param callable $function
  * @return Closure(array<int|string, mixed>):int
  */
-function filterCount( callable $function ): Closure {
+function filterCount(callable $function): Closure {
 	/**
 	 * @param array<int|string, mixed> $array
 	 * @return int Count
 	 */
-	return function ( array $array ) use ( $function ) {
-		return count( array_filter( $array, $function ) );
+	return function(array $array) use ($function) {
+		return count(array_filter($array, $function));
 	};
 }
 
@@ -334,12 +334,12 @@ 
  * @param callable(mixed):(bool|int) $function
  * @return Closure(mixed[]):array{0:mixed[], 1:mixed[]}
  */
-function partition( callable $function ): Closure {
+function partition(callable $function): Closure {
 	/**
 	 * @param mixed[] $array
 	 * @return array{0:mixed[], 1:mixed[]}
 	 */
-	return function ( array $array ) use ( $function ): array {
+	return function(array $array) use ($function): array {
 		return array_reduce(
 			$array,
 			/**
@@ -347,12 +347,12 @@ 
 			 * @param mixed $element
 			 * @return array{0:mixed[], 1:mixed[]}
 			 */
-			function ( $carry, $element ) use ( $function ): array {
-				$key             = (bool) $function( $element ) ? 1 : 0;
-				$carry[ $key ][] = $element;
+			function($carry, $element) use ($function): array {
+				$key             = (bool) $function($element) ? 1 : 0;
+				$carry[$key][] = $element;
 				return $carry;
 			},
-			array( array(), array() )
+			array(array(), array())
 		);
 	};
 }
@@ -363,14 +363,14 @@ 
  * @param callable(mixed):bool $function
  * @return Closure(mixed[]):bool
  */
-function filterAll( callable $function ): Closure {
+function filterAll(callable $function): Closure {
 	/**
 	 * @param mixed[] $array
 	 * @return bool
 	 */
-	return function ( array $array ) use ( $function ): bool {
-		foreach ( $array as $value ) {
-			if ( false === $function( $value ) ) {
+	return function(array $array) use ($function): bool {
+		foreach ($array as $value) {
+			if (false === $function($value)) {
 				return false;
 			}
 		}
@@ -385,14 +385,14 @@ 
  * @param callable(mixed):bool $function
  * @return Closure(mixed[]):bool
  */
-function filterAny( callable $function ): Closure {
+function filterAny(callable $function): Closure {
 	/**
 	 * @param mixed[] $array
 	 * @return bool
 	 */
-	return function ( array $array ) use ( $function ): bool {
-		foreach ( $array as $value ) {
-			if ( true === $function( $value ) ) {
+	return function(array $array) use ($function): bool {
+		foreach ($array as $value) {
+			if (true === $function($value)) {
 				return true;
 			}
 		}
@@ -415,13 +415,13 @@ 
  * @param callable(mixed):mixed $func Callback to apply to each element in array.
  * @return Closure(mixed[]):mixed[]
  */
-function map( callable $func ): Closure {
+function map(callable $func): Closure {
 	/**
 	 * @param mixed[] $array The array to map
 	 * @return mixed[]
 	 */
-	return function ( array $array ) use ( $func ): array {
-		return array_map( $func, $array );
+	return function(array $array) use ($func): array {
+		return array_map($func, $array);
 	};
 }
 
@@ -432,16 +432,16 @@ 
  * @param callable $func
  * @return Closure(mixed[]):mixed[]
  */
-function mapKey( callable $func ): Closure {
+function mapKey(callable $func): Closure {
 	/**
 	 * @param mixed[] $array The array to map
 	 * @return mixed[]
 	 */
-	return function ( array $array ) use ( $func ): array {
+	return function(array $array) use ($func): array {
 		return array_reduce(
-			array_keys( $array ),
-			function ( $carry, $key ) use ( $func, $array ) {
-				$carry[ $func( $key ) ] = $array[ $key ];
+			array_keys($array),
+			function($carry, $key) use ($func, $array) {
+				$carry[$func($key)] = $array[$key];
 				return $carry;
 			},
 			array()
@@ -456,15 +456,15 @@ 
  * @param mixed ...$data
  * @return Closure(mixed[]):mixed[]
  */
-function mapWith( callable $func, ...$data ): Closure {
+function mapWith(callable $func, ...$data): Closure {
 	/**
 	 * @param mixed[] $array The array to map
 	 * @return mixed[]
 	 */
-	return function ( array $array ) use ( $func, $data ): array {
+	return function(array $array) use ($func, $data): array {
 		return array_map(
-			function ( $e ) use ( $data, $func ) {
-				return $func( $e, ...$data );
+			function($e) use ($data, $func) {
+				return $func($e, ...$data);
 			},
 			$array
 		);
@@ -477,18 +477,18 @@ 
  * @param callable(int|string $key, mixed $value):mixed $func
  * @return Closure(mixed[]):mixed[]
  */
-function mapWithKey( callable $func ): Closure {
+function mapWithKey(callable $func): Closure {
 	/**
 	 * @param mixed[] $array The array to map
 	 * @return mixed[]
 	 */
-	return function ( array $array ) use ( $func ): array {
+	return function(array $array) use ($func): array {
 		return array_map(
-			function ( $key, $value ) use ( $func ) {
-				return $func( $value, $key );
+			function($key, $value) use ($func) {
+				return $func($value, $key);
 			},
 			$array,
-			array_keys( $array )
+			array_keys($array)
 		);
 	};
 }
@@ -499,17 +499,17 @@ 
  * @param callable(int|string $key, mixed $value):void $func
  * @return Closure(mixed[]):void
  */
-function each( callable $func ): Closure {
+function each(callable $func): Closure {
 	/**
 	 * @param mixed[] $array The array to map
 	 * @return void
 	 */
-	return function ( array $array ) use ( $func ): void {
+	return function(array $array) use ($func): void {
 		array_map(
-			function ( $key, $value ) use ( $func ) {
-				$func( $key, $value );
+			function($key, $value) use ($func) {
+				$func($key, $value);
 			},
-			array_keys( $array ),
+			array_keys($array),
 			$array
 		);
 	};
@@ -522,12 +522,12 @@ 
  * @param int|null $n Depth of nodes to flatten. If null will flatten to n
  * @return Closure(mixed[]):mixed[]
  */
-function flatMap( callable $function, ?int $n = null ): Closure {
+function flatMap(callable $function, ?int $n = null): Closure {
 	/**
 	 * @param mixed[] $array
 	 * @return mixed[]
 	 */
-	return function ( array $array ) use ( $n, $function ): array {
+	return function(array $array) use ($n, $function) : array {
 		return array_reduce(
 			$array,
 			/**
@@ -535,11 +535,11 @@ 
 			 * @param mixed $element
 			 * @return mixed[]
 			 */
-			function ( array $carry, $element ) use ( $n, $function ): array {
-				if ( is_array( $element ) && ( is_null( $n ) || $n > 0 ) ) {
-					$carry = array_merge( $carry, flatMap( $function, $n ? $n - 1 : null )( $element ) );
+			function(array $carry, $element) use ($n, $function) : array {
+				if (is_array($element) && (is_null($n) || $n > 0)) {
+					$carry = array_merge($carry, flatMap($function, $n ? $n - 1 : null)($element));
 				} else {
-					$carry[] = is_array( $element ) ? $element : $function( $element );
+					$carry[] = is_array($element) ? $element : $function($element);
 				}
 				return $carry;
 			},
@@ -561,12 +561,12 @@ 
  * @param callable(mixed):(string|int) $function The function to group by.
  * @return Closure(mixed):mixed[]
  */
-function groupBy( callable $function ): Closure {
+function groupBy(callable $function): Closure {
 	/**
 	 * @param mixed[] $array The array to be grouped
 	 * @return mixed[] Grouped array.
 	 */
-	return function ( array $array ) use ( $function ): array {
+	return function(array $array) use ($function): array {
 		return array_reduce(
 			$array,
 			/**
@@ -574,8 +574,8 @@ 
 			 * @param mixed $element
 			 * @return mixed[]
 			 */
-			function ( $carry, $item ) use ( $function ): array {
-				$carry[ call_user_func( $function, $item ) ][] = $item;
+			function($carry, $item) use ($function): array {
+				$carry[call_user_func($function, $item)][] = $item;
 				return $carry;
 			},
 			array()
@@ -590,13 +590,13 @@ 
  * @param bool $preserveKeys Should inital keys be kept. Default false.
  * @return Closure(mixed[]):mixed[]
  */
-function chunk( int $count, bool $preserveKeys = false ): Closure {
+function chunk(int $count, bool $preserveKeys = false): Closure {
 	/**
 	 * @param mixed[] $array Array to chunk
 	 * @return mixed[]
 	 */
-	return function ( array $array ) use ( $count, $preserveKeys ): array {
-		return array_chunk( $array, max( 1, $count ), $preserveKeys );
+	return function(array $array) use ($count, $preserveKeys): array {
+		return array_chunk($array, max(1, $count), $preserveKeys);
 	};
 }
 
@@ -607,13 +607,13 @@ 
  * @param string $key Use column for assigning as the index. defaults to numeric keys if null.
  * @return Closure(mixed[]):mixed[]
  */
-function column( string $column, ?string $key = null ): Closure {
+function column(string $column, ?string $key = null): Closure {
 	/**
 	 * @param mixed[] $array
 	 * @return mixed[]
 	 */
-	return function ( array $array ) use ( $column, $key ): array {
-		return array_column( $array, $column, $key );
+	return function(array $array) use ($column, $key) : array {
+		return array_column($array, $column, $key);
 	};
 }
 
@@ -623,12 +623,12 @@ 
  * @param int|null $n Depth of nodes to flatten. If null will flatten to n
  * @return Closure(mixed[] $var): mixed[]
  */
-function flattenByN( ?int $n = null ): Closure {
+function flattenByN(?int $n = null): Closure {
 	/**
 	 * @param mixed[] $array Array to flatten
 	 * @return mixed[]
 	 */
-	return function ( array $array ) use ( $n ): array {
+	return function(array $array) use ($n) : array {
 		return array_reduce(
 			$array,
 			/**
@@ -636,14 +636,14 @@ 
 			 * @param mixed|mixed[] $element
 			 * @return array<int|string, mixed>
 			 */
-			function ( array $carry, $element ) use ( $n ): array {
+			function(array $carry, $element) use ($n) : array {
 				// Remove empty arrays.
-				if ( is_array( $element ) && empty( $element ) ) {
+				if (is_array($element) && empty($element)) {
 					return $carry;
 				}
 				// If the element is an array and we are still flattening, call again
-				if ( is_array( $element ) && ( is_null( $n ) || $n > 0 ) ) { // @phpstan-ignore-line
-					$carry = array_merge( $carry, flattenByN( $n ? $n - 1 : null )( $element ) );
+				if (is_array($element) && (is_null($n) || $n > 0)) { // @phpstan-ignore-line
+					$carry = array_merge($carry, flattenByN($n ? $n - 1 : null)($element));
 				} else {
 					// Else just add the element.
 					$carry[] = $element;
@@ -661,13 +661,13 @@ 
  * @param mixed[] ...$with The array values to replace with
  * @return Closure(mixed[]):mixed[]
  */
-function replaceRecursive( array ...$with ): Closure {
+function replaceRecursive(array ...$with): Closure {
 	/**
 	 * @param mixed[] $array The array to have elements replaced from.
 	 * @return mixed[] Array with replacements.
 	 */
-	return function ( array $array ) use ( $with ): array {
-		return array_replace_recursive( $array, ...$with );
+	return function(array $array) use ($with): array {
+		return array_replace_recursive($array, ...$with);
 	};
 }
 
@@ -677,13 +677,13 @@ 
  * @param mixed[] ...$with Array with values to replace with, must have matching key with base array.
  * @return Closure(mixed[]):mixed[]
  */
-function replace( array ...$with ): Closure {
+function replace(array ...$with): Closure {
 	/**
 	 * @param mixed[] $array The array to have elements replaced from.
 	 * @return mixed[] Array with replacements.
 	 */
-	return function ( array $array ) use ( $with ): array {
-		return array_replace( $array, ...$with );
+	return function(array $array) use ($with): array {
+		return array_replace($array, ...$with);
 	};
 }
 
@@ -693,13 +693,13 @@ 
  * @param callable(mixed):Number $function The function to return the value for array sum
  * @return Closure(mixed[]):Number
  */
-function sumWhere( callable $function ): Closure {
+function sumWhere(callable $function): Closure {
 	/**
 	 * @param mixed[] $array Array to do sum() on.
 	 * @return Number The total.
 	 */
-	return function ( array $array ) use ( $function ) {
-		return array_sum( array_map( $function, $array ) );
+	return function(array $array) use ($function) {
+		return array_sum(array_map($function, $array));
 	};
 }
 
@@ -712,24 +712,24 @@ 
  * @return Closure(mixed[]):object
  * @throws InvalidArgumentException If property does not exist or is not public.
  */
-function toObject( ?object $object = null ): Closure {
+function toObject(?object $object = null): Closure {
 	$object = $object ?? new stdClass();
 
 	/**
 	 * @param mixed[] $array
 	 * @return object
 	 */
-	return function ( array $array ) use ( $object ): object {
-		foreach ( $array as $key => $value ) {
+	return function(array $array) use ($object): object {
+		foreach ($array as $key => $value) {
 			// If key is not a string or numerical, skip it.
-			if ( ! is_string( $key ) || is_numeric( $key ) ) {
+			if (!is_string($key) || is_numeric($key)) {
 				continue;
 			}
 
 			try {
 				$object->{$key} = $value;
-			} catch ( \Throwable $th ) {
-				throw new \InvalidArgumentException( "Property {$key} does not exist or is not public." );
+			} catch (\Throwable $th) {
+				throw new \InvalidArgumentException("Property {$key} does not exist or is not public.");
 			}
 		}
 		return $object;
@@ -749,13 +749,13 @@ 
  *            JSON_PRETTY_PRINT, JSON_UNESCAPED_LINE_TERMINATORS,
  *            JSON_UNESCAPED_SLASHES, JSON_UNESCAPED_UNICODE, JSON_THROW_ON_ERROR
  */
-function toJson( int $flags = 0, int $depth = 512 ): Closure {
+function toJson(int $flags = 0, int $depth = 512): Closure {
 	/**
 	 * @param mixed $data
 	 * @return string|null
 	 */
-	return function ( $data ) use ( $flags, $depth ): ?string {
-		return \json_encode( $data, $flags, max( 1, $depth ) ) ?: null;
+	return function($data) use ($flags, $depth): ?string {
+		return \json_encode($data, $flags, max(1, $depth)) ?: null;
 	};
 }
 
@@ -774,13 +774,13 @@ 
  * @param int $flag Uses php stock sort constants or numerical values.
  * @return Closure(mixed[]):mixed[]
  */
-function sort( int $flag = SORT_REGULAR ): Closure {
+function sort(int $flag = SORT_REGULAR): Closure {
 	/**
 	 *  @param mixed[]$array The array to sort
 	 *  @return mixed[] The sorted array (new array)
 	 */
-	return function ( array $array ) use ( $flag ) {
-		\sort( $array, $flag );
+	return function(array $array) use ($flag) {
+		\sort($array, $flag);
 		return $array;
 	};
 }
@@ -792,13 +792,13 @@ 
  * @param int $flag Uses php stock sort constants or numerical values.
  * @return Closure(mixed[]):mixed[]
  */
-function rsort( int $flag = SORT_REGULAR ): Closure {
+function rsort(int $flag = SORT_REGULAR): Closure {
 	/**
 	 *  @param mixed[]$array The array to sort
 	 *  @return mixed[] The sorted array (new array)
 	 */
-	return function ( array $array ) use ( $flag ) {
-		\rsort( $array, $flag );
+	return function(array $array) use ($flag) {
+		\rsort($array, $flag);
 		return $array;
 	};
 }
@@ -810,13 +810,13 @@ 
  * @param int $flag Uses php stock sort constants or numerical values.
  * @return Closure(mixed[]):mixed[]
  */
-function ksort( int $flag = SORT_REGULAR ): Closure {
+function ksort(int $flag = SORT_REGULAR): Closure {
 	/**
 	 *  @param mixed[]$array The array to sort
 	 *  @return mixed[] The sorted array (new array)
 	 */
-	return function ( array $array ) use ( $flag ) {
-		\ksort( $array, $flag );
+	return function(array $array) use ($flag) {
+		\ksort($array, $flag);
 		return $array;
 	};
 }
@@ -827,13 +827,13 @@ 
  * @param int $flag Uses php stock sort constants or numerical values.
  * @return Closure(mixed[]):mixed[]
  */
-function krsort( int $flag = SORT_REGULAR ): Closure {
+function krsort(int $flag = SORT_REGULAR): Closure {
 	/**
 	 *  @param mixed[]$array The array to sort
 	 *  @return mixed[] The sorted array (new array)
 	 */
-	return function ( array $array ) use ( $flag ) {
-		\krsort( $array, $flag );
+	return function(array $array) use ($flag) {
+		\krsort($array, $flag);
 		return $array;
 	};
 }
@@ -845,13 +845,13 @@ 
  * @param int $flag Uses php stock sort constants or numerical values.
  * @return Closure(mixed[]):mixed[]
  */
-function asort( int $flag = SORT_REGULAR ): Closure {
+function asort(int $flag = SORT_REGULAR): Closure {
 	/**
 	 *  @param mixed[]$array The array to sort
 	 *  @return mixed[] The sorted array (new array)
 	 */
-	return function ( array $array ) use ( $flag ) {
-		\asort( $array, $flag );
+	return function(array $array) use ($flag) {
+		\asort($array, $flag);
 		return $array;
 	};
 }
@@ -863,13 +863,13 @@ 
  * @param int $flag Uses php stock sort constants or numerical values.
  * @return Closure(mixed[]):mixed[]
  */
-function arsort( int $flag = SORT_REGULAR ): Closure {
+function arsort(int $flag = SORT_REGULAR): Closure {
 	/**
 	 *  @param mixed[]$array The array to sort
 	 *  @return mixed[] The sorted array (new array)
 	 */
-	return function ( array $array ) use ( $flag ) {
-		\arsort( $array, $flag );
+	return function(array $array) use ($flag) {
+		\arsort($array, $flag);
 		return $array;
 	};
 }
@@ -884,8 +884,8 @@ 
 	 *  @param mixed[]$array The array to sort
 	 *  @return mixed[] The sorted array (new array)
 	 */
-	return function ( array $array ) {
-		\natsort( $array );
+	return function(array $array) {
+		\natsort($array);
 		return $array;
 	};
 }
@@ -900,8 +900,8 @@ 
 	 *  @param mixed[]$array The array to sort
 	 *  @return mixed[] The sorted array (new array)
 	 */
-	return function ( array $array ) {
-		\natcasesort( $array );
+	return function(array $array) {
+		\natcasesort($array);
 		return $array;
 	};
 }
@@ -912,13 +912,13 @@ 
  * @param callable(mixed $a, mixed $b): int $function
  * @return Closure(mixed[]):mixed[]
  */
-function uksort( callable $function ): Closure {
+function uksort(callable $function): Closure {
 	/**
 	 *  @param mixed[] $array The array to sort
 	 *  @return mixed[] The sorted array (new array)
 	 */
-	return function ( array $array ) use ( $function ) {
-		\uksort( $array, $function );
+	return function(array $array) use ($function) {
+		\uksort($array, $function);
 		return $array;
 	};
 }
@@ -930,13 +930,13 @@ 
  * @param callable(mixed $a, mixed $b): int $function
  * @return Closure(mixed[]):mixed[]
  */
-function uasort( callable $function ): Closure {
+function uasort(callable $function): Closure {
 	/**
 	 *  @param mixed[]$array The array to sort
 	 *  @return mixed[] The sorted array (new array)
 	 */
-	return function ( array $array ) use ( $function ) {
-		\uasort( $array, $function );
+	return function(array $array) use ($function) {
+		\uasort($array, $function);
 		return $array;
 	};
 }
@@ -949,13 +949,13 @@ 
  * @param callable(mixed $a, mixed $b): int $function
  * @return Closure(mixed[]):mixed[]
  */
-function usort( callable $function ): Closure {
+function usort(callable $function): Closure {
 	/**
 	 *  @param mixed[]$array The array to sort
 	 *  @return mixed[] The sorted array (new array)
 	 */
-	return function ( array $array ) use ( $function ) {
-		\usort( $array, $function );
+	return function(array $array) use ($function) {
+		\usort($array, $function);
 		return $array;
 	};
 }
@@ -967,11 +967,11 @@ 
  * @param mixed $initialValue
  * @return Closure(mixed[]):mixed[]
  */
-function scan( callable $function, $initialValue ): Closure {
-	return function ( array $array ) use ( $function, $initialValue ) {
+function scan(callable $function, $initialValue): Closure {
+	return function(array $array) use ($function, $initialValue) {
 		$carry[] = $initialValue;
-		foreach ( $array as $key => $value ) {
-			$initialValue = $function( $initialValue, $value );
+		foreach ($array as $key => $value) {
+			$initialValue = $function($initialValue, $value);
 			$carry[]      = $initialValue;
 		}
 		return $carry;
@@ -985,14 +985,14 @@ 
  * @param mixed $initialValue
  * @return Closure(mixed[]):mixed[]
  */
-function scanR( callable $function, $initialValue ): Closure {
-	return function ( array $array ) use ( $function, $initialValue ) {
+function scanR(callable $function, $initialValue): Closure {
+	return function(array $array) use ($function, $initialValue) {
 		$carry[] = $initialValue;
-		foreach ( array_reverse( $array ) as $key => $value ) {
-			$initialValue = $function( $initialValue, $value );
+		foreach (array_reverse($array) as $key => $value) {
+			$initialValue = $function($initialValue, $value);
 			$carry[]      = $initialValue;
 		}
-		return \array_reverse( $carry );
+		return \array_reverse($carry);
 	};
 }
 
@@ -1003,13 +1003,13 @@ 
  * @param mixed $initial
  * @return Closure(mixed[]):mixed
  */
-function fold( callable $callable, $initial = array() ): Closure {
+function fold(callable $callable, $initial = array()): Closure {
 	/**
 	 * @param mixed[] $array
 	 * @return mixed
 	 */
-	return function ( array $array ) use ( $callable, $initial ) {
-		return array_reduce( $array, $callable, $initial );
+	return function(array $array) use ($callable, $initial) {
+		return array_reduce($array, $callable, $initial);
 	};
 }
 
@@ -1020,13 +1020,13 @@ 
  * @param mixed $initial
  * @return Closure(mixed[]):mixed
  */
-function foldR( callable $callable, $initial = array() ): Closure {
+function foldR(callable $callable, $initial = array()): Closure {
 	/**
 	 * @param mixed[] $array
 	 * @return mixed
 	 */
-	return function ( array $array ) use ( $callable, $initial ) {
-		return array_reduce( \array_reverse( $array ), $callable, $initial );
+	return function(array $array) use ($callable, $initial) {
+		return array_reduce(\array_reverse($array), $callable, $initial);
 	};
 }
 
@@ -1038,14 +1038,14 @@ 
  * @param mixed $initial
  * @return Closure(mixed[]):mixed
  */
-function foldKeys( callable $callable, $initial = array() ): Closure {
+function foldKeys(callable $callable, $initial = array()): Closure {
 	/**
 	 * @param mixed[] $array
 	 * @return mixed
 	 */
-	return function ( array $array ) use ( $callable, $initial ) {
-		foreach ( $array as $key => $value ) {
-			$initial = $callable( $initial, $key, $value );
+	return function(array $array) use ($callable, $initial) {
+		foreach ($array as $key => $value) {
+			$initial = $callable($initial, $key, $value);
 		}
 		return $initial;
 	};
@@ -1058,18 +1058,18 @@ 
  * @return Closure(mixed[]):mixed[]
  * @throws \InvalidArgumentException if count is negative
  */
-function take( int $count = 1 ): Closure {
+function take(int $count = 1): Closure {
 	// throw InvalidArgumentException if count is negative
-	if ( $count < 0 ) {
-		throw new \InvalidArgumentException( __FUNCTION__ . ' count must be greater than or equal to 0' );
+	if ($count < 0) {
+		throw new \InvalidArgumentException(__FUNCTION__ . ' count must be greater than or equal to 0');
 	}
 
 	/**
 	 * @param mixed[] $array
 	 * @return mixed[]
 	 */
-	return function ( array $array ) use ( $count ) {
-		return \array_slice( $array, 0, $count );
+	return function(array $array) use ($count) {
+		return \array_slice($array, 0, $count);
 	};
 }
 
@@ -1080,15 +1080,15 @@ 
  * @return Closure(mixed[]):mixed[]
  * @throws \InvalidArgumentException if count is negative
  */
-function takeLast( int $count = 1 ): Closure {
+function takeLast(int $count = 1): Closure {
 	// throw InvalidArgumentException if count is negative
-	if ( $count < 0 ) {
-		throw new \InvalidArgumentException( __FUNCTION__ . ' count must be greater than or equal to 0' );
+	if ($count < 0) {
+		throw new \InvalidArgumentException(__FUNCTION__ . ' count must be greater than or equal to 0');
 	}
 
 	// If count is 0, return an empty array
-	if ( $count === 0 ) {
-		return function ( array $array ) {
+	if ($count === 0) {
+		return function(array $array) {
 			return array();
 		};
 	}
@@ -1097,8 +1097,8 @@ 
 	 * @param mixed[] $array
 	 * @return mixed[]
 	 */
-	return function ( array $array ) use ( $count ) {
-		return \array_slice( $array, - $count );
+	return function(array $array) use ($count) {
+		return \array_slice($array, - $count);
 	};
 }
 
@@ -1109,18 +1109,18 @@ 
  * @param callable(mixed): bool $conditional
  * @return Closure(mixed[]):mixed[]
  */
-function takeUntil( callable $conditional ): Closure {
+function takeUntil(callable $conditional): Closure {
 	/**
 	 * @param mixed[] $array
 	 * @return mixed[]
 	 */
-	return function ( array $array ) use ( $conditional ) {
+	return function(array $array) use ($conditional) {
 		$carry = array();
-		foreach ( $array as $key => $value ) {
-			if ( true === $conditional( $value ) ) {
+		foreach ($array as $key => $value) {
+			if (true === $conditional($value)) {
 				break;
 			}
-			$carry[ $key ] = $value;
+			$carry[$key] = $value;
 		}
 		return $carry;
 	};
@@ -1133,18 +1133,18 @@ 
  * @param callable(mixed): bool $conditional
  * @return Closure(mixed[]):mixed[]
  */
-function takeWhile( callable $conditional ): Closure {
+function takeWhile(callable $conditional): Closure {
 	/**
 	 * @param mixed[] $array
 	 * @return mixed[]
 	 */
-	return function ( array $array ) use ( $conditional ) {
+	return function(array $array) use ($conditional) {
 		$carry = array();
-		foreach ( $array as $key => $value ) {
-			if ( false === $conditional( $value ) ) {
+		foreach ($array as $key => $value) {
+			if (false === $conditional($value)) {
 				break;
 			}
-			$carry[ $key ] = $value;
+			$carry[$key] = $value;
 		}
 		return $carry;
 	};