phln\Phln

Complexity

Total Complexity

102

Size/Duplication

Total Lines	1924
Duplicated Lines	0 %

Importance

Changes

0

<?php
class Phln
{
    const all = \phln\collection\all;
    const any = \phln\collection\any;
    const append = \phln\collection\append;
    const chunk = \phln\collection\chunk;
    const collapse = \phln\collection\collapse;
    const concat = \phln\collection\concat;
    const contains = \phln\collection\contains;
    const filter = \phln\collection\filter;
    const find = \phln\collection\find;
    const flatMap = \phln\collection\flatMap;
    const fromPairs = \phln\collection\fromPairs;
    const head = \phln\collection\head;
    const init = \phln\collection\init;
    const join = \phln\collection\join;
    const last = \phln\collection\last;
    const length = \phln\collection\length;
    const map = \phln\collection\map;
    const mapIndexed = \phln\collection\mapIndexed;
    const none = \phln\collection\none;
    const nth = \phln\collection\nth;
    const pluck = \phln\collection\pluck;
    const prepend = \phln\collection\prepend;
    const range = \phln\collection\range;
    const reduce = \phln\collection\reduce;
    const reject = \phln\collection\reject;
    const reverse = \phln\collection\reverse;
    const slice = \phln\collection\slice;
    const sort = \phln\collection\sort;
    const sortBy = \phln\collection\sortBy;
    const tail = \phln\collection\tail;
    const unique = \phln\collection\unique;
    const F = \phln\fn\F;
    const T = \phln\fn\T;
    const otherwise = \phln\fn\otherwise;
    const always = \phln\fn\always;
    const apply = \phln\fn\apply;
    const arity = \phln\fn\arity;
    const compose = \phln\fn\compose;
    const curry = \phln\fn\curry;
    const curryN = \phln\fn\curryN;
    const identity = \phln\fn\identity;
    const negate = \phln\fn\negate;
    const of = \phln\fn\of;
    const once = \phln\fn\once;
    const __ = \phln\fn\__;
    const partial = \phln\fn\partial;
    const partialRight = \phln\fn\partialRight;
    const pipe = \phln\fn\pipe;
    const swap = \phln\fn\swap;
    const tap = \phln\fn\tap;
    const throwException = \phln\fn\throwException;
    const unapply = \phln\fn\unapply;
    const allPass = \phln\logic\allPass;
    const both = \phln\logic\both;
    const cond = \phln\logic\cond;
    const defaultTo = \phln\logic\defaultTo;
    const either = \phln\logic\either;
    const ifElse = \phln\logic\ifElse;
    const isEmpty = \phln\logic\isEmpty;
    const not = \phln\logic\not;
    const add = \phln\math\add;
    const dec = \phln\math\dec;
    const divide = \phln\math\divide;
    const inc = \phln\math\inc;
    const mean = \phln\math\mean;
    const median = \phln\math\median;
    const modulo = \phln\math\modulo;
    const multiply = \phln\math\multiply;
    const product = \phln\math\product;
    const subtract = \phln\math\subtract;
    const sum = \phln\math\sum;
    const eqProps = \phln\object\eqProps;
    const keys = \phln\object\keys;
    const merge = \phln\object\merge;
    const objOf = \phln\object\objOf;
    const omit = \phln\object\omit;
    const path = \phln\object\path;
    const pathOr = \phln\object\pathOr;
    const pick = \phln\object\pick;
    const prop = \phln\object\prop;
    const props = \phln\object\props;
    const toPairs = \phln\object\toPairs;
    const values = \phln\object\values;
    const where = \phln\object\where;
    const whereEq = \phln\object\whereEq;
    const clamp = \phln\relation\clamp;
    const difference = \phln\relation\difference;
    const equals = \phln\relation\equals;
    const gt = \phln\relation\gt;
    const gte = \phln\relation\gte;
    const intersection = \phln\relation\intersection;
    const lt = \phln\relation\lt;
    const lte = \phln\relation\lte;
    const max = \phln\relation\max;
    const min = \phln\relation\min;
    const pathEq = \phln\relation\pathEq;
    const propEq = \phln\relation\propEq;
    const match = \phln\string\match;
    const regexp = \phln\string\regexp;
    const replace = \phln\string\replace;
    const split = \phln\string\split;
    const test = \phln\string\test;
    const is = \phln\type\is;
    const typeCond = \phln\type\typeCond;

    /**
     * Returns `true` if all elements of array match the predicate, `false` otherwise.
     *
     * @phlnSignature (a -> Boolean) -> [a] -> Boolean
     * @phlnCategory collection
     * @param callable $predicate
     * @param array $list
     * @return \Closure|bool
     * @example
     *      $onlyTwos = P::all(P::equals(2));
     *      $onlyTwos([1, 2, 2]); // false
     */
    public static function all(callable $predicate = NULL, array $list = [])
    {
        return \phln\collection\all(...func_get_args());
    }

    /**
     * Returns `true` if at least one of array elements match the predicate, `false` otherwise.
     *
     * @phlnSignature (a -> Boolean) -> [a] -> Boolean
     * @phlnCategory collection
     * @param callable $predicate
     * @param array $list
     * @return \Closure|bool
     * @example
     *      $hasTwos = P::any(P::equals(2));
     *      $hasTwos([1, 2, 3, 4]); // true
     */
    public static function any(callable $predicate = NULL, array $list = [])
    {
        return \phln\collection\any(...func_get_args());
    }

    /**
     * Returns a new list containing the contents of the given list or string, followed by the given element.
     *
     * @phlnSignature a -> [a] -> [a]
     * @phlnSignature String -> String -> String
     * @phlnCategory collection
     * @param mixed $value
     * @param array|string $collection
     * @return \Closure|string|array
     * @example
     *      P::append(3, [1, 2]); // [1, 2, 3]
     *      P::append([3], [1, 2]); // [1, 2, [3]]
     *      P::append('foo', 'bar'); // 'barfoo'
     */
    public static function append($value = NULL, $collection = NULL)
    {
        return \phln\collection\append(...func_get_args());
    }

    /**
     * Chunks an array or string into arrays with `size` elements.
     * The last chunk may contain less than `size` elements.
     *
     * @phlnSignature Number -> [a] -> [[a]]
     * @phlnSignature Number -> String -> [String]
     * @phlnCategory collection
     * @param integer $size
     * @param array|string $collection
     * @return \Closure|array
     * @example
     *      P::chunk(2, [1, 2, 3, 4]); // [[1, 2], [3, 4]]
     *      P::chunk(2, 'hello'); // ['he', 'll', 'o']
     */
    public static function chunk(int $size = 0, $collection = NULL)
    {
        return \phln\collection\chunk(...func_get_args());
    }

    /**
     * Flattens array elements by one level
     *
     * @phlnSignature [[*], [*]] -> [*, *]
     * @phlnCategory collection
     * @param array $list
     * @return array
     */
    public static function collapse(array $list): array
    {
        return \phln\collection\collapse(...func_get_args());
    }

    /**
     * Returns the result of concatenating the given lists or strings.
     *
     * Note: `P::concat` expects both arguments to be of the same type, otherwise it will throw an exception.
     *
     * @phlnSignature [a] -> [a] -> [a]
     * @phlnSignature String -> String -> String
     * @phlnCategory collection
     * @param string|array $a
     * @param string|array $b
     * @return \Closure|string|array
     * @throws \InvalidArgumentException
     * @example
     *      P::concat([1, 2], [3]); // [1, 2, 3]
     *      P::concat('foo', 'bar'); // 'foobar'
     */
    public static function concat($a = NULL, $b = NULL)
    {
        return \phln\collection\concat(...func_get_args());
    }

    /**
     * Returns `true` if the specified value is equal, `P::equals` terms,
     * to at least one element of the given collection; `false` otherwise.
     *
     * @phlnSignature a -> [a] -> Boolean
     * @phlnSignature String -> String -> Boolean
     * @phlnCategory collection
     * @param mixed $value
     * @param array|string $collection
     * @return \Closure|bool
     * @example
     *      P::contains(1, [1, 2, 3]); // true
     *      P::contains('foo', 'foobar'); // true
     */
    public static function contains($value = NULL, $collection = NULL)
    {
        return \phln\collection\contains(...func_get_args());
    }

    /**
     * Filters elements of an array using a callback function
     *
     * @phlnSignature (a -> Boolean) -> [a] -> Boolean
     * @phlnCategory collection
     * @param callable $predicate
     * @param array $list
     * @return \Closure|mixed
     * @example
     *      P::filter(equals(1), [1, 2, 3]); // [1]
     */
    public static function filter(callable $predicate = NULL, array $list = [])
    {
        return \phln\collection\filter(...func_get_args());
    }

    /**
     * Returns the first element of the list which matches the predicate,
     * or `null` if no element matches.
     *
     * @phlnSignature (a -> Boolean) -> [a] -> a
     * @phlnCategory collection
     * @param callable $predicate
     * @param array $list
     * @return \Closure|mixed
     * @example
     *      $xs = [['a' => 1], ['a' => 2], ['a' => 3]];
     *      P::find(equals(['a' => 1]), $xs); // ['a' => 1]
     */
    public static function find(callable $predicate = NULL, array $list = [])
    {
        return \phln\collection\find(...func_get_args());
    }

    /**
     * Maps a function over list and concatenates results
     *
     * @phlnSignature (a -> b) -> [a] -> [b]
     * @phlnCategory collection
     * @param callable $mapper
     * @param array $list
     * @return \Closure|mixed
     * @example
     *      $duplicateElements = P::flatMap(function ($i) {
     *          return [$i, $i];
     *      });
     *
     *      $duplicateElements([1, 2]); // [1, 1, 2, 2]
     */
    public static function flatMap(callable $mapper = NULL, array $list = [])
    {
        return \phln\collection\flatMap(...func_get_args());
    }

    /**
     * Creates a new key => value object from list of pairs.
     *
     * @phlnSignature [[k, v]] -> {k: v}
     * @phlnCategory collection
     * @param array $pairs
     * @return array
     * @example
     *      P::fromPairs([['foo', 1], ['bar', 2]]); // [ 'foo' => 1, 'bar' => 2 ]
     */
    public static function fromPairs(array $pairs): array
    {
        return \phln\collection\fromPairs(...func_get_args());
    }

    /**
     * Returns the first element of a given list or string
     *
     * @phlnSignature [a] -> a | Null
     * @phlnSignature String -> String
     * @phlnCategory collection
     * @param array $collection
     * @return mixed|null
     * @example
     *      P::head([1, 2, 3]); // 1
     *      P::head([]); // null
     *      P::head('foo'); // 'f'
     *      P::head('f'); // ''
     */
    public static function head($collection)
    {
        return \phln\collection\head(...func_get_args());
    }

    /**
     * Returns all but the last element of the given array or string.
     *
     * @phlnSignature [a] -> [a]
     * @phlnSignature String -> String
     * @phlnCategory collection
     * @param array|string $collection
     * @return array|string
     * @example
     *      P::init([1, 2, 3]); // [1, 2]
     *      P::init([1, 2]); // [1]
     *      P::init([1]); // []
     *      P::init([]); // []
     *
     *      P::init('lorem'); // 'lore'
     *      P::init('lo'); // 'l'
     *      P::init('l'); // ''
     *      P::init(''); // ''
     */
    public static function init($collection)
    {
        return \phln\collection\init(...func_get_args());
    }

    /**
     * Returns a string made by inserting the separator between each element and concatenating all the elements into a single string.
     *
     * @phlnSignature String -> [a] -> String
     * @phlnCategory collection
     * @param string $separator
     * @param array $list
     * @return \Closure|mixed
     * @example
     *      $spacer = P::join(' ');
     *      $spacer([1, 2, 3]); // '1 2 3'
     */
    public static function join(string $separator = '', array $list = [])
    {
        return \phln\collection\join(...func_get_args());
    }

    /**
     * Returns the last element of the given list or string.
     *
     * @phlnSignature [a] -> a
     * @phlnSignature String -> String
     * @phlnCategory collection
     * @param array|string $list
     * @return mixed|null
     * @example
     *      P::last([1, 2, 3]); // 3
     *      P::last([]); // null
     *      P::last('foo'); // 'o'
     *      P::last('f'); // 'f'
     */
    public static function last($list)
    {
        return \phln\collection\last(...func_get_args());
    }

    /**
     * Returns the number of elements in the array or string
     *
     * @phlnSignature [a] -> Number
     * @phlnSignature String -> Number
     * @phlnCategory collection
     * @param string|array $collection
     * @return int
     * @example
     *      P::length('lorem'); // 5
     */
    public static function length($collection): int
    {
        return \phln\collection\length(...func_get_args());
    }

    /**
     * Applies the callback to the elements of the given arrays
     *
     * @phlnSignature (a -> b) -> [a] -> [b]
     * @phlnCategory collection
     * @param callable $fn
     * @param array $list
     * @return \Closure|array
     */
    public static function map(callable $fn = NULL, array $list = [])
    {
        return \phln\collection\map(...func_get_args());
    }

    /**
     * Applies the callback to the elements of the given arrays
     *
     * Callback will receive index of iterated value as a second argument.
     *
     * @phlnSignature ((a, i) -> b) -> [a] -> [b]
     * @phlnCategory collection
     * @param callable $fn
     * @param array $list
     * @return \Closure|array
     */
    public static function mapIndexed(callable $fn = NULL, array $list = [])
    {
        return \phln\collection\mapIndexed(...func_get_args());
    }

    /**
     * Returns `true` if no elements of the list match the predicate, `false` otherwise.
     *
     * @phlnSignature (a -> Boolean) -> [a] -> Boolean
     * @phlnCategory collection
     * @param callable $predicate
     * @param array $list
     * @return \Closure|mixed
     * @example
     *      $isEven = function ($i) {
     *          return $i % 2 === 0;
     *      };
     *
     *      P::none($isEven, [1, 3, 5]); // true
     *      P::none($isEven, [1, 3, 5, 6]); // false
     */
    public static function none(callable $predicate = NULL, array $list = [])
    {
        return \phln\collection\none(...func_get_args());
    }

    /**
     * Returns the nth element of the given list or string.
     * If n is negative the element at index length - n is returned.
     *
     * @phlnSignature Number -> [a] -> a | Null
     * @phlnCategory collection
     * @param integer $n
     * @param array $list
     * @return \Closure|mixed
     * @example
     *      P::nth(1, [1, 2, 3]); // 2
     *      P::nth(-1, [1, 2, 3]); // 3
     */
    public static function nth(int $n = 0, array $list = [])
    {
        return \phln\collection\nth(...func_get_args());
    }

    /**
     * Returns a new list by plucking the same named property off all objects in the list supplied.
     *
     * @phlnSignature k -> [{k: v}] -> v
     * @phlnCategory collection
     * @param string|integer $key
     * @param array $list
     * @return \Closure|array
     * @example
     *      $list = [['a' => 1], ['a' => 2]];
     *      P::pluck('a', $list); // [1, 2]
     */
    public static function pluck($key = '', array $list = [])
    {
        return \phln\collection\pluck(...func_get_args());
    }

    /**
     * Returns a new collection with the given element at the front, followed by the contents of the list or string.
     *
     * @phlnSignature a -> [a] -> [a]
     * @phlnSignature String -> String -> String
     * @phlnCategory collection
     * @param mixed $value
     * @param string|array $collection
     * @return \Closure|array
     * @example
     *      P::prepend(3, [1, 2]); // [3, 1, 2]
     *      P::prepend([3], [1, 2]); // [[3], 1, 2]
     *      P::prepend('foo', 'bar'); // [[3], 1, 2]
     */
    public static function prepend($value = NULL, $collection = NULL)
    {
        return \phln\collection\prepend(...func_get_args());
    }

    /**
     * Returns a list of numbers from `from` (inclusive) to `to` (exclusive).
     *
     * @phlnSignature Integer a => a -> a -> [a]
     * @phlnCategory collection
     * @param int $start
     * @param int $end
     * @return \Closure|array
     * @example
     *      P::range(0, 3); // [0, 1, 2]
     */
    public static function range(int $start = 0, int $end = 0)
    {
        return \phln\collection\range(...func_get_args());
    }

    /**
     * Returns a single item by iterating through the list, successively calling the iterator function and passing it an accumulator value and the current value from the array, and then passing the result to the next call.
     *
     * The iterator function receives two values: (`acc`, `value`).
     *
     * @phlnSignature ((a, b) -> a) -> a -> [b] -> a
     * @phlnCategory collection
     * @param callable $reducer
     * @param mixed $initialValue
     * @param array $list
     * @return \Closure|mixed
     * @example
     *      P::reduce(P::subtract, 0, [1, 2, 3, 4]);
     *      // ((((0 - 1) - 2) - 3) - 4) => -10
     */
    public static function reduce(callable $reducer = NULL, $initialValue = NULL, array $list = [])
    {
        return \phln\collection\reduce(...func_get_args());
    }

    /**
     * The negation of `filter`.
     *
     * @phlnSignature (a -> Boolean) -> [a] -> [a]
     * @phlnCategory collection
     * @param callable $predicate
     * @param array $list
     * @return \Closure|array
     * @example
     *      $isOdd = function ($i) {
     *          return $i % 2 === 1;
     *      };
     *      P::reject($isOdd, [1, 2, 3, 4]); // [2, 4]
     */
    public static function reject(callable $predicate = NULL, array $list = [])
    {
        return \phln\collection\reject(...func_get_args());
    }

    /**
     * Returns a new list or string with the elements in reverse order.
     *
     * @phlnSignature [a] -> [a]
     * @phlnSignature String -> String
     * @phlnCategory collection
     * @param array|string $collection
     * @return array|string
     * @see \array_reverse()
     * @see \strrev()
     * @example
     *      P::reverse([1, 2, 3]); // [3, 2, 1]
     *      P::reverse('foo'); // 'oof'
     */
    public static function reverse($collection)
    {
        return \phln\collection\reverse(...func_get_args());
    }

    /**
     * Extracts a slice of the array or string
     *
     * @phlnSignature Integer -> Integer -> [a] -> [a]
     * @phlnSignature Integer -> Integer -> String -> String
     * @phlnCategory collection
     * @param integer $offset
     * @param integer $length
     * @param string|array $collection
     * @return \Closure|array|string
     * @see \array_slice()
     * @see \substr()
     * @example
     *      $takeTwo = P::slice(0, 2);
     *      $takeTwo([1, 2, 3]); // [1, 2]
     */
    public static function slice(int $offset = 0, int $length = 0, $collection = NULL)
    {
        return \phln\collection\slice(...func_get_args());
    }

    /**
     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a time and return a negative number if the first value is smaller, a positive number if it's larger, and zero if they are equal.
     *
     * @phlnSignature ((a, a) -> Number) -> [a] -> [a]
     * @phlnCategory collection
     * @param callable $comparator
     * @param array $list
     * @return \Closure|array
     * @see \usort()
     * @example
     *      $diff = function ($a, $b) {
     *          return $a - $b;
     *      };
     *
     *      P::sort($diff, [3, 2, 1]); // [1, 2, 3]
     */
    public static function sort(callable $comparator = NULL, array $list = [])
    {
        return \phln\collection\sort(...func_get_args());
    }

    /**
     * Sorts the list according to the supplied function.
     *
     * @phlnSignature (a -> b) -> [a] -> [a]
     * @phlnCategory collection
     * @param callable $mapper
     * @param array $list
     * @return \Closure|array
     * @see \array_multisort()
     * @example
     *      $alice = ['name' => 'alice'];
     *      $bob = ['name' => 'bob'];
     *      $clara = ['name' => 'clara'];
     *      $people = [$bob, $clara, $alice];
     *
     *      P::soryBy(P::prop('name'), $people); // [$alice, $bob, $clara]
     */
    public static function sortBy(callable $mapper = NULL, array $list = [])
    {
        return \phln\collection\sortBy(...func_get_args());
    }

    /**
     * Returns all but the first element of the given array or string
     *
     * @phlnSignature [a] -> [a]
     * @phlnSignature String -> String
     * @phlnCategory collection
     * @param array $collection
     * @return array
     * @example
     *      P::tail([1, 2, 3]); // [2, 3]
     *      P::tail([1]); // []
     *      P::tail([]); // []
     *      P::tail('lorem'); // 'orem'
     *      P::tail('l'); // ''
     *      P::tail(''); // ''
     */
    public static function tail($collection)
    {
        return \phln\collection\tail(...func_get_args());
    }

    /**
     * Returns a new list containing only one copy of each element in the original list. Strict comparision is used to determine equality.
     *
     * @phlnSignature [a] -> [a]
     * @phlnCategory collection
     * @param array $list
     * @return array
     * @example
     *      P::unique([3, 2, 1, 1, 3, 2]); // [3, 2, 1]
     */
    public static function unique(array $list): array
    {
        return \phln\collection\unique(...func_get_args());
    }

    /**
     * A function that always returns `false`. Any passed in parameters are ignored.
     *
     * @phlnSignature * -> Boolean
     * @phlnCategory function
     * @return bool
     */
    public static function F(): bool
    {
        return \phln\fn\F(...func_get_args());
    }

    /**
     * A function that always returns `true`. Any passed in parameters are ignored.
     *
     * @phlnSignature * -> Boolean
     * @phlnCategory function
     * @return bool
     */
    public static function T(): bool
    {
        return \phln\fn\T(...func_get_args());
    }

    /**
     * Returns a function that always returns the given value.
     * For non-primitives the value returned is a reference to the original value.
     *
     * @phlnSignature a -> (* -> a)
     * @phlnCategory function
     * @param $value
     * @return \Closure
     * @example
     *      $foo = P::always('foo');
     *      $foo(); // 'foo'
     */
    public static function always($value): \Closure
    {
        return \phln\fn\always(...func_get_args());
    }

    /**
     * Applies function `fn` to the argument list. This is useful for creating a fixed-arity function from a variadic function.
     *
     * @phlnSignature (*... -> a) -> [*] -> a
     * @phlnCategory function
     * @param callable $fn
     * @param array $arguments
     * @return \Closure|mixed
     * @example
     *      P::apply(P::sum, [1, 2]); // 3
     */
    public static function apply(callable $fn = NULL, array $arguments = [])
    {
        return \phln\fn\apply(...func_get_args());
    }

    /**
     * Takes a function and returns its arity.
     *
     * @phlnSignature (*... -> *) -> Number
     * @phlnCategory function
     * @param callable $fn
     * @return int
     * @example
     *      P::arity('var_dump'); // 1
     */
    public static function arity(callable $fn): int
    {
        return \phln\fn\arity(...func_get_args());
    }

    /**
     * Performs left-to-right function composition.
     * The leftmost function may have any arity; the remaining functions must be unary.
     *
     * **Note**: The result of pipe is not automatically curried.
     *
     * @phlnSignature [((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)] -> (a, b, ..., n) -> z)
     * @phlnCategory function
     * @param callable[] ...$fns
     * @return \Closure
     * @throws \UnderflowException
     */
    public static function compose(array $fns): \Closure
    {
        return \phln\fn\compose(...func_get_args());
    }

    /**
     * Returns a curried equivalent of the provided function.
     *
     * Curried function doesn't require providing arguments one at a time.
     * If `f` is a ternary function and `g` is `P::curry(f)`, the following are equivalent.
     *      * g(1)(2)(3)
     *      * g(1)(2, 3)
     *      * g(1, 2)(3)
     *      * g(1, 2, 3)
     *
     * @phlnSignature (* → a) → (* → a)
     * @phlnCategory function
     * @param callable $fn
     * @param array $args
     * @return \Closure|mixed
     */
    public static function curry(callable $fn, array $args = [])
    {
        return \phln\fn\curry(...func_get_args());
    }

    /**
     * Returns a curried equivalent of the provided function, with the specified arity.
     *
     * Curried function doesn't require providing arguments one at a time.
     * If `f` is a ternary function and `g` is `P::curryN(3, f)`, the following are equivalent.
     *      * g(1)(2)(3)
     *      * g(1)(2, 3)
     *      * g(1, 2)(3)
     *      * g(1, 2, 3)
     *
     * @phlnSignature Number -> (* → a) → (* → a)
     * @phlnCategory function
     * @param int $n
     * @param callable $fn
     * @param array $args
     * @return \Closure|mixed
     */
    public static function curryN(int $n, callable $fn, array $args = [])
    {
        return \phln\fn\curryN(...func_get_args());
    }

    /**
     * A function that does nothing but return the parameter supplied to it. Good as a default or placeholder function.
     *
     * @phlnSignature a -> a
     * @phlnCategory function
     * @param $value
     * @return mixed
     * @example
     *      P::identity(1) === 1; // 'true'
     */
    public static function identity($value)
    {
        return \phln\fn\identity(...func_get_args());
    }

    /**
     * Creates a function that negates the result of the predicate.
     *
     * @phlnSignature (*... -> *) -> (*... -> Boolean)
     * @phlnCategory function
     * @param callable $predicate
     * @return \Closure
     * @example
     *      $isEven = function ($i) {
     *          return $i % 2 === 0;
     *      };
     *
     *      P::filter(P::negate($isEven), [1, 2, 3, 4, 5, 6]); // [1, 3, 5]
     */
    public static function negate(callable $predicate): \Closure
    {
        return \phln\fn\negate(...func_get_args());
    }

    /**
     * Returns a singleton array containing the value provided.
     *
     * @phlnSignature a -> [a]
     * @phlnCategory function
     * @param mixed $value
     * @return array
     * @example
     *      P::of(null); // [null]
     *      P::of('a'); // ['a']
     */
    public static function of($value): array
    {
        return \phln\fn\of(...func_get_args());
    }

    /**
     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that `fn` can only ever be called once, no matter how many times the returned function is invoked. The first value calculated is returned in subsequent invocations.
     *
     * @phlnSignature (a... -> b) -> (a... -> b)
     * @phlnCategory function
     * @param callable $fn
     * @return \Closure
     * @example
     *      $f = P::once('\rand');
     *      $f(1, 100); // 4
     *      $f(1, 100); // 4
     *      $f(1, 100); // 4
     */
    public static function once(callable $fn): \Closure
    {
        return \phln\fn\once(...func_get_args());
    }

    /**
     * Takes a function `f` and a list of arguments, and returns a function `g`.
     * When applied, `g` returns the result of applying `f` to the arguments provided initially followed by the arguments provided to `g`.
     *
     * Special placeholder value `P::__` may be used to specify "gaps", allowing partial application of any combination of arguments, regardless of their positions.
     *
     * @phlnSignature ((a, b, c, ..., n) -> x) -> [a, b, c, ...] -> ((d, e, f, ..., n) -> x)
     * @phlnCategory function
     * @param callable $fn
     * @param array $args
     * @return \Closure
     * @example
     *      $subtractFive = P::partial(P::subtract, [P::__, 5]);
     *      $subtractFive(10); // 5
     */
    public static function partial(callable $fn = NULL, array $args = []): \Closure
    {
        return \phln\fn\partial(...func_get_args());
    }

    /**
     * Takes a function `f` and a list of arguments, and returns a function `g`. When applied, `g` returns the result of applying `f` to the arguments provided initially followed by the arguments provided to `g`.
     *
     * @phlnSignature ((a, b, c, d, ..., n) -> x) -> [d, ..., n] -> ((a, b, c) -> x)
     * @phlnCategory function
     * @param callable $fn
     * @param array $args
     * @return \Closure
     * @example
     *      $hello = function ($salutations, $name, $lastname) {
     *          return "{$salutations}, {$name} {$lastname}";
     *      };
     *
     *      $f = P::partialRight($hello, ['Jon', 'Stark']);
     *      $f('Hello'); // 'Hello, Jon Stark'
     */
    public static function partialRight(callable $fn = NULL, array $args = NULL): \Closure
    {
        return \phln\fn\partialRight(...func_get_args());
    }

    /**
     * Performs left-to-right function composition.
     * The leftmost function may have any arity; the remaining functions must be unary.
     *
     * **Note**: The result of pipe is not automatically curried.
     *
     * @phlnSignature [((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)] -> (a, b, ..., n) -> z)
     * @phlnCategory function
     * @param callable[] $fns
     * @return \Closure
     * @throws \UnderflowException
     */
    public static function pipe(array $fns): \Closure
    {
        return \phln\fn\pipe(...func_get_args());
    }

    /**
     * Returns a new function much like the supplied one, except that the first two arguments' order is reversed.
     *
     * @phlnSignature (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)
     * @phlnCategory function
     * @param callable $f
     * @return \Closure
     * @example
     *      $serialize = function ($a, $b) {
     *          return "a:{$a},b:{$b}";
     *      };
     *      P::swap($serialize)(2, 1); // 'a:1,b:2'
     */
    public static function swap(callable $f): \Closure
    {
        return \phln\fn\swap(...func_get_args());
    }

    /**
     * Runs the given function with the supplied object, then returns the object.
     *
     * @phlnSignature (a -> *) -> a -> a
     * @phlnCategory function
     * @param string|callable $fn
     * @param mixed $value
     * @return \Closure|mixed
     * @example
     *      $dump = P::tap('var_dump');
     *      $dump('foo'); // var_dumps('foo'); returns 'foo'
     */
    public static function tap(callable $fn = NULL, $value = NULL)
    {
        return \phln\fn\tap(...func_get_args());
    }

    /**
     * Returns callback which throws given exception.
     *
     * *Note:* exceptions are considered as side-efects. Use it with caution.
     *
     * @phlnSignature (String, [*]) -> (*... -> Null)
     * @phlnCategory function
     * @param string $exception
     * @param array $args
     * @return \Closure
     * @example
     *      $break = P::throwException(\LogicException::class);
     *      $break(); // -> throw new \LogicException()
     */
    public static function throwException(string $exception = 'Exception', array $args = []): \Closure
    {
        return \phln\fn\throwException(...func_get_args());
    }

    /**
     * Takes a function `fn`, which takes a single array argument, and returns a function which:
     * * takes any number of positional arguments;
     * * passes these arguments to `fn` as an array and returns the result
     *
     * In other words, `P::unapply` derives a variadic function from a function which takes an array. `P::unapply` is the inverse of `P::apply`.
     *
     * @phlnSignature ([*...] -> a) -> (*... -> a)
     * @phlnCategory function
     * @param string|callable $fn
     * @param array ...$args
     * @return \Closure|mixed
     * @example
     *      P::unapply('\\json_encode')(1, 2, 3); // [1,2,3]
     */
    public static function unapply(callable $fn = NULL, ...$args)
    {
        return \phln\fn\unapply(...func_get_args());
    }

    /**
     * Takes a list of predicates and returns a predicate that returns `true` for a given list of arguments if every one of the provided predicates is satisfied by those arguments.
     *
     * The function returned is a curried function whose arity matches that of the highest-arity predicate.
     *
     * @phlnSignature [(*... -> Boolean) -> *... -> Boolean
     * @phlnCategory logic
     * @param array $predicates
     * @return callable
     * @example
     *      $ace = P::propEq('rank', 'A');
     *      $spades = P::propEq('suit', '♠︎');
     *      $aceOfSpades = P::allPass([$ace, $spades]);
     *      $aceOfSpades(['rank' => 'A', 'suit' => '♠︎']); // true
     */
    public static function allPass(array $predicates): callable
    {
        return \phln\logic\allPass(...func_get_args());
    }

    /**
     * Returns `true` when both of two provided values are truthy.
     *
     * This function is polymorphic and supports two cases:
     * 1. when both values are predicates it will return wrapper function which call to the two functions in an `&&` operation, returning `true` if both of the functions will return truthy value.
     * 2. when both values are booleans it will return result of `&&` operation
     *
     * @phlnSignature (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
     * @phlnSignature Boolean -> Boolean -> Boolean
     * @phlnCategory logic
     * @param string|callable|bool $left
     * @param string|callable|bool $right
     * @return \Closure|bool
     * @example
     *      $gt10 = P::partial(P::gt, [P::__, 10]);
     *      $lt20 = P::partial(P::lt, [P::__, 20]);
     *      $f = P::both($gt10, $lt20);
     *      $f(12); // true
     *      P::both(true, false); // false
     */
    public static function both($left = NULL, $right = NULL)
    {
        return \phln\logic\both(...func_get_args());
    }

    /**
     * Returns a function, `fn`, which encapsulates `if/else`, `if/else`, ... logic. `P::cond` takes a list of [`predicate`, `transformer`] pairs. All of the arguments to `fn` are applied to each of the `predicates` in turn until one returns a truth-y value, at which point `fn` returns the result of applying its arguments to the corresponding `transformer`. If none of the `predicates` matches, `fn` returns null.
     *
     * @phlnSignature [[(*… → Boolean),(*… → *)]] → (*… → *)
     * @phlnCategory logic
     * @param array $pairs
     * @return \Closure
     * @example
     *      $fn = P::cond([
     *          [P::equals(0), P::always('water freezes at 0°C')],
     *          [P::equals(100), P::always('water boils at 100°C')],
     *          [P::T, function(temp) {
     *              return 'nothing special happens at ' + temp + '°C';
     *          }]
     *      ]);
     *
     *      $fn(0); //=> 'water freezes at 0°C'
     *      $fn(50); //=> 'nothing special happens at 50°C'
     *      $fn(100); //=> 'water boils at 100°C'
     */
    public static function cond(array $pairs): \Closure
    {
        return \phln\logic\cond(...func_get_args());
    }

    /**
     * Returns the second argument if it is not `null`; otherwise the first argument is returned.
     *
     * @phlnSignature a -> b -> b | a
     * @phlnCategory logic
     * @param mixed $default
     * @param mixed $value
     * @return \Closure|mixed
     * @example
     *      P::defaultTo(42, null); // 42
     *      P::defaultTo(42, 'life'); // 'life'
     */
    public static function defaultTo($default = NULL, $value = NULL)
    {
        return \phln\logic\defaultTo(...func_get_args());
    }

    /**
     * Returns `true` when one of two provided values is truthy.
     *
     * This function is polymorphic and supports two cases:
     * 1. when both values are predicates it will return wrapper function which call to the two functions in an `||` operation, returning `true` if at least one of the functions will return truthy value.
     * 2. when both values are booleans it will return result of `||` operation
     *
     * @phlnSignature (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
     * @phlnSignature Boolean -> Boolean -> Boolean
     * @phlnCategory logic
     * @param string|callable|bool $left
     * @param string|callable|bool $right
     * @return \Closure|bool
     * @example
     *      $lt10 = P::partial(P::lt, [P::__, 10]);
     *      $gt20 = P::partial(P::gt, [P::__, 20]);
     *      $f = P::either($lt10, $gt20);
     *      $f(12); // false
     *      $f(9); // true
     *      $f(21); // true
     *      P::either(true, false); // true
     */
    public static function either($left = NULL, $right = NULL)
    {
        return \phln\logic\either(...func_get_args());
    }

    /**
     * Creates a function that will process either the `onTrue` or the `onFalse` function depending upon the result of the condition predicate.
     *
     * @phlnSignature (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)
     * @phlnCategory logic
     * @param callable $predicate
     * @param callable $onTrue
     * @param callable $onFalse
     * @return \Closure
     * @example
     *      $modulo15 = P::swap(P::modulo)(15);
     *      $fizzbuzz = P::ifElse(
     *          P::compose(P::equals(0), $modulo15),
     *          P::always('fizzbuzz'),
     *          P::identity
     *      );
     *
     *      $fizzbuzz(15); // 'fizzbuzz'
     *      $fizzbuzz(1); // 1
     */
    public static function ifElse(callable $predicate = NULL, callable $onTrue = NULL, callable $onFalse = NULL): \Closure
    {
        return \phln\logic\ifElse(...func_get_args());
    }

    /**
     * Returns `true` if the given value is its type's empty value; `false` otherwise.
     *
     * *Note* unlike `\empty()` this function will consider numbers, booleans and NULL as non-empty.
     *
     * @phlnSignature a -> Boolean
     * @phlnCategory logic
     * @param $value
     * @return bool
     * @example
     *      P::isEmpty(''); // true
     *      P::isEmpty([]); // true
     *      P::isEmpty(new stdClass); // true
     *      P::isEmpty(0); // false
     *      P::isEmpty(null); // false
     *      P::isEmpty(false); // false
     *      P::isEmpty(true); // false
     */
    public static function isEmpty($value): bool
    {
        return \phln\logic\isEmpty(...func_get_args());
    }

    /**
     * A function that returns the `!` of its argument. It will return `true` when passed false-y value, and `false` when passed a truth-y one.
     *
     * @phlnSignature * -> Boolean
     * @phlnCategory logic
     * @param $value
     * @return bool
     * @example
     *      P::not(0); // true
     *      P::not(true); // false
     */
    public static function not($value): bool
    {
        return \phln\logic\not(...func_get_args());
    }

    /**
     * Add two values
     *
     * @phlnSignature Number a => a -> a -> a
     * @phlnCategory math
     * @param mixed $a
     * @param mixed $b
     * @return \Closure|mixed
     */
    public static function add($a = NULL, $b = NULL)
    {
        return \phln\math\add(...func_get_args());
    }

    /**
     * Decrement its argument
     *
     * @phlnSignature Int a => a -> a
     * @phlnCategory math
     * @param mixed $number
     * @return mixed
     */
    public static function dec($number)
    {
        return \phln\math\dec(...func_get_args());
    }

    /**
     * Divide numbers. Equivalent of `a / b`
     *
     * @phlnSignature Number a => a -> a -> a
     * @phlnCategory math
     * @param mixed $a
     * @param mixed $b
     * @return \Closure|mixed
     */
    public static function divide($a = NULL, $b = NULL)
    {
        return \phln\math\divide(...func_get_args());
    }

    /**
     * Increment its argument
     *
     * @phlnSignature Int a => a -> a
     * @phlnCategory math
     * @param mixed $number
     * @return mixed
     */
    public static function inc($number)
    {
        return \phln\math\inc(...func_get_args());
    }

    /**
     * Returns the mean of the given list of numbers.
     *
     * @phlnSignature Number a => [a] -> a
     * @phlnCategory math
     * @param array $numbers
     * @example
     *      P::mean([2, 7, 9]) // 6
     * @return \Closure|mixed
     */
    public static function mean(array $numbers)
    {
        return \phln\math\mean(...func_get_args());
    }

    /**
     * Returns the median of the given list of numbers.
     *
     * @phlnSignature Number a => [a] -> a
     * @phlnCategory math
     * @param string|array $numbers
     * @return mixed
     * @example
     *      \\phln\\math\\median([7, 2, 9]) // 7
     *      \\phln\\math\\median([7, 2, 10, 9]) // 8
     */
    public static function median(array $numbers)
    {
        return \phln\math\median(...func_get_args());
    }

    /**
     * Divides the first parameter by the second and returns the remainder.
     *
     * @phlnSignature Number a => a -> a -> a
     * @phlnCategory math
     * @param string $a
     * @param string $b
     * @return \Closure|mixed
     * @example
     *      \\phln\\math\\modulo(1, 2) // 1
     */
    public static function modulo($a = NULL, $b = NULL)
    {
        return \phln\math\modulo(...func_get_args());
    }

    /**
     * Multiplies two numbers
     *
     * @phlnSignature Number a => a -> a -> a
     * @phlnCategory math
     * @param string $a
     * @param string $b
     * @return \Closure|mixed
     * @example
     *      $triple = P::multiply(3);
     *      $triple(7); // 21
     */
    public static function multiply($a = NULL, $b = NULL)
    {
        return \phln\math\multiply(...func_get_args());
    }

    /**
     * Multiplies together all the elements of a list.
     *
     * @phlnSignature Number a => [a] -> a
     * @phlnCategory math
     * @param array $numbers
     * @return mixed
     * @example
     *      P::product([2, 4, 6, 8, 100, 1]); // 38400
     */
    public static function product(array $numbers)
    {
        return \phln\math\product(...func_get_args());
    }

    /**
     * Subtracts its second argument from its first argument.
     *
     * @phlnSignature Number a => a -> a -> a
     * @phlnCategory math
     * @param number $a
     * @param number $b
     * @return \Closure|mixed
     * @example
     *      $complementaryAngle = P::subtract(90);
     *      $complementaryAngle(30); //=> 60
     */
    public static function subtract($a = NULL, $b = NULL)
    {
        return \phln\math\subtract(...func_get_args());
    }

    /**
     * Adds together all the elements of a list.
     *
     * @phlnSignature [Number] -> Number
     * @phlnCategory math
     * @param array $numbers
     * @return mixed
     * @example
     *      P::sum([1, 2, 3, 4]); // 10
     */
    public static function sum(array $numbers)
    {
        return \phln\math\sum(...func_get_args());
    }

    /**
     * Reports whether two objects have the same value, in `P::equals` terms, for the specified property.
     *
     * @phlnSignature k -> {k: v} -> {k: v} -> Boolean
     * @phlnCategory object
     * @param string $prop
     * @param array|object $a
     * @param array|object $b
     * @return \Closure|mixed
     * @example
     *      P::eqProps('name', ['name' => 'Jon'], ['name' => 'Jon']); // true
     */
    public static function eqProps(string $prop = '', $a = [], $b = [])
    {
        return \phln\object\eqProps(...func_get_args());
    }

    /**
     * Returns a list containing the names of array keys.
     *
     * @phlnSignature {k: v} -> [k]
     * @phlnCategory object
     * @param array|object $object
     * @return array
     * @see \array_keys()
     * @see \get_object_vars()
     * @example
     *      P::keys(['a' => 1, 'b' => 1]); // ['a', 'b']
     */
    public static function keys($object): array
    {
        return \phln\object\keys(...func_get_args());
    }

    /**
     * Create a new object with the keys of the first object merged with the keys of the second object. If a key exists in both objects, the value from the second object will be used.
     *
     * @phlnSignature {k: v} -> {k: v} -> {k: v}
     * @phlnCategory object
     * @param array|object $left
     * @param array|object $right
     * @return \Closure|array
     * @example
     *      $toDefaults = P::partial(P::merge, [P::__, ['x' => 0]);
     *      $toDefaults(['x' => 2, 'y' => 1]); // ['x' => 0, 'y' => 1]
     */
    public static function merge($left = [], $right = [])
    {
        return \phln\object\merge(...func_get_args());
    }

    /**
     * Creates an object containing a single key:value pair.
     *
     * @phlnSignature String -> a -> { String: a }
     * @phlnCategory object
     * @param string $key
     * @param mixed $value
     * @return \Closure|object
     * @example
     *      P::objOf('foo', 'bar'); // ['foo' => 'bar']
     */
    public static function objOf(string $key = NULL, $value = NULL)
    {
        return \phln\object\objOf(...func_get_args());
    }

    /**
     * Returns a partial copy of an object omitting the keys specified.
     *
     * @phlnSignature [String] -> {String: *} -> {String: *}
     * @phlnCategory object
     * @param array $omitKeys
     * @param array|object $object
     * @return \Closure|array
     * @example
     *      P::omit(['a', 'c'], ['a' => 1, 'b' => 2, 'c' => 3]); // ['b' => 2]
     */
    public static function omit(array $omitKeys = [], $object = [])
    {
        return \phln\object\omit(...func_get_args());
    }

    /**
     * Returns nested value using "dot notation".
     *
     * @phlnSignature String -> {k: v} -> v|Null
     * @phlnCategory object
     * @param string $path
     * @param array|object $object
     * @return \Closure|mixed
     * @example
     *      P::path('a.b', ['a' => ['b' => 'foo']]); // 'foo'
     *      P::path('a.b.c', ['a' => ['b' => 'foo']]); // null
     */
    public static function path(string $path = '', $object = [])
    {
        return \phln\object\path(...func_get_args());
    }

    /**
     * Returns nested value using "dot notation". If key is not defined, or value is NULL default value will be returned.
     *
     * @phlnSignature String -> a -> {k: v} -> v | a
     * @phlnCategory object
     * @param string $path
     * @param mixed $default
     * @param array $object
     * @return \Closure|mixed
     * @example
     *      P::pathOr('a.b', 'foo', ['a' => ['b' => 1]]); // 1
     *      P::pathOr('a.b', 'foo', ['a' => ['b' => 0]]); // 0
     *      P::pathOr('a.b', 'foo', ['a' => ['b' => null]]); // 'foo'
     *      P::pathOr('a.b', 'foo', ['a' => 1]); // 'foo'
     */
    public static function pathOr(string $path = '', $default = NULL, array $object = [])
    {
        return \phln\object\pathOr(...func_get_args());
    }

    /**
     * Returns a partial copy of an object containing only the keys specified. If the key does not exist, the property is ignored.
     *
     * @phlnSignature [String] -> {String: *} -> {String: *}
     * @phlnCategory object
     * @param array $useKeys
     * @param array|object $object
     * @return \Closure|array
     * @example
     *      P::pick(['a'], ['a' => 1, 'b' => 2]); // ['a' => 1]
     */
    public static function pick(array $useKeys = [], $object = [])
    {
        return \phln\object\pick(...func_get_args());
    }

    /**
     * Returns a function that when supplied an array returns the indicated key of that key, if it exists.
     *
     * @phlnSignature k -> {k: v} -> v
     * @phlnCategory object
     * @param string|integer $key
     * @param array|object $array
     * @return \Closure|mixed
     */
    public static function prop($key = '', $object = [])
    {
        return \phln\object\prop(...func_get_args());
    }

    /**
     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.
     *
     * @phlnSignature [k] -> {k: v} -> [v]
     * @phlnCategory object
     * @param array $props
     * @param array|object $object
     * @return \Closure|array
     * @example
     *      $fullName = P::compose(P::join(' '), P::props(['firstName', 'lastName']));
     *      $fullName(['lastName' => 'Snow', 'firstName' => 'Jon']); // 'Jon Snow'
     */
    public static function props(array $props = [], $object = [])
    {
        return \phln\object\props(...func_get_args());
    }

    /**
     * Converts an object into an array of key-value arrays.
     *
     * Note that order of output is not guaranteed.
     *
     * @phlnSignature String k => { k: v } -> [[k, v]]
     * @phlnCategory object
     * @param array|object $object
     * @return array
     * @example
     *      P::toPairs(['foo' => 1, 'bar' => 2]); // [['foo', 1], ['bar', 2]]
     */
    public static function toPairs($object): array
    {
        return \phln\object\toPairs(...func_get_args());
    }

    /**
     * Returns values of supplied object
     *
     * @phlnSignature {k: v} -> [v]
     * @phlnCategory object
     * @param array|object $object
     * @return array
     */
    public static function values($object): array
    {
        return \phln\object\values(...func_get_args());
    }

    /**
     * Takes a spec object and a test object; returns `true` if the test satisfies the spec. Each of the spec's properties must be a predicate function. Each predicate is applied to the value of the corresponding property of the test object. where returns `true` if all the predicates return true, false otherwise.
     *
     * `where` is well suited to declaratively expressing constraints for other functions such as `filter` and `find`.
     *
     * @phlnSignature {String: (* -> Boolean)} -> {String: *} -> Boolean
     * @phlnCategory object
     * @param array $predicates
     * @param array|object $object
     * @return \Closure|bool
     * @example
     *      $verifyJon = P::where([
     *          'firstName' => P::equals('Jon'),
     *          'lastName' => P::equals('Snow'),
     *      ]);
     *
     *      $verifyJon(['firstName' => 'Jon', 'lastName' => 'Snow', 'house' => 'Stark']); // true
     */
    public static function where(array $predicates = [], $object = [])
    {
        return \phln\object\where(...func_get_args());
    }

    /**
     * Takes a spec object and a test object; returns `true` if the test satisfies the spec, false otherwise. An object satisfies the spec if, for each of the spec's properties, accessing that property of the object gives the same value (in `P::equals()` terms) as accessing that property of the spec.
     *
     * @phlnSignature {String: *} -> {String: *} -> Boolean
     * @phlnCategory object
     * @param array $predicates
     * @param array|object $object
     * @return \Closure|bool
     * @example
     *      $verifyJon = P::whereEq(['firstName' => 'Jon', 'lastName' => 'Snow']);
     *      $verifyJon(['firstName' => 'Jon', 'lastName' => 'Snow']); // true
     */
    public static function whereEq(array $predicates = [], $object = [])
    {
        return \phln\object\whereEq(...func_get_args());
    }

    /**
     * Restricts a number to be within a range.
     *
     * @phlnSignature Number a => a -> a -> a -> a
     * @phlnCategory relation
     * @param mixed $min
     * @param mixed $max
     * @param mixed $value
     * @return \Closure|mixed
     * @example
     *      P::clamp(-1, 1, -100); // -1
     *      P::clamp(-1, 1, 100); // 1
     *      P::clamp(-1, 1, 0); // 0
     */
    public static function clamp($min = NULL, $max = NULL, $value = NULL)
    {
        return \phln\relation\clamp(...func_get_args());
    }

    /**
     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.
     *
     * @phlnSignature [*] -> [*] -> [*]
     * @phlnCategory relation
     * @param array $left
     * @param array $right
     * @return \Closure|array
     * @example
     *      P::difference([1, 2, 3, 4], [3, 4, 5, 6]); // [1, 2]
     */
    public static function difference(array $left = NULL, array $right = NULL)
    {
        return \phln\relation\difference(...func_get_args());
    }

    /**
     * Returns `true` if its arguments are equivalent, `false` otherwise.
     *
     * @phlnSignature a -> b -> Boolean
     * @phlnCategory relation
     * @param mixed $a
     * @param mixed $b
     * @return \Closure|bool
     * @example
     *      P::equals(1, 1); // true
     *      P::equals(1, '1'); // false
     *      P::equals(1, 2); // false
     */
    public static function equals($a = NULL, $b = NULL)
    {
        return \phln\relation\equals(...func_get_args());
    }

    /**
     * Returns `true` if the first argument is greater than the second; `false` otherwise.
     *
     * @phlnSignature Ord a => a -> a -> Boolean
     * @phlnCategory relation
     * @param mixed $a
     * @param mixed $b
     * @return \Closure|bool
     * @example
     *      P::gt(2, 1); // true
     */
    public static function gt($a = NULL, $b = NULL)
    {
        return \phln\relation\gt(...func_get_args());
    }

    /**
     * Returns `true` if the first argument is greater than or equal to the second; `false` otherwise.
     *
     * @phlnSignature Ord a => a -> a -> Boolean
     * @phlnCategory relation
     * @param string $a
     * @param string $b
     * @return \Closure|mixed
     * @example
     *      P::gte(2, 1); // true
     *      P::gte(2, 2); // true
     *      P::gte(2, 3); // false
     */
    public static function gte($a = NULL, $b = NULL)
    {
        return \phln\relation\gte(...func_get_args());
    }

    /**
     * Combines two lists into a set composed of those elements common to both lists.
     *
     * @phlnSignature [*] -> [*] -> [*]
     * @phlnCategory relation
     * @param array $left
     * @param array $right
     * @return \Closure|mixed
     * @example
     *      P::intersection([1, 2, 3, 4], [6, 4, 5]); // [4]
     */
    public static function intersection(array $left = [], array $right = [])
    {
        return \phln\relation\intersection(...func_get_args());
    }

    /**
     * Returns `true` if the first argument is less than the second; `false` otherwise.
     *
     * @phlnSignature Ord a => a -> a -> Boolean
     * @phlnCategory relation
     * @param mixed $left
     * @param mixed $right
     * @return \Closure|bool
     * @example
     *      P::lt(1, 2); // true
     *      P::lt(3, 2); // false
     *      P::lt(2, 2); // false
     */
    public static function lt($left = NULL, $right = NULL)
    {
        return \phln\relation\lt(...func_get_args());
    }

    /**
     * Returns `true` if the first argument is less than or equal to the second; `false` otherwise.
     *
     * @phlnSignature Ord a => a -> a -> Boolean
     * @phlnCategory relation
     * @param mixed $left
     * @param mixed $right
     * @return \Closure|mixed
     * @example
     *      P::lte(1, 2); // true
     */
    public static function lte($left = NULL, $right = NULL)
    {
        return \phln\relation\lte(...func_get_args());
    }

    /**
     * Returns the larger of its two arguments.
     *
     * @phlnSignature a -> a -> a
     * @phlnCategory relation
     * @param mixed $left
     * @param mixed $right
     * @return \Closure|mixed
     */
    public static function max($left = NULL, $right = NULL)
    {
        return \phln\relation\max(...func_get_args());
    }

    /**
     * Returns the smaller of its two arguments.
     *
     * @phlnSignature a -> a -> a
     * @phlnCategory relation
     * @param mixed $left
     * @param mixed $right
     * @return \Closure|mixed
     * @example
     *      P::min(1, -1); // -1
     */
    public static function min($left = NULL, $right = NULL)
    {
        return \phln\relation\min(...func_get_args());
    }

    /**
     * Determines whether a nested path on an object has a specific value, in `equals()` terms.
     *
     * @phlnSignature String -> a -> {a} -> Boolean
     * @phlnCategory relation
     * @param string $path
     * @param mixed $value
     * @param array $object
     * @return \Closure|bool
     * @example
     *      P::pathEq('foo.bar', 1, ['foo' => ['bar' => 1]]); // true
     */
    public static function pathEq(string $path = '', $value = NULL, array $object = [])
    {
        return \phln\relation\pathEq(...func_get_args());
    }

    /**
     * Returns `true` if the specified object property is equal, in `equals()` terms, to the given value; `false` otherwise.
     *
     * @phlnSignature k -> a -> {k: a} -> Boolean
     * @phlnCategory relation
     * @param string $prop
     * @param mixed $value
     * @param mixed $object
     * @return \Closure|mixed
     * @example
     *      P::propEq('name', 'Jon', ['name' => 'Jon']); // true
     */
    public static function propEq(string $prop = '', $value = NULL, $object = NULL)
    {
        return \phln\relation\propEq(...func_get_args());
    }

    /**
     * Tests a regular expression against a String. Returns found string, or `NULL`. When regular expression has 'global' modifier function will return array of found strings.
     *
     * @phlnSignature RegExp -> String -> String|Null
     * @phlnSignature RegExp -> String -> [String]
     * @phlnCategory string
     * @param string|RegExp $regexp
     * @param string $test
     * @return \Closure|array|string
     * @example
     *      P::match('/([a-z](o))/i', 'Lorem ipsum dolor'); // 'Lo'
     *      P::match('/([a-z](o))/ig', 'Lorem ipsum dolor'); // ['Lo', 'do', 'lo']
     */
    public static function match($regexp = NULL, string $test = '')
    {
        return \phln\string\match(...func_get_args());
    }

    /**
     * Converts given string to RegExp object
     *
     * @phlnSignature String -> RegExp
     * @phlnCategory string
     * @param string $regexp
     * @return RegExp
     * @example
     *      P::regexp('/foo/ig'); // => new \phln\RegExp('/foo/', 'ig');
     */
    public static function regexp(string $regexp): \phln\RegExp
    {
        return \phln\string\regexp(...func_get_args());
    }

    /**
     * Replace a regex match in a string with a replacement.
     *
     * When regular expression has 'global' modifier all matching strings will be replaced.
     * Otherwise only first matching string will be replaced.
     *
     * @phlnSignature RegExp -> String -> String -> String
     * @phlnCategory string
     * @param string|RegExp $regexp
     * @param string $replacement
     * @param string $text
     * @return \Closure|string
     * @example
     *      P::replace('/foo/', 'bar', 'foo foo foo'); // 'bar foo foo'
     *      P::replace('/foo/g', 'bar', 'foo foo foo'); // 'bar bar bar'
     */
    public static function replace($regexp = NULL, string $replacement = '', string $text = '')
    {
        return \phln\string\replace(...func_get_args());
    }

    /**
     * Splits a string into an array of strings based on the given regular expression or separator.
     *
     * It's possible to split string
     *
     * @phlnSignature String -> String -> [String]
     * @phlnSignature RegExp -> String -> [String]
     * @phlnCategory string
     * @param string|RegExp $delimiter
     * @param string $text
     * @return \Closure|array
     * @example
     *      P::split('/', 'a/b'); // ['a', 'b']
     */
    public static function split($delimiter = NULL, string $text = '')
    {
        return \phln\string\split(...func_get_args());
    }

    /**
     * Determines whether a given string matches a given regular expression.
     *
     * @phlnSignature RegExp -> String -> Bool
     * @phlnSignature String -> String -> Bool
     * @phlnCategory string
     * @param string|RegExp $regexp
     * @param string $string
     * @return \Closure|bool
     * @example
     *      P::test('/foo/', 'foobar'); // true
     */
    public static function test($regexp = NULL, string $string = NULL)
    {
        return \phln\string\test(...func_get_args());
    }

    /**
     * See if `value` is of given `type`.
     *
     * Internally this function uses `\gettype()` with few support of few aliases:
     * * `bool` - alias for `boolean` type
     * * `float` - alias for `double` type
     * * `callable` - checks if $value is valid callback
     * * `function` - same as `callable`
     * * class FQN - will check if supplied object is instance of given class
     *
     * @phlnSignature String -> a -> Boolean
     * @phlnCategory type
     * @param string $type
     * @param mixed $value
     * @return \Closure|bool
     * @example
     *      P::is('bool', true); // true
     *      P::is(\stdClass::class, new \stdClass); // true
     *      P::is(float, 1.1); // true
     */
    public static function is(string $type = '', $value = NULL)
    {
        return \phln\type\is(...func_get_args());
    }

    /**
     * Returns a function, `fn`, which encapsulates `if/else`, `if/else`, ... logic. `P::typeCond` takes a list of [`type`, `transformer`] pairs. Type is converted to `predicate` matching type of variable (in terms of `P::is()`). All of the arguments to `fn` are applied to each of the `predicates` in turn until one returns a truth-y value, at which point `fn` returns the result of applying its arguments to the corresponding `transformer`. If none of the `predicates` matches, `fn` returns null.
     *
     * @phlnSignature [[String, (*... -> *)]] -> (*... -> *)
     * @phlnCategory type
     * @phlnSee P::cond
     * @param array $pairs
     * @return \Closure
     * @example
     *      $count = P::typeCond([
     *          ['string', '\\mb_strlen'],
     *          ['array', '\\count'],
     *          [P::T, P::always(0)],
     *      ]);
     *      $count('foo'); // 3
     *      $count(['f', 'o', 'o']); // 3
     *      $count(new stdClass); // 0
     */
    public static function typeCond(array $pairs): \Closure
    {
        return \phln\type\typeCond(...func_get_args());
    }