<?php

/**
 * Функциональное программирование в PHP
 * package functional
 */

/**
 * Эмуляция каррированой функции
 */
class __right {
    protected $params; 
    protected $fn;
    
    public function __construct($params) {
        $this->fn = array_shift($params);
        $this->params = $params;
    }
    
    function apply() {
        $params = func_get_args();
        array_splice($params, count($params), 0, $this->params);
        return call_user_func_array($this->fn, $params);
    }    
}

class __left {
    protected $params; 
    protected $fn;
    
    public function __construct($params) {
        $this->fn = array_shift($params);
        $this->params = $params;
    }

    function apply() {
        $params = func_get_args();
        array_splice ($params, 0, 0, $this->params);
        return call_user_func_array ($this->fn, $params);
    }
}

define('__', '_ARGUMENT_PLACE_');
class __partial {
    protected $params; 
    protected $fn;
    
    public function __construct($params) {
        $this->fn = array_shift($params);
        $this->params = $params;
    }

    function apply() {
        $params = func_get_args();
        $result = array();
        for($i = 0, $j = 0; $i < count($this->params); $i++) {
            if ($this->params[$i] == __) {
                $result [] = $params[$j];
                $j++;
            } else {
                $result [] = $this->params[$i];
            }
        }
        return call_user_func_array ($this->fn, $result);
    }
} 

function partial() {
    $closure = new __partial(func_get_args());
    return array($closure, 'apply');
}


/**
 * Композиция функций
 */
class __compose {
    protected $fns;
    function __construct($list) {
        $this->fns = array_reverse($list);
    }

    function apply () {
        $params = func_get_args ();
        $result = call_user_func_array($this->fns[0], $params);
        for ($i = 1; $i < count($this->fns); $i++) {
            $result = call_user_func($this->fns[$i], $result);
        }
        return $result;
    }
}

/**
 * Композиция функций
 * @param mixed $a   
 * @param mixed $b   
 *
 * @return array[int]mixed 
 */
function compose() {
    $closure = new __compose(func_get_args());
    return array($closure, 'apply');
}

/**
 * Карирование справа
 *
 * @return array[int]mixed 
 */
function rcurry() {
    $closure = new __right(func_get_args ());
    return array($closure, 'apply');
}

/**
 * Карирование слева
 *
 * @return array[int]mixed 
 */
function lcurry() {
    $closure = new __left(func_get_args ());
    return array($closure, 'apply');
}

/**
 * Разделение массива на два по условию
 * @param mixed $pred Условие по которому разделяется массив
 * @param array $lst 
 *
 * @return array[int]mixed 
 */
function partition($pred, $lst) {
    $left = array ();
    $right = array ();
    foreach ($lst as $n) {
        if (call_user_func($pred, $n) !== false) {
            $left [] = $n;
        } else {
            $right [] = $n;
        }
    }
    return array ($left, $right);
}

/**
 * @param array $value
 * @param string $name 
 *
 * @return mixed
 */
function __key($value, $name) {
    return $value[$name];
}

function identity($value) {
    return $value;
}

/**
 * @param array $a
 * @param array $b
 * @param $key
 *
 * @return int 
 */
function __cmp($a, $b, $key) {
    if ($a[$key] == $b[$key]) {
        return 0;
    }
    return ($a[$key] > $b[$key]) ? -1 : 1;
}

function __cmp_less($a, $b, $key) {
    if ($a[$key] == $b[$key]) {
        return 0;
    }
    return ($a[$key] < $b[$key]) ? -1 : 1;
}

// Сравнение по ключу массиве
function __index($n, $key, $row) {
    return ($row[$key] == $n);
}

function __div($x, $y) {
    return $x / $y;
}

function __self($name, $o) {
    return call_user_func(array($o, $name));
}

function concat(/* $args ...*/) {
    $args = func_get_args();
    return implode($args);
}

function __empty($x) {
    return empty($x);
}

// Отрицание
function __not($x) {
    return !$x;
}

// Не равно
function __neq($x, $y) {
    return $x != $y;
}

// Равно
function __eq($x, $y) {
    return $x == $y;
}

/**
 * Извлекает из многомерого массива значения с определенным ключом
 * @example key_values('a', array(1 => array('a' => 1, 'b' => 2))) => array(1)
 *
 * @return mixed
 */
function key_values($key, /*array|ArrayIterator*/ $array) {
    $result = array();
    
    foreach($array as $item) {
        $result[] = $item[$key];
    }
    return $result;
}

function assoc_key_values($key, $value, $array) {
    $result = array();
    foreach ($array as $item) {
        $result[$item[$key]] = $item[$value];
    }
    return $result;
}

function assoc_key($key, $array) {
    $result = array();
    foreach ($array as $item) {
        $result[$item[$key]] = $item;
    }
    return $result;
}

function _get($key, $value, $array) {
    foreach ($array as $item) {
        if ($item[$key] == $value) return $item;
    }
    return null;        
}

function _get_key($key, $value, $array) {
    foreach ($array as $name => $item) {
        if ($item[$key] == $value) return $name;
    }
    return null;        
}


/**
 * Логическа операция && ко всем элементам массива
 * @return bool
 */
function every(array $array, $callback) {
    foreach ($array as $key => $value) {
        if (call_user_func($callback, $value) === false) {
            return false;
        }
    }
    return true;
}

/**
 * Логическа операция || ко всем элементам массива
 * @param array $array   
 * @param mixed $callback   
 *
 * @return mixed
 */
function some(array $array, $callback) {
    assert(is_callable($callback));

    foreach ($array as $key => $value) {
        if (call_user_func($callback, $value) === true) {
            return $key;
        }
    }
    return false;
}

function span($length, array $array) {
    assert(is_int($length));

    $result = array();
    for($i = 0; $i < count($array); $i += $length) {
        $result [] = array_slice($array, $i, $length);
    }
    return $result;
}

function array_ref($data, $n) {
    return $data[$n];
}

function call() {
    $args = func_get_args();        
    $name = array_shift($args);
    return call_user_func_array($name, $args);
}

/**
 * Поиск элемента в массиве
 * @param function $cb сравнение с  элементом массива
 * @param array $hs массив в котором ищется значение
 *
 * @return int|string ключ найденого элемента в массиве
 */
function array_usearch($cb, array $hs, $strict = false) {
    foreach($hs as $key => $value) if (call_user_func_array($cb, array($value, $key, $strict))) return $key;
}

if (!function_exists('hash_key')) {
    /**
     * Преобразует ключи элементов для многомерного массива 
     * @return mixed
     */
    function hash_key ($key_name,/*. array .*/ $array) {
        $result = array();

        foreach($array as $value) {
            $result[$value[$key_name]] = $value;        
        }
        return $result; 
    };
}

function array_merge1($x, $y) {
    $result = $x;
    foreach ($y as $k => $v) {
        $result [$k] = $v;            
    }
    return $result;
}