<?php namespace PHPixme; /** * Take a callable and produce a curried \Closure * @param int $arity * @param callable = $hof * @return \Closure * @sig Integer -> Callable (*-> x) -> \Closure (* -> x) */ function curry($arity = null, callable $hof = null) { return call_user_func_array(__PRIVATE__::$instance[curry], func_get_args()); } const curry = __NAMESPACE__ . '\\curry'; __PRIVATE__::$instance[curry] = __PRIVATE__::curryExactly2(function ($arity, $callable) { __CONTRACT__::argIsAPositiveOrZeroInt($arity); __CONTRACT__::argIsACallable($callable, 1); // The function is static so that is easier to recurse, // as it shares no state with itself outside its arguments. return __PRIVATE__::curryGiven([], $arity, $callable); });
<?php namespace PHPixme; /** * @param callable $hof * @param \Traversable= $traversable * @return \Closure|mixed * @sig Callable (a, b -> a) -> \Traversable[a,b] -> a */ function reduce($hof = null, $traversable = null) { return call_user_func_array(__PRIVATE__::$instance[reduce], func_get_args()); } const reduce = __NAMESPACE__ . '\\reduce'; __PRIVATE__::$instance[reduce] = __PRIVATE__::curryExactly2(function ($hof, $arrayLike) { __CONTRACT__::argIsACallable($hof); __CONTRACT__::argIsATraversable($arrayLike, 1); if ($arrayLike instanceof ReducibleInterface) { return $arrayLike->reduce($hof); } // Equalize the usefulness $array = __CONTRACT__::isNonEmpty(__PRIVATE__::traversableToArray($arrayLike)); $output = current($array); next($array); while (null !== ($key = key($array))) { $output = call_user_func($hof, $output, current($array), $key, $arrayLike); next($array); } return $output; });
<?php namespace PHPixme; /** * ufo, short for the space ship operator, or the three way comparison, a stand in for <=> * @sig ($lhs)->($rhs)-> boolean $z * @param mixed $lhs * @param mixed $rhs * @return int|\Closure */ function ufo($lhs = null, $rhs = null) { return call_user_func_array(__PRIVATE__::$instance[ufo], func_get_args()); } const ufo = __NAMESPACE__ . '\\ufo'; __PRIVATE__::$instance[ufo] = __PRIVATE__::curryExactly2(function ($lhs, $rhs) { return $lhs != $rhs ? $lhs > $rhs ? 1 : -1 : 0; });
<?php namespace PHPixme; /** * @param Callable $decorator * @param Callable $fn * @return \Closure */ function except($decorator = null, $fn = null) { return call_user_func_array(__PRIVATE__::$instance[except], func_get_args()); } const except = __NAMESPACE__ . '\\except'; __PRIVATE__::$instance[except] = __PRIVATE__::curryExactly2(function ($predicate, $fn) { __CONTRACT__::argIsACallable($predicate); __CONTRACT__::argIsACallable($fn, 1); return function () use($predicate, $fn) { $args = func_get_args(); return call_user_func_array($predicate, $args) ? null : call_user_func_array($fn, $args); }; });
<?php namespace PHPixme; /** * xorL, short for logical xor, a stand in for xor keyword * @sig ($lhs)->($rhs)-> boolean $z * @param mixed $lhs * @param mixed $rhs * @return boolean|\Closure */ function xorL($lhs = null, $rhs = null) { return call_user_func_array(__PRIVATE__::$instance[xorL], func_get_args()); } const xorL = __NAMESPACE__ . '\\xorL'; __PRIVATE__::$instance[xorL] = __PRIVATE__::curryExactly2(function ($lhs, $rhs) { return $lhs xor $rhs; });
<?php namespace PHPixme; /** * map * @param callable $hof * @param array|FunctorInterface|\Traversable $collection * @return \Closure|$collection */ function walk($hof = null, $collection = null) { return call_user_func_array(__PRIVATE__::$instance[walk], func_get_args()); } const walk = __NAMESPACE__ . '\\walk'; __PRIVATE__::$instance[walk] = __PRIVATE__::curryExactly2(function ($hof, $collection) { __CONTRACT__::argIsACallable($hof); __CONTRACT__::argIsATraversable($collection, 1); if ($collection instanceof FunctorInterface) { return $collection->walk($hof); } $array = __PRIVATE__::getArrayFrom($collection); if ($array !== null) { array_walk($array, $hof, $collection); } else { foreach (__PRIVATE__::copyTransversable($collection) as $k => $v) { call_user_func($hof, $v, $k, $collection); } } return $collection; });
<?php namespace PHPixme; /** * After Decorator * Decorate a callable using the return value of the decorated callable as the argument * for this decorative function. It does not modify the return value. * @param Callable $decorator * @param Callable $fn * @return \Closure * @sig Callable (x->) -> Callable (*->x) -> Closure (*->x) */ function after($decorator = null, $fn = null) { return call_user_func_array(__PRIVATE__::$instance[after], func_get_args()); } const after = __NAMESPACE__ . '\\after'; __PRIVATE__::$instance[after] = __PRIVATE__::curryExactly2(function ($decorator, $fn) { __CONTRACT__::argIsACallable($decorator); __CONTRACT__::argIsACallable($fn, 1); return function () use($decorator, $fn) { $value = call_user_func_array($fn, func_get_args()); call_user_func($decorator, $value); return $value; }; });
namespace PHPixme; /** * @param callable $hof * @param \Traversable= $traversable * @return \Closure|mixed * @sig Callable (a, b -> a) -> \Traversable[a,b] -> a */ function reduceRight($hof = null, $traversable = null) { return call_user_func_array(__PRIVATE__::$instance[reduceRight], func_get_args()); } const reduceRight = __NAMESPACE__ . '\\reduceRight'; __PRIVATE__::$instance[reduceRight] = __PRIVATE__::curryExactly2(function ($hof, $arrayLike) { __CONTRACT__::argIsACallable($hof); __CONTRACT__::argIsATraversable($arrayLike, 1); if ($arrayLike instanceof ReducibleInterface) { return $arrayLike->reduceRight($hof); } // Equalize the usefulness $array = __CONTRACT__::isNonEmpty(__PRIVATE__::traversableToArray($arrayLike)); $output = end($array); $value = prev($array); // Traverse using the internal pointer to avoid creating additional work while (($key = key($array)) !== null) { $output = call_user_func($hof, $output, $value, $key, $arrayLike); $value = prev($array); } return $output; });
<?php namespace PHPixme; /** * pluckObjectWith * Creates a function to access the property of an object * @param string $accessor * @param Object $container * @return \Closure ($object) -> object->accessor * @sig String -> Object -> \Closure (->x) */ function pluckObjectWith($accessor = null, $container = null) { return call_user_func_array(__PRIVATE__::$instance[pluckObjectWith], func_get_args()); } const pluckObjectWith = __NAMESPACE__ . '\\pluckObjectWith'; __PRIVATE__::$instance[pluckObjectWith] = __PRIVATE__::curryExactly2(function ($accessor, $container) { return $container->{$accessor}; });
<?php namespace PHPixme; /** * @param callable $hof * @param array|\Traversable|FunctorInterface $traversable * @return \Closure|mixed * @sig Callable (a -> b) -> \Traversable[a] -> \Traversable[b] * */ function map($hof = null, $traversable = null) { return call_user_func_array(__PRIVATE__::$instance[map], func_get_args()); } const map = __NAMESPACE__ . '\\map'; __PRIVATE__::$instance[map] = __PRIVATE__::curryExactly2(function ($hof, $traversable) { __CONTRACT__::argIsACallable($hof); __CONTRACT__::argIsATraversable($traversable, 1); if ($traversable instanceof FunctorInterface) { return $traversable->map($hof); } $output = []; foreach (__PRIVATE__::protectTraversable($traversable) as $key => $value) { $output[$key] = call_user_func($hof, $value, $key, $traversable); } return $output; });
<?php namespace PHPixme; /** * callWith * Produce a function that calls a function within a array or object * @param string $accessor * @param object|array $container * @return \Closure ($container) -> ((args) -> $container{[$accessor]}(...args)) * @sig String -> Object|Array -> \Closure (*->x) */ function callWith($accessor = null, $container = null) { return call_user_func_array(__PRIVATE__::$instance[callWith], func_get_args()); } const callWith = __NAMESPACE__ . '\\callWith'; __PRIVATE__::$instance[callWith] = __PRIVATE__::curryExactly2(function ($accessor, $container) { $callable = __CONTRACT__::composedIsACallable(is_array($container) ? array_key_exists($accessor, $container) ? $container[$accessor] : null : [$container, $accessor]); return function () use($callable) { return call_user_func_array($callable, func_get_args()); }; });
<?php /** * Created by PhpStorm. * User: rgladson * Date: 5/12/2016 * Time: 12:03 PM */ namespace PHPixme; /** * Wrap a function in an argument that will eat all but n arguments * @param int $arity * @param callable = $hof * @return \Closure * @sig Integer -> Callable (* -> x) -> \Closure (* -> x) */ function nAry($arity = null, callable $hof = null) { return call_user_func_array(__PRIVATE__::$instance[nAry], func_get_args()); } const nAry = __NAMESPACE__ . '\\nAry'; __PRIVATE__::$instance[nAry] = __PRIVATE__::curryExactly2(function ($number = 0, $hof = null) { __CONTRACT__::argIsAPositiveOrZeroInt($number); __CONTRACT__::argIsACallable($hof, 1); return function () use($number, $hof) { $args = func_get_args(); return call_user_func_array($hof, array_slice($args, 0, $number)); }; });
<?php namespace PHPixme; /** * pluckArrayWith * Creates a function to access the property of an object * @param string $accessor * @param array $container * @return \Closure ($object) -> object->accessor * @sig String -> Array -> \Closure (->x) */ function pluckArrayWith($accessor = null, $container = null) { return call_user_func_array(__PRIVATE__::$instance[pluckArrayWith], func_get_args()); } const pluckArrayWith = __NAMESPACE__ . '\\pluckArrayWith'; __PRIVATE__::$instance[pluckArrayWith] = __PRIVATE__::curryExactly2(function ($accessor, $container) { return $container[$accessor]; });
<?php namespace PHPixme; /** * Group a traversable by a return value, separating them out into [groupName=>[value...]] * @param callable $fn * @param array|\Traversable $arrayLike * @return array|\Closure */ function group($fn = null, $arrayLike = null) { return call_user_func_array(__PRIVATE__::$instance[group], func_get_args()); } const group = __NAMESPACE__ . '\\group'; __PRIVATE__::$instance[group] = __PRIVATE__::curryExactly2(function ($fn, $arrayLike) { __CONTRACT__::argIsACallable($fn); __CONTRACT__::argIsATraversable($arrayLike, 1); if ($arrayLike instanceof GroupableInterface) { return $arrayLike->group($fn); } $output = []; foreach (__PRIVATE__::protectTraversable($arrayLike) as $key => $value) { $output[call_user_func($fn, $value, $key, $arrayLike)][] = $value; } return $output; });
<?php namespace PHPixme; /** * partitionWithKey * Like filter, but keeps both sides of the comparison. ["true"=>[[key, value]...], "false"=>[[key, value]...]] * @param callable $fn * @param array|\Traversable $arrayLike * @return array|\Closure */ function partitionWithKey($fn = null, $arrayLike = null) { return call_user_func_array(__PRIVATE__::$instance[partitionWithKey], func_get_args()); } const partitionWithKey = __NAMESPACE__ . '\\partitionWithKey'; __PRIVATE__::$instance[partitionWithKey] = __PRIVATE__::curryExactly2(function ($fn, $arrayLike) { __CONTRACT__::argIsACallable($fn); __CONTRACT__::argIsATraversable($arrayLike, 1); if ($arrayLike instanceof GroupableInterface) { return $arrayLike->partitionWithKey($fn); } $output = ["false" => [], "true" => []]; foreach (__PRIVATE__::protectTraversable($arrayLike) as $key => $value) { $output[call_user_func($fn, $value, $key, $arrayLike) ? "true" : "false"][] = [$key, $value]; } return $output; });
<?php namespace PHPixme; /** * gte, short for greater than or equal to, a stand in for >= * @sig ($lhs)->($rhs)-> boolean $z * @param mixed $lhs * @param mixed $rhs * @return boolean|\Closure */ function gte($lhs = null, $rhs = null) { return call_user_func_array(__PRIVATE__::$instance[gte], func_get_args()); } const gte = __NAMESPACE__ . '\\gte'; __PRIVATE__::$instance[gte] = __PRIVATE__::curryExactly2(function ($lhs, $rhs) { return $lhs > $rhs; });
<?php namespace PHPixme; /** * Before decorator * Wraps a Closure around a callable, running the decorating callable with the same arguments * before executing and returning the value of the decorated function * @param Callable $decorator * @param Callable $fn * @return \Closure * @sig Callable (*->) -> Callable (*->x) -> Closure (*->x) */ function before($decorator = null, $fn = null) { return call_user_func_array(__PRIVATE__::$instance[before], func_get_args()); } const before = __NAMESPACE__ . '\\before'; __PRIVATE__::$instance[before] = __PRIVATE__::curryExactly2(function ($decorator, $fn) { __CONTRACT__::argIsACallable($decorator); __CONTRACT__::argIsACallable($fn, 1); return function () use($decorator, $fn) { $args = func_get_args(); call_user_func_array($decorator, $args); return call_user_func_array($fn, $args); }; });
<?php namespace PHPixme; /** * shiftL, or shift left, a stand in for << * @param int|float $lhs * @param int $rhs * @return int|\Closure */ function shiftL($lhs = null, $rhs = null) { return call_user_func_array(__PRIVATE__::$instance[shiftL], func_get_args()); } const shiftL = __NAMESPACE__ . '\\shiftL'; __PRIVATE__::$instance[shiftL] = __PRIVATE__::curryExactly2(function ($lhs, $rhs) { return $lhs << $rhs; });
<?php namespace PHPixme; /** * nid, short for not the identity, or not strictly equals, a stand in for !== * @sig ($lhs)->($rhs)-> boolean $z * @param mixed $lhs * @param mixed $rhs * @return boolean|\Closure */ function nid($lhs = null, $rhs = null) { return call_user_func_array(__PRIVATE__::$instance[nid], func_get_args()); } const nid = __NAMESPACE__ . '\\nid'; __PRIVATE__::$instance[nid] = __PRIVATE__::curryExactly2(function ($lhs, $rhs) { return $lhs !== $rhs; });