identity() - Code Metrics - Inspection of "identity and identical function" - aerophant/ramda - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#10)

by Siwapun

created 2018-06-30 21:00 UTC

identity() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	8
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php
namespace Aerophant\Ramda;

/**
 * @param mixed $data
 * @return \Closure
 */
function always()
{
  $always = function ($data) {
    return function () use ($data) {
      return $data;
    };
  };
  $arguments = func_get_args();
  $curried = curryN($always, 1);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param callable $fn
 * @param array $args
 * @return string
 */
function apply()
{
  $apply = function (callable $fn, array $args) {
    return call_user_func_array($fn, $args);
  };
  $arguments = func_get_args();
  $curried = curryN($apply, 2);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param callable $fn
 * @param mixed ...$args
 * @return string
 */
function call()
{
  $arguments = func_get_args();
  $length = count($arguments);
  switch ($length) {
    case 0:
          return __FUNCTION__;
    case 1:
      $fn = $arguments[0];
          return function (...$arguments) use ($fn) {

            return call_user_func_array($fn, $arguments);
          };
    default:
      $fn = $arguments[0];
      $arguments = dropFirst($arguments);
          return call_user_func_array($fn, $arguments);
  }
}

/**
 * @return callable
 * @throws \Exception
 */
function compose()
{
  $arguments = array_reverse(func_get_args());
  return call_user_func_array('Aerophant\Ramda\pipe', $arguments);
}

/**
 * @param string $class
 * @return \Closure
 */
function construct()
{
  $construct = function ($class) {
    return function () use ($class) {
      return new $class();
    };
  };
  $arguments = func_get_args();
  $curried = curryN($construct, 1);
  return call_user_func_array($curried, $arguments);
}

function curryN(callable $fn, int $numberOfArguments)
{
  return function () use ($fn, $numberOfArguments) {
    $arguments = func_get_args();
    $length = count($arguments);
    if ($length > $numberOfArguments) {
      throw new \InvalidArgumentException(
        "Number of passed($length) parameters is greater than expected($numberOfArguments)"
      );
    }
    // NO CURRY
    if ($length == $numberOfArguments) {
      return call_user_func_array($fn, $arguments);
    }
    // AUTO CURRY
    $curriedFn = function () use ($fn, $arguments) {
      $curriedArguments = func_get_args();
      return call_user_func_array($fn, array_merge($arguments, $curriedArguments));
    };
    return curryN($curriedFn, $numberOfArguments - $length);
  };
}

/**
 * @param mixed $value
 * @return mixed|\Closure
 */
function identity()
{
  $identity = function ($value) {
    return $value;
  };
  $arguments = func_get_args();
  $curried = curryN($identity, 1);
  return call_user_func_array($curried, $arguments);
}

/**
 * ((a, b, c, …, n) → x) → [a, b, c, …] → ((d, e, f, …, n) → x)
 * @param callable $fn
 * @param array $args
 * @return \Closure
 */
function partial(callable $fn, array $args)
{
  return function () use ($fn, $args) {
    $arguments = func_get_args();
    return call_user_func_array($fn, array_merge($args, $arguments));
  };
}

/**
 * ((a, b, c, …, n) → x) → [d, e, f, …, n] → ((a, b, c, …) → x)
 * @param callable $fn
 * @param array $args
 * @return \Closure
 */
function partialRight(callable $fn, array $args)
{
  return function () use ($fn, $args) {
    $arguments = func_get_args();
    return call_user_func_array($fn, array_merge($arguments, $args));
  };
}

/**
 * @return callable
 * @throws \Exception
 */
function pipe()
{
  $arguments = func_get_args();
  $length = count($arguments);
  if ($length === 0) {
    throw new \Exception("pipe requires at least one argument");
  }
  return function () use ($arguments) {
    $internalArguments = func_get_args();
    $initialValue = call_user_func_array($arguments[0], $internalArguments);
    $accumulator = function ($acc, $it) {
      return call_user_func_array($it, [$acc]);
    };
    return array_reduce(drop(0, $arguments), $accumulator, $initialValue);
  };
}


1			<?php
2			namespace Aerophant\Ramda;
3
4			/**
5			* @param mixed $data
6			* @return \Closure
7			*/
8			function always()
9			{
10			$always = function ($data) {
11			return function () use ($data) {
12			return $data;
13			};
14			};
15			$arguments = func_get_args();
16			$curried = curryN($always, 1);
17			return call_user_func_array($curried, $arguments);
18			}
19
20			/**
21			* @param callable $fn
22			* @param array $args
23			* @return string
24			*/
25			function apply()
26			{
27			$apply = function (callable $fn, array $args) {
28			return call_user_func_array($fn, $args);
29			};
30			$arguments = func_get_args();
31			$curried = curryN($apply, 2);
32			return call_user_func_array($curried, $arguments);
33			}
34
35			/**
36			* @param callable $fn
37			* @param mixed ...$args
38			* @return string
39			*/
40			function call()
41			{
42			$arguments = func_get_args();
43			$length = count($arguments);
44			switch ($length) {
45			case 0:
46			return __FUNCTION__;
47			case 1:
48			$fn = $arguments[0];
49			return function (...$arguments) use ($fn) {
			0 ignored issues – show Bug Best Practice introduced 2018-06-30 19:08 UTC by Report Bug Copy Issue Report The expression `return function(...) { /* ... */ }` returns the type `callable` which is incompatible with the documented return type `string`. Loading history...
50			return call_user_func_array($fn, $arguments);
51			};
52			default:
53			$fn = $arguments[0];
54			$arguments = dropFirst($arguments);
55			return call_user_func_array($fn, $arguments);
56			}
57			}
58
59			/**
60			* @return callable
61			* @throws \Exception
62			*/
63			function compose()
64			{
65			$arguments = array_reverse(func_get_args());
66			return call_user_func_array('Aerophant\Ramda\pipe', $arguments);
67			}
68
69			/**
70			* @param string $class
71			* @return \Closure
72			*/
73			function construct()
74			{
75			$construct = function ($class) {
76			return function () use ($class) {
77			return new $class();
78			};
79			};
80			$arguments = func_get_args();
81			$curried = curryN($construct, 1);
82			return call_user_func_array($curried, $arguments);
83			}
84
85			function curryN(callable $fn, int $numberOfArguments)
86			{
87			return function () use ($fn, $numberOfArguments) {
88			$arguments = func_get_args();
89			$length = count($arguments);
90			if ($length > $numberOfArguments) {
91			throw new \InvalidArgumentException(
92			"Number of passed($length) parameters is greater than expected($numberOfArguments)"
93			);
94			}
95			// NO CURRY
96			if ($length == $numberOfArguments) {
97			return call_user_func_array($fn, $arguments);
98			}
99			// AUTO CURRY
100			$curriedFn = function () use ($fn, $arguments) {
101			$curriedArguments = func_get_args();
102			return call_user_func_array($fn, array_merge($arguments, $curriedArguments));
103			};
104			return curryN($curriedFn, $numberOfArguments - $length);
105			};
106			}
107
108			/**
109			* @param mixed $value
110			* @return mixed\|\Closure
111			*/
112			function identity()
113			{
114			$identity = function ($value) {
115			return $value;
116			};
117			$arguments = func_get_args();
118			$curried = curryN($identity, 1);
119			return call_user_func_array($curried, $arguments);
120			}
121
122			/**
123			* ((a, b, c, …, n) → x) → [a, b, c, …] → ((d, e, f, …, n) → x)
124			* @param callable $fn
125			* @param array $args
126			* @return \Closure
127			*/
128			function partial(callable $fn, array $args)
129			{
130			return function () use ($fn, $args) {
131			$arguments = func_get_args();
132			return call_user_func_array($fn, array_merge($args, $arguments));
133			};
134			}
135
136			/**
137			* ((a, b, c, …, n) → x) → [d, e, f, …, n] → ((a, b, c, …) → x)
138			* @param callable $fn
139			* @param array $args
140			* @return \Closure
141			*/
142			function partialRight(callable $fn, array $args)
143			{
144			return function () use ($fn, $args) {
145			$arguments = func_get_args();
146			return call_user_func_array($fn, array_merge($arguments, $args));
147			};
148			}
149
150			/**
151			* @return callable
152			* @throws \Exception
153			*/
154			function pipe()
155			{
156			$arguments = func_get_args();
157			$length = count($arguments);
158			if ($length === 0) {
159			throw new \Exception("pipe requires at least one argument");
160			}
161			return function () use ($arguments) {
162			$internalArguments = func_get_args();
163			$initialValue = call_user_func_array($arguments[0], $internalArguments);
164			$accumulator = function ($acc, $it) {
165			return call_user_func_array($it, [$acc]);
166			};
167			return array_reduce(drop(0, $arguments), $accumulator, $initialValue);
168			};
169			}
170

aerophant / ramda

Pull Request — master (#10)

identity() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like