list.php ➔ allSatisfies() - Code Metrics - Inspection of "adding fns and tests" - tarsana/functional - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( f80c85...97f147 )

by Amine
created 2016-11-15 22:54 UTC
list.php ➔ allSatisfies() A

↳ Parent: Project
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	4
nc	1
nop	0
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0
<?php namespace Tarsana\Functional;
/**
 * This file contains some useful functions to handle lists (arrays having only numeric keys).
 */

/**
 * Curried version of `array_map`.
 * ```php
 * $doubles = map(function($x) { return 2 * $x; });
 * $doubles([1, 2, 3, 4]) // [2, 4, 6, 8]
 * ```
 *
 * @signature (a -> b) -> [a] -> [b]
 * @param  callable $fn
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function map() {
    $map = function($fn, $list) {
        return array_map($fn, $list);
    };
    return apply(curry($map), func_get_args());
}

/**
 * Applies a function to items of the array and concatenates the results.
 * This is also known as `flatMap` in some libraries.
 * ```php
 * $words = chain(split(' '));
 * $words(['Hello World', 'How are you']) // ['Hello', 'World', 'How', 'are', 'you']
 * ```
 *
 * @signature (a -> [b]) -> [a] -> [b]
 * @param  callable $fn
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function chain() {
    $chain = function($fn, $list) {
        return concatAll(map($fn, $list));
    };
    return apply(curry($chain), func_get_args());
}

/**
 * Curried version of `array_filter` with modified order of
 * arguments. The callback is the first argument then the list.
 * ```php
 * $list = [1, 'aa', 3, [4, 5]];
 * $numeric = F\filter('is_numeric');
 * $numeric($list) // [1, 3]
 * ```
 * @signature (a -> Boolean) -> [a] -> [a]
 * @param  callable $fn
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function filter() {
    $filter = function($fn, $list){
        return array_values(array_filter($list, $fn));
    };
    return apply(curry($filter), func_get_args());
}

/**
 * Curried version of `array_reduce` with modified order of
 * arguments ($callback, $initial, $list).
 * ```php
 * $list = [1, 2, 3, 4];
 * $sum = reduce('Tarsana\Functional\plus', 0);
 * $sum($list) // 10
 * ```
 *
 * @signature (* -> a -> *) -> * -> [a] -> *
 * @param  callable $fn
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  mixed $initial
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function reduce() {
    $reduce = function($fn, $initial, $list){
        return array_reduce($list, $fn, $initial);
    };
    return apply(curry($reduce), func_get_args());
}

/**
 * Applies the callback to each item and returns the original list.
 * ```php
 * $list = [1, 2, 3, 4];
 * each(function($item){
 *     echo $item, PHP_EOL;
 * }, $list);
 * // Outputs:
 * // 1
 * // 2
 * // 3
 * // 4
 * ```
 *
 * @signature (a -> *) -> [a] -> [a]
 * @param  callable $fn
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function each() {
    $each = function($fn, $list){
        foreach ($list as $item) {
            apply($fn, [$item]);
        }
        return $list;
    };
    return apply(curry($each), func_get_args());
}

/**
 * Returns the first item of the given array or string.
 * ```php
 * head([1, 2, 3, 4]) // 1
 * head('Hello') // 'H'
 * head([]) // null
 * head('') // ''
 * ```
 *
 * @signature [a] -> a
 * @signature String -> String
 * @param  array|string $list
 * @return mixed
 */
function head($list) {

    if(is_string($list))
        return substr($list, 0, 1);
    return (count($list) > 0)
        ? $list[0]
        : null;
}

/**
 * Returns the last item of the given array or string.
 * ```php
 * last([1, 2, 3, 4]) // 4
 * last('Hello') // 'o'
 * last([]) // null
 * last('') // ''
 * ```
 *
 * @signature [a] -> a
 * @signature String -> String
 * @param  array|string $list
 * @return mixed
 */
function last($list) {

    if(is_string($list))
        return substr($list, -1);
    return (count($list) > 0)
        ? $list[count($list) - 1]
        : null;
}

/**
 * Returns all but the last element of the given array or string.
 * ```php
 * init([1, 2, 3, 4]) // [1, 2, 3]
 * init('Hello') // 'Hell'
 * init([7]) // []
 * init([]) // []
 * init('') // ''
 * ```
 *
 * @signature [a] -> a
 * @signature String -> String
 * @param  array|string $list
 * @return array
 */
function init($list) {
    if(is_string($list))

        return (strlen($list) > 1)
            ? substr($list, 0, strlen($list) - 1)
            : '';
    return (count($list) > 1)
        ? array_slice($list, 0, count($list) - 1)
        : [];
}

/**
 * Returns all but the first element of the given array or string.
 * ```php
 * tail([1, 2, 3, 4]) // [2, 3, 4]
 * tail('Hello') // 'ello'
 * tail([7]) // []
 * tail([]) // []
 * tail('') // ''
 * ```
 *
 * @signature [a] -> a
 * @signature String -> String
 * @param  array|string $list
 * @return array
 */
function tail($list) {
    if(is_string($list))

        return (strlen($list) > 1)
            ? substr($list, 1)
            : '';
    return (count($list) > 1)
        ? array_slice($list, 1)
        : [];
}

/**
 * Alias of `array_reverse()` and `strrev()`.
 * ```php
 * reverse([1, 2, 3, 4]) // [4, 3, 2, 1]
 * reverse('Hello') // 'olleH'
 * ```
 *
 * @signature [a] -> [a]
 * @signature String -> String
 * @param  array|string $list
 * @return array
 */
function reverse($list) {
    return is_string($list)
        ? strrev($list)
        : array_reverse($list);
}

/**
 * Alias for `count()` and `strlen()`.
 * ```php
 * length([1, 2, 3, 4]) // 4
 * length('Hello') // 5
 * ```
 *
 * @signature [a] -> Number
 * @signature String -> Number
 * @param  array|string $list
 * @return int
 */
function length($list) {
    return is_string($list)
        ? strlen($list)
        : count($list);
}

/**
 * Checks if the `$predicate` is verified by **all** items of the array.
 * ```php
 * $allNotNull = allSatisfies(pipe(eq(0), not()));
 * $allNotNull([9, 3, 2, 4]); // true
 * $allNotNull([9, 3, 0, 4]); // false
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> Boolean
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return bool
 */
function allSatisfies() {
    $allSatisfies = function($predicate, $list) {
        return length(filter($predicate, $list)) == length($list);
    };
    return apply(curry($allSatisfies), func_get_args());
}


/**
 * Checks if the `$predicate` is verified by **any** item of the array.
 * ```php
 * $anyNumeric = anySatisfies('is_numeric');
 * $anyNumeric(['Hello', '12', []]); // true
 * $anyNumeric(['Hello', 'Foo']); // false
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> Boolean
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return bool
 */
function anySatisfies() {
    $anySatisfies = function($predicate, $list) {
        return null != findIndex($predicate, $list);
    };
    return apply(curry($anySatisfies), func_get_args());
}

/**
 * Concatenates two arrays or strings.
 * ```php
 * concat([1, 2], [3, 4]) // [1, 2, 3, 4]
 * concat('Hello ', 'World') // 'Hello World'
 * ```
 *
 * @signature [*] -> [*] -> [*]
 * @signature String -> String -> String
 * @param  array $list1
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list2
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function concat() {
    $concat = function($list1, $list2) {
        $t1 = toString($list1);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $t2 = toString($list2);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        // echo "Concating {$t1} and {$t2}", PHP_EOL;

        if (is_string($list1) && is_string($list2))
            return $list1 . $list2;
        return array_merge($list1, $list2);
    };
    return apply(curry($concat), func_get_args());
}

/**
 * Concatenates a list of arrays or strings.
 * ```php
 * concatAll([[1, 2], [3, 4], [5, 6]]) // [1, 2, 3, 4, 5, 6]
 * concatAll('Hello ', 'World', ' !') // 'Hello World !'
 * ```
 *
 * @signature [[a]] -> [a]
 * @param  array $lists
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function concatAll() {
    $concatAll = function($lists) {
        return length($lists) == 0 ? [] :
            reduce(concat(), head($lists), tail($lists));
    };
    return apply(curry($concatAll), func_get_args());
}

/**
 * Inserts an item at some position into an array or a substring into a string. If `$position < 0`
 * the item or substring is inserted before the last `|$position|` elements/characters.
 * ```php
 * insert(2, 'x', [1, 2, 3, 4]); // [1, 2, 'x', 3, 4]
 * insert(-1,  'x', [1, 2, 3, 4]); // [1, 2, 3, 'x', 4]
 * insert(11, 'x', [1, 2, 3, 4]); // [1, 2, 3, 4, 'x']
 * insert(0, 'x', [1, 2, 3, 4]); // ['x', 1, 2, 3, 4]
 * insert(-11, 'x', [1, 2, 3, 4]); // ['x', 1, 2, 3, 4]
 * insert(3, 'l', 'Helo World'); // 'Hello World'
 * ```
 *
 * @signature Number -> a -> [a] -> [a]
 * @signature Number -> String -> String -> String
 * @param  int $position
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  mixed $item
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function insert() {
    $insert = function($position, $item, $list) {
        return (is_string($list))
            ? insertAll($position, $item, $list)
            : insertAll($position, [$item], $list);
    };
    return apply(curry($insert), func_get_args());
}

/**
 * Same as `insert` but inserts an array instead of a single item.
 * ```php
 * insertAll(2, ['x', 'y'], [1, 2, 3, 4]); // [1, 2, 'x', 'y', 3, 4]
 * insertAll(-1,  ['x', 'y'], [1, 2, 3, 4]); // [1, 2, 3, 'x', 'y', 4]
 * insertAll(11, ['x', 'y'], [1, 2, 3, 4]); // [1, 2, 3, 4, 'x', 'y']
 * insertAll(0, ['x', 'y'], [1, 2, 3, 4]); // ['x', 'y', 1, 2, 3, 4]
 * insertAll(-11, ['x', 'y'], [1, 2, 3, 4]); // ['x', 'y', 1, 2, 3, 4]
 * insertAll(2, 'llo', 'He World'); // 'Hello World'
 * ```
 *
 * @signature Number -> [a] -> [a] -> [a]
 * @signature Number -> String -> String -> String
 * @param  int $position
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  mixed $items
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function insertAll() {
    $insertAll = function($position, $items, $list) {
        $length = length($list);
        if ($position < 0)
            $position = $length + $position;
        if ($position < 0)
            $position = 0;
        return ($position >= $length)
            ? concat($list, $items)
            : concatAll([take($position, $list), $items, remove($position, $list)]);
    };
    return apply(curry($insertAll), func_get_args());
}

/**
 * Appends an item to an array or a substring to a string.
 * ```php
 * append(5, [1, 2, 3]) // [1, 2, 3, 5]
 * append(' World', 'Hello') // 'Hello World'
 * ```
 *
 * @signature * -> [*] -> [*]
 * @signature String -> String -> String
 * @param  mixed $item
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function append() {
    $append = function ($item, $list) {
        return insert(length($list), $item, $list);
    };
    return apply(curry($append), func_get_args());
}

/**
 * Inserts an item at the begining of an array or a substring at the begining of a string.
 * Note that this function is equivalent to `insert(0)`.
 * ```php
 * prepend(5, [1, 2, 3]) // [5, 1, 2, 3]
 * prepend('Hello ', 'World') // 'Hello World'
 * ```
 *
 * @signature a -> [a] -> [a]
 * @signature String -> String -> String
 * @param  mixed $item
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function prepend() {
    return apply(insert(0), func_get_args());
}

/**
 * Takes a number of elements from an array. If `$count` is
 * negative, the elements are taken from the end of the array.
 * ```php
 * $items = ['Foo', 'Bar', 'Baz'];
 * take(2, $items) // ['Foo', 'Bar']
 * take(0, $items) // []
 * take(-2, $items) // ['Bar', 'Baz']
 * take(5, 'Hello World') // 'Hello'
 * take(-5, 'Hello World') // 'World'
 * ```
 *
 * @signature Number -> [a] -> [a]
 * @signature Number -> String -> String
 * @param  int $count
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function take() {
    $take = function($count, $list) {
        $length = length($list);
        if ($count > $length || $count < -$length)
            return [];
        if(is_string($list)) {
            return ($count >= 0)
                ? substr($list, 0, $count)
                : substr($list, $count);
        }
        return ($count >= 0)
            ? array_slice($list, 0, $count)
            : array_slice($list, $count);
    };
    return apply(curry($take), func_get_args());
}

/**
 * Takes elements from an array while they match the given predicate. It stops at the
 * first element not matching the predicate and does not include it in the result.
 * ```php
 * $items = ['Foo', 'Fun', 'Dev', 'Bar', 'Baz'];
 * takeWhile(startsWith('F'), $items) // ['Foo', 'Fun']
 * takeWhile(startsWith('D'), $items) // []
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> [a]
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function takeWhile() {

    $takeWhile = function($predicate, $list) {
        $first = head($list);
        return (null == $first || !$predicate($first))
            ? []
            : prepend($first, takeWhile($predicate, tail($list)));

    };
    return apply(curry($takeWhile), func_get_args());
}

/**
 * Same as `takeWhile` but taking elements from the end of the array.
 * ```php
 * $items = ['Foo', 'Fun', 'Dev', 'Bar', 'Baz'];
 * takeLastWhile(startsWith('B'), $items) // ['Bar', 'Baz']
 * takeLastWhile(startsWith('D'), $items) // []
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> [a]
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function takeLastWhile() {

    $takeLastWhile = function($predicate, $list) {
        $last = last($list);
        return (null == $last || !$predicate($last))
            ? []
            : append($last, takeLastWhile($predicate, init($list)));

    };
    return apply(curry($takeLastWhile), func_get_args());
}

/**
 * Takes elements from an array **until** the predicate
 * is satisfied, not including the satisfying element.
 * ```php
 * $items = ['Foo', 'Fun', 'Dev', 'Bar', 'Baz'];
 * takeUntil(startsWith('B'), $items) // ['Foo', 'Fun', 'Dev']
 * takeUntil(startsWith('F'), $items) // []
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> [a]
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function takeUntil() {
    $takeUntil = function($predicate, $list) {
        return takeWhile(pipe($predicate, not()), $list);
    };
    return apply(curry($takeUntil), func_get_args());
}

/**
 * Same as `takeUntil` but takes elements from the end of the array.
 * ```php
 * $items = ['Foo', 'Fun', 'Dev', 'Bar', 'Baz'];
 * takeLastUntil(startsWith('F'), $items) // ['Dev', 'Bar', 'Baz']
 * takeLastUntil(startsWith('B'), $items) // []
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> [a]
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function takeLastUntil() {
    $takeLastUntil = function($predicate, $list) {
        return takeLastWhile(pipe($predicate, not()), $list);
    };
    return apply(curry($takeLastUntil), func_get_args());
}

/**
 * Removes a number of elements from an array.
 * If `$count` is negative, the elements are
 * removed from the end of the array.
 * ```php
 * $items = ['Foo', 'Bar', 'Baz'];
 * remove(2, $items) // ['Baz']
 * remove(-1, $items) // ['Foo', 'Bar']
 * remove(5, $items) // []
 * remove(6, 'Hello World') // 'World'
 * remove(-6, 'Hello World') // 'Hello'
 * ```
 *
 * @signature Number -> [a] -> [a]
 * @signature Number -> String -> String
 * @param  int $count
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function remove() {
    $remove = function($count, $list) {
        $length = length($list);
        if ($count > $length || $count < -$length)
            return [];
        return ($count > 0)
            ? take($count - $length, $list)
            : take($count + $length, $list);
    };
    return apply(curry($remove), func_get_args());
}

/**
 * Removes elements from an array while they match the given predicate. It stops at the
 * first element not matching the predicate and does not remove it.
 * ```php
 * $items = ['Foo', 'Fun', 'Dev', 'Bar', 'Baz'];
 * removeWhile(startsWith('F'), $items) // ['Dev', 'Bar', 'Baz']
 * removeWhile(startsWith('D'), $items) // ['Foo', 'Fun', 'Dev', 'Bar', 'Baz']
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> [a]
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function removeWhile() {
    $removeWhile = function($predicate, $list) {
        return remove(length(takeWhile($predicate, $list)), $list);
    };
    return apply(curry($removeWhile), func_get_args());
}

/**
 * Same as `removeWhile` but removes elements from the end of the array.
 * ```php
 * $items = ['Foo', 'Fun', 'Bye', 'Dev', 'Bar', 'Baz'];
 * removeLastWhile(startsWith('F'), $items) // ['Foo', 'Fun', 'Bye', 'Dev', 'Bar', 'Baz']
 * removeLastWhile(startsWith('B'), $items) // ['Foo', 'Fun', 'Bye', 'Dev']
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> [a]
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function removeLastWhile() {
    $removeLastWhile = function($predicate, $list) {
        return remove(- length(takeLastWhile($predicate, $list)), $list);
    };
    return apply(curry($removeLastWhile), func_get_args());
}

/**
 * Removes elements from an array **until** the predicate
 * is satisfied, not removing the satisfying element.
 * ```php
 * $items = ['Foo', 'Fun', 'Dev', 'Bar', 'Baz'];
 * removeUntil(startsWith('B'), $items) // ['Bar', 'Baz']
 * removeUntil(startsWith('F'), $items) // ['Foo', 'Fun', 'Dev', 'Bar', 'Baz']
 * removeUntil(startsWith('A'), $items) // []
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> [a]
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function removeUntil() {
    $removeUntil = function($predicate, $list) {
        return remove(length(takeUntil($predicate, $list)), $list);
    };
    return apply(curry($removeUntil), func_get_args());
}

/**
 * Same as `removeUntil` but removes elements from the end of the array.
 * ```php
 * $items = ['Foo', 'Fun', 'Dev', 'Bar', 'Baz'];
 * removeLastUntil(startsWith('B'), $items) // ['Foo', 'Fun', 'Dev', 'Bar', 'Baz']
 * removeLastUntil(startsWith('F'), $items) // ['Foo', 'Fun']
 * removeLastUntil(startsWith('A'), $items) // []
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> [a]
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function removeLastUntil() {
    $removeLastUntil = function($predicate, $list) {
        return remove(- length(takeLastUntil($predicate, $list)), $list);
    };
    return apply(curry($removeLastUntil), func_get_args());
}

/**
 * Converts an array of (key, value) pairs to an object (instance of `stdClass`).
 * ```php
 * fromPairs([['name', 'Foo'], ['age', 11]]); // (object) ['name' => 'Foo', 'age' => 11]
 * ```
 *
 * @signature [(k, v)] -> {k: v}
 * @param  array $pairs
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return stdClass
 */
function fromPairs() {
    $fromPairs = function($pairs) {
        return reduce(function($result, $pair) {
            $result->{$pair[0]} = $pair[1];
            return $result;
        }, new \stdClass, $pairs);
    };
    return apply(curry($fromPairs), func_get_args());
}

/**
 * Gets an array of slices of size `$size` from an array.
 * ```php
 * $pairs = slices(2);
 * $pairs([1, 2, 3, 4, 5]); // [[1, 2], [3, 4], [5]]
 * $pairs("Hello World"); // ['He', 'll', 'o ', 'Wo', 'rl', 'd']
 * slices(5, [1, 2]); // [[1, 2]]
 * slices(3, []) // []
 * slices(3, '') // ''
 * ```
 *
 * @signature Number -> [a] -> [[a]]
 * @signature Number -> String -> [String]
 * @param  int $size
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function slices() {
    $slices = function($size, $list) {
        if(empty($list))
            return is_string($list) ? '' : [];
        if(length($list) <= $size)
            return [$list];
        return prepend(take($size, $list), slices($size, remove($size, $list)));
    };
    return apply(curry($slices), func_get_args());
}

/**
 * Checks if an array contains an item.
 * ```php
 * contains('foo', ['foo', 'bar', 'baz']) // true
 * contains('hi', ['foo', 'bar', 'baz']) // false
 * contains('hi', 'Hello World') // false
 * contains('He', 'Hello World') // true
 * ```
 *
 * @signature a -> [a] -> Boolean
 * @signature String -> String -> Boolean
 * @param  mixed $item
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array|string $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return bool
 */
function contains() {
    $contains = function($item, $list) {
        return -1 != indexOf($item, $list);
    };
    return apply(curry($contains), func_get_args());
}

/**
 * Returns the position/key of the first item satisfying the
 * predicate in the array or null if no such element is found.
 * ```php
 * findIndex(startsWith('b'), ['foo', 'bar', 'baz']); // 1
 * findIndex(startsWith('b'), ['a' => 'foo', 'b' => 'bar', 'c' => 'baz']); // 'b'
 * findIndex(startsWith('c'), ['foo', 'bar', 'baz']); // null
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> Maybe(Number)
 * @signature (v -> Boolean) -> {k: v} -> Maybe(k)
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return mixed
 */
function findIndex() {
    $findIndex = function($predicate, $list) {
        foreach ($list as $key => $value) {
            if ($predicate($value))
                return $key;
        }
        return null;
    };
    return apply(curry($findIndex), func_get_args());
}

/**
 * Returns the position/key of the last item satisfying the
 * predicate in the array or null if no such element is found.
 * ```php
 * findLastIndex(startsWith('b'), ['foo', 'bar', 'baz']); // 2
 * findLastIndex(startsWith('b'), ['a' => 'foo', 'b' => 'bar', 'c' => 'baz']); // 'c'
 * findLastIndex(startsWith('c'), ['foo', 'bar', 'baz']); // null
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> Maybe(Number)
 * @signature (v -> Boolean) -> {k: v} -> Maybe(k)
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return mixed
 */
function findLastIndex() {
    $findLastIndex = function($predicate, $list) {
        foreach (reverse(toPairs($list)) as $pair) {
            if($predicate($pair[1]))
                return $pair[0];
        }
        return null;
    };
    return apply(curry($findLastIndex), func_get_args());
}

/**
 * Returns the first item satisfying the predicate in
 * the array or null if no such element is found.
 * ```php
 * find(startsWith('b'), ['foo', 'bar', 'baz']); // 'bar'
 * find(startsWith('c'), ['foo', 'bar', 'baz']); // null
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> Maybe(a)
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return mixed
 */
function find() {
    $find = function($predicate, $list) {
        return get(findIndex($predicate, $list), $list);
    };
    return apply(curry($find), func_get_args());
}

/**
 * Returns the last item satisfying the predicate in
 * the array or null if no such element is found.
 * ```php
 * findLast(startsWith('b'), ['foo', 'bar', 'baz']); // 'baz'
 * findLast(startsWith('c'), ['foo', 'bar', 'baz']); // null
 * ```
 *
 * @signature (a -> Boolean) -> [a] -> Maybe(a)
 * @param  callable $predicate
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return mixed
 */
function findLast() {
    $findLast = function($predicate, $list) {
        return get(findLastIndex($predicate, $list), $list);
    };
    return apply(curry($findLast), func_get_args());
}

/**
 * If `$list` is an array, it returns the **key** of the first **item** which is equal to `$item`.
 * If `$list` is a string, it returns the **position** of the first **substring** which is equal to `$item`.
 * If `$list` is an object, it returns the **name** of the first **attribute** which is equal to `$item`.
 * If the searched item, substring or attribute is not found; `null` is returned.
 * Note that elements are deeply compared using `Tarsana\Functional\equals`.
 * ```php
 * indexOf(['Hello', 'World'], [1, ['Hello', 'World'], true, ['Hello', 'World']]); // 1
 * indexOf(['Hello'], [1, ['Hello', 'World'], true]); // -1
 * indexOf('World', 'Hello World'); // 6
 * indexOf('World !', 'Hello World'); // -1
 * indexOf('foo', (object) ['name' => 'foo', 'age' => 11]); // 'name'
 * ```
 *
 * @signature a -> [a] -> Number
 * @signature v -> {k: v} -> Maybe(k)
 * @signature String -> String -> Number
 * @param  mixed $item
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return int
 */
function indexOf() {

    $indexOf = function($item, $list) {
        if (is_string($list)) {
            $index = strpos($list, $item);
        } else {
            $index = findIndex(equals($item), $list);
        }
        return (false === $index || null === $index)
            ? -1
            : $index;
    };
    return apply(curry($indexOf), func_get_args());
}

/**
 * Same as `indexOf` but returns the key/position/name of the last item/substring/attribute.
 * ```php
 * lastIndexOf(['Hello', 'World'], [1, ['Hello', 'World'], true, ['Hello', 'World']]); // 3
 * lastIndexOf(['Hello'], [1, ['Hello', 'World'], true]); // -1
 * lastIndexOf('World', 'Hello World'); // 6
 * lastIndexOf('World !', 'Hello World'); // -1
 * lastIndexOf('foo', (object) ['name' => 'foo', 'age' => 11]); // 'name'
 * ```
 *
 * @signature a -> [a] -> Number
 * @signature String -> String -> Number
 * @param  mixed $item
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return int
 */
function lastIndexOf() {

    $lastIndexOf = function($item, $list) {
        if (is_string($list)) {
            $index = strrpos($list, $item);
        } else {
            $index = findLastIndex(equals($item), $list);
        }
        return (false === $index || null === $index)
            ? -1
            : $index;
    };
    return apply(curry($lastIndexOf), func_get_args());
}

/**
 * Removes duplicates from a list by keeping the first occurence of each group
 * of items which are equivalent according to the given `$areEqual` callable.
 * ```php
 * uniqueBy(eq(), [1, '2', '1', 3, '3', 2, 2]); // [1, '2', 3]
 * ```
 *
 * @signature (a -> a -> Boolean) -> [a] -> [a]
 * @param  callable $areEqual
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function uniqueBy() {
    $uniqueBy = function($areEqual, $list) {
        // make sure the compare function is curried
        $compare = function($a) use($areEqual) {
            return function($b) use($areEqual, $a) {
                return $areEqual($a, $b);
            };
        };

        return reduce(function($result, $item) use($compare) {
            return (null === findIndex($compare($item), $result))
                ? append($item, $result)
                : $result;
        }, [], $list);
    };
    return apply(curry($uniqueBy), func_get_args());
}

/**
 * Alias of `uniqueBy(equals())`.
 * ```php
 * unique([1, '1', [1, 2], 1, ['1', 2], [1, 2]]); // [1, '1', [1, 2], ['1', 2]]
 * ```
 *
 * @signature [a] -> [a]
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function unique() {
    return apply(curry(uniqueBy(equals())), func_get_args());
}

/**
 * Converts an array to an associative array, based on the result of calling `$fn`
 * on each element, and grouping the results according to values returned.
 * Note that `$fn` should take an item from the list and return a string.
 * ```php
 * $persons = [
 *     ['name' => 'foo', 'age' => 11],
 *     ['name' => 'bar', 'age' => 9],
 *     ['name' => 'baz', 'age' => 16],
 *     ['name' => 'zeta', 'age' => 33],
 *     ['name' => 'beta', 'age' => 25]
 * ];
 * $phase = function($person) {
 *     $age = $person['age'];
 *     if ($age < 13) return 'child';
 *     if ($age < 19) return 'teenager';
 *     return 'adult';
 * };
 * groupBy($phase, $persons);
 * // [
 * //  'child' => [['name' => 'foo', 'age' => 11], ['name' => 'bar', 'age' => 9]],
 * //  'teenager' => [['name' => 'baz', 'age' => 16]],
 * //  'adult' => [['name' => 'zeta', 'age' => 33], ['name' => 'beta', 'age' => 25]]
 * // ]
 * ```
 *
 * @signature (a -> String) -> [a] -> {String: a}
 * @param  callable $fn
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @param  array $list
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
 * @return array
 */
function groupBy() {
    $groupBy = function($fn, $list) {
        return reduce(function($result, $item) use($fn) {
            $index = $fn($item);
            if (! isset($result[$index]))
                $result[$index] = [];
            $result[$index][] = $item;
            return $result;
        }, [], $list);
    };
    return apply(curry($groupBy), func_get_args());
}

1			<?php namespace Tarsana\Functional;
2			/**
3			* This file contains some useful functions to handle lists (arrays having only numeric keys).
4			*/
5
6			/**
7			* Curried version of `array_map`.
8			* ```php
9			* $doubles = map(function($x) { return 2 * $x; });
10			* $doubles([1, 2, 3, 4]) // [2, 4, 6, 8]
11			* ```
12			*
13			* @signature (a -> b) -> [a] -> [b]
14			* @param callable $fn
			0 ignored issues – show Bug introduced 2016-08-15 21:58 UTC by Report Bug Copy Issue Report There is no parameter named `$fn`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
15			* @param array $list
			0 ignored issues – show Bug introduced 2016-11-13 22:11 UTC by Report Bug Copy Issue Report There is no parameter named `$list`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
16			* @return array
17			*/
18			function map() {
19			$map = function($fn, $list) {
20			return array_map($fn, $list);
21			};
22			return apply(curry($map), func_get_args());
23			}
24
25			/**
26			* Applies a function to items of the array and concatenates the results.
27			* This is also known as `flatMap` in some libraries.
28			* ```php
29			* $words = chain(split(' '));
30			* $words(['Hello World', 'How are you']) // ['Hello', 'World', 'How', 'are', 'you']
31			* ```
32			*
33			* @signature (a -> [b]) -> [a] -> [b]
34			* @param callable $fn
			0 ignored issues – show Bug introduced 2016-08-15 21:58 UTC by Report Bug Copy Issue Report There is no parameter named `$fn`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
35			* @param array $list
			0 ignored issues – show Bug introduced 2016-11-13 22:11 UTC by Report Bug Copy Issue Report There is no parameter named `$list`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
36			* @return array
tarsana / functional

Push — master ( f80c85...97f147 )

list.php ➔ allSatisfies() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
