LambdaExpression::call() - Code Metrics - peacefulbit/packet-lite - Measure and Improve Code Quality continuously with Scrutinizer

LambdaExpression::call() A
last analyzed 2016-11-01 20:01 UTC

↳ Parent: LambdaExpression

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	6
nc	2
nop	2
dl	0
loc	12
rs	9.4285
c	0
b	0
f	0

<?php

namespace PeacefulBit\Slate\Parser\Nodes;

use PeacefulBit\Slate\Core\Evaluator;
use PeacefulBit\Slate\Core\Frame;

use Nerd\Common\Arrays;
use PeacefulBit\Slate\Exceptions\EvaluatorException;

class LambdaExpression extends Node implements CallableNode
{
    /**
     * @var array
     */
    private $params;

    /**
     * @var Node
     */
    private $body;

    /**
     * @param array $params
     * @param Node $body
     */
    public function __construct(array $params, Node $body)
    {
        $this->params = $params;
        $this->body = $body;
    }

    /**
     * @return array
     */
    public function getParams(): array
    {
        return $this->params;
    }

    /**
     * @return Node
     */
    public function getBody(): Node
    {
        return $this->body;
    }

    /**
     * @return string
     */
    public function __toString()
    {
        return '(lambda '
        . '('
        . implode(' ', array_map('strval', $this->getParams()))
        . ') '
        . strval($this->getBody())
        . ')';
    }

    /**
     * @param Frame $frame
     * @return $this
     */
    public function evaluate(Frame $frame)
    {
        return $this;
    }

    /**
     * @param Frame $frame
     * @param array $arguments
     * @return mixed
     * @throws EvaluatorException
     */
    public function call(Frame $frame, array $arguments = [])
    {
        if (sizeof($this->getParams()) != sizeof($arguments)) {
            throw new EvaluatorException("Number of arguments mismatch");
        }

        $evaluatedArguments = array_map([$frame, 'evaluate'], $arguments);

        $newFrame = array_combine($this->getParams(), $evaluatedArguments);

        return $frame->extend($newFrame)->evaluate($this->getBody());
    }
}


1			<?php
2
3			namespace PeacefulBit\Slate\Parser\Nodes;
4
5			use PeacefulBit\Slate\Core\Evaluator;
6			use PeacefulBit\Slate\Core\Frame;
7
8			use Nerd\Common\Arrays;
9			use PeacefulBit\Slate\Exceptions\EvaluatorException;
10
11			class LambdaExpression extends Node implements CallableNode
12			{
13			/**
14			* @var array
15			*/
16			private $params;
17
18			/**
19			* @var Node
20			*/
21			private $body;
22
23			/**
24			* @param array $params
25			* @param Node $body
26			*/
27			public function __construct(array $params, Node $body)
28			{
29			$this->params = $params;
30			$this->body = $body;
31			}
32
33			/**
34			* @return array
35			*/
36			public function getParams(): array
37			{
38			return $this->params;
39			}
40
41			/**
42			* @return Node
43			*/
44			public function getBody(): Node
45			{
46			return $this->body;
47			}
48
49			/**
50			* @return string
51			*/
52			public function __toString()
53			{
54			return '(lambda '
55			. '('
56			. implode(' ', array_map('strval', $this->getParams()))
57			. ') '
58			. strval($this->getBody())
59			. ')';
60			}
61
62			/**
63			* @param Frame $frame
64			* @return $this
65			*/
66			public function evaluate(Frame $frame)
67			{
68			return $this;
69			}
70
71			/**
72			* @param Frame $frame
73			* @param array $arguments
74			* @return mixed
75			* @throws EvaluatorException
76			*/
77			public function call(Frame $frame, array $arguments = [])
78			{
79			if (sizeof($this->getParams()) != sizeof($arguments)) {
80			throw new EvaluatorException("Number of arguments mismatch");
81			}
82
83			$evaluatedArguments = array_map([$frame, 'evaluate'], $arguments);
84
85			$newFrame = array_combine($this->getParams(), $evaluatedArguments);
86
87			return $frame->extend($newFrame)->evaluate($this->getBody());
88			}
89			}
90

peacefulbit / packet-lite

LambdaExpression::call() A last analyzed 2016-11-01 20:01 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

LambdaExpression::call() A
last analyzed 2016-11-01 20:01 UTC