Map - Code Metrics - Inspection of "Merge branch 'develop'" - Innmind/Immutable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e8feac...c3293d )

by Baptiste

created 2016-03-17 07:05 UTC

Map B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	470
Duplicated Lines	14.89 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

98.95%

Metric	Value
wmc	53
lcom	1
cbo	11
dl	70
loc	470
ccs	188
cts	190
cp	0.9895
rs	7.4757

35 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	keyType()	0	4	1
A	valueType()	0	4	1
A	size()	0	4	1
A	count()	0	4	1
A	current()	0	4	1
A	key()	0	4	1
A	next()	0	6	1
A	rewind()	0	6	1
A	valid()	0	4	1
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
B	put()	0	25	2
A	get()	0	10	2
A	contains()	0	4	1
A	drop()	9	9	1
A	dropEnd()	9	9	1
A	clear()	0	9	1
A	equals()	0	8	2
A	filter()	0	16	3
A	first()	0	4	1
A	last()	0	4	1
A	keys()	0	4	1
A	values()	0	4	1
A	take()	9	9	1
A	takeEnd()	9	9	1
A	join()	0	4	1
B	groupBy()	7	33	6
A	remove()	0	23	2
A	foreach()	0	8	2
A	merge()	0	19	3
A	map()	15	22	3
A	partition()	12	22	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Map often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Map, and based on these observations, apply Extract Interface, too.

<?php
declare(strict_types = 1);

namespace Innmind\Immutable;

use Innmind\Immutable\{
    Exception\InvalidArgumentException,
    Exception\LogicException,
    Exception\ElementNotFoundException,
    Exception\GroupEmptyMapException
};

class Map implements MapInterface
{
    use Type;

    private $keyType;
    private $valueType;
    private $keySpec;
    private $valueSpec;
    private $keys;
    private $values;
    private $pairs;

    public function __construct(string $keyType, string $valueType)
    {
        $this->keySpec = $this->getSpecFor($keyType);
        $this->valueSpec = $this->getSpecFor($valueType);
        $this->keyType = new StringPrimitive($keyType);
        $this->valueType = new StringPrimitive($valueType);
        $this->keys = new Sequence;
        $this->values = new Sequence;
        $this->pairs = new Sequence;
    }

    /**
     * {@inheritdoc}
     */
    public function keyType(): StringPrimitive
    {
        return $this->keyType;
    }

    /**
     * {@inheritdoc}
     */
    public function valueType(): StringPrimitive
    {
        return $this->valueType;
    }

    /**
     * {@inheritdoc}
     */
    public function size(): int
    {
        return $this->keys->size();
    }

    /**
     * {@inheritdoc}
     */
    public function count(): int
    {
        return $this->keys->count();
    }

    /**
     * {@inheritdoc}
     */
    public function current()
    {
        return $this->values->current();
    }

    /**
     * {@inheritdoc}
     */
    public function key()
    {
        return $this->keys->current();
    }

    /**
     * {@inheritdoc}
     */
    public function next()
    {
        $this->keys->next();
        $this->values->next();
        $this->pairs->next();
    }

    /**
     * {@inheritdoc}
     */
    public function rewind()
    {
        $this->keys->rewind();
        $this->values->rewind();
        $this->pairs->rewind();
    }

    /**
     * {@inheritdoc}
     */
    public function valid()
    {
        return $this->keys->valid();
    }

    /**
     * {@inheritdoc}
     */
    public function offsetExists($offset): bool
    {
        return $this->keys->contains($offset);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetGet($offset)
    {
        return $this->get($offset);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value)
    {
        throw new LogicException('You can\'t modify a map');
    }

    /**
     * {@inheritdoc}
     */
    public function offsetUnset($offset)
    {
        throw new LogicException('You can\'t modify a map');
    }

    /**
     * {@inheritdoc}
     */
    public function put($key, $value): MapInterface
    {
        $this->keySpec->validate($key);
        $this->valueSpec->validate($value);

        $map = clone $this;

        if ($this->keys->contains($key)) {
            $index = $this->keys->indexOf($key);
            $map->values = (new Sequence)
                ->append($this->values->take($index))
                ->add($value)
                ->append($this->values->drop($index + 1));
            $map->pairs = (new Sequence)
                ->append($this->pairs->take($index))
                ->add(new Pair($key, $value))
                ->append($this->pairs->drop($index + 1));
        } else {
            $map->keys = $this->keys->add($key);
            $map->values = $this->values->add($value);
            $map->pairs = $this->pairs->add(new Pair($key, $value));
        }

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function get($key)
    {
        if (!$this->keys->contains($key)) {
            throw new ElementNotFoundException;
        }

        return $this->values->get(
            $this->keys->indexOf($key)
        );
    }

    /**
     * {@inheritdoc}
     */
    public function contains($key): bool
    {
        return $this->keys->contains($key);
    }

    /**
     * {@inheritdoc}
     */
    public function drop(int $size): MapInterface

    {
        $map = clone $this;
        $map->keys = $this->keys->drop($size);
        $map->values = $this->values->drop($size);
        $map->pairs = $this->pairs->drop($size);

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function dropEnd(int $size): MapInterface

    {
        $map = clone $this;
        $map->keys = $this->keys->dropEnd($size);
        $map->values = $this->values->dropEnd($size);
        $map->pairs = $this->pairs->dropEnd($size);

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function clear(): MapInterface
    {
        $map = clone $this;
        $map->keys = new Sequence;
        $map->values = new Sequence;
        $map->pairs = new Sequence;

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function equals(MapInterface $map): bool
    {
        if ($map->keys()->equals($this->keys())) {
            return true;
        }

        return $map->values()->equals($this->values());
    }

    /**
     * {@inheritdoc}
     */
    public function filter(\Closure $predicate): MapInterface
    {
        $map = $this->clear();

        foreach ($this->keys as $index => $key) {
            $value = $this->values->get($index);

            if ($predicate($key, $value) === true) {
                $map->keys = $map->keys->add($key);
                $map->values = $map->values->add($value);
                $map->pairs = $map->pairs->add($this->pairs->get($index));
            }
        }

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function foreach(\Closure $function): MapInterface
    {
        foreach ($this->keys as $index => $key) {
            $function($key, $this->values->get($index));
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function groupBy(\Closure $discriminator): MapInterface
    {
        if ($this->size() === 0) {
            throw new GroupEmptyMapException;
        }

        $map = null;

        foreach ($this->keys as $index => $key) {
            $newKey = $discriminator($key, $this->values->get($index));

            if ($map === null) {

                $type = gettype($newKey);
                $map = new self(
                    $type === 'object' ? get_class($newKey) : $type,
                    SequenceInterface::class
                );
            }

            $pair = $this->pairs->get($index);

            if ($map->contains($newKey)) {
                $map = $map->put(
                    $newKey,
                    $map->get($newKey)->add($pair)
                );
            } else {
                $map = $map->put($newKey, new Sequence($pair));
            }
        }

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function first(): Pair
    {
        return $this->pairs->first();
    }

    /**
     * {@inheritdoc}
     */
    public function last(): Pair
    {
        return $this->pairs->last();
    }

    /**
     * {@inheritdoc}
     */
    public function keys(): SequenceInterface
    {
        return $this->keys;
    }

    /**
     * {@inheritdoc}
     */
    public function values(): SequenceInterface
    {
        return $this->values;
    }

    /**
     * {@inheritdoc}
     */
    public function map(\Closure $function): MapInterface
    {
        $map = $this->clear();

        foreach ($this->keys as $index => $key) {

            $return = $function(
                $key,
                $this->values->get($index)
            );

            if ($return instanceof Pair) {
                $key = $return->key();
                $value = $return->value();
            } else {
                $value = $return;
            }

            $map = $map->put($key, $value);
        }

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function take(int $size): MapInterface

    {
        $map = clone $this;
        $map->keys = $this->keys->take($size);
        $map->values = $this->values->take($size);
        $map->pairs = $this->pairs->take($size);

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function takeEnd(int $size): MapInterface

    {
        $map = clone $this;
        $map->keys = $this->keys->takeEnd($size);
        $map->values = $this->values->takeEnd($size);
        $map->pairs = $this->pairs->takeEnd($size);

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function join(string $separator): StringPrimitive
    {
        return $this->values->join($separator);
    }

    /**
     * {@inheritdoc}
     */
    public function remove($key): MapInterface
    {
        if (!$this->contains($key)) {
            return $this;
        }

        $index = $this->keys->indexOf($key);
        $map = clone $this;
        $map->keys = $this
            ->keys
            ->slice(0, $index)
            ->append($this->keys->slice($index + 1, $this->keys->size()));
        $map->values = $this
            ->values
            ->slice(0, $index)
            ->append($this->values->slice($index + 1, $this->values->size()));
        $map->pairs = $this
            ->pairs
            ->slice(0, $index)
            ->append($this->pairs->slice($index + 1, $this->pairs->size()));

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function merge(MapInterface $map): MapInterface
    {
        if (
            !$this->keyType()->equals($map->keyType()) ||
            !$this->valueType()->equals($map->valueType())
        ) {
            throw new InvalidArgumentException(
                'The 2 maps does not reference the same types'
            );
        }

        $newMap = clone $this;

        $map->foreach(function($key, $value) use (&$newMap) {
            $newMap = $newMap->put($key, $value);
        });

        return $newMap;
    }

    /**
     * {@inheritdoc}
     */
    public function partition(\Closure $predicate): MapInterface
    {
        $truthy = $this->clear();
        $falsy = $this->clear();

        foreach ($this->keys as $index => $key) {

            $return = $predicate(
                $key,
                $value = $this->values->get($index)
            );

            if ($return === true) {
                $truthy = $truthy->put($key, $value);
            } else {
                $falsy = $falsy->put($key, $value);
            }
        }

        return (new self('bool', MapInterface::class))
            ->put(true, $truthy)
            ->put(false, $falsy);
    }
}


1			<?php
2			declare(strict_types = 1);
3
4			namespace Innmind\Immutable;
5
6			use Innmind\Immutable\{
7			Exception\InvalidArgumentException,
8			Exception\LogicException,
9			Exception\ElementNotFoundException,
10			Exception\GroupEmptyMapException
11			};
12
13			class Map implements MapInterface
14			{
15			use Type;
16
17			private $keyType;
18			private $valueType;
19			private $keySpec;
20			private $valueSpec;
21			private $keys;
22			private $values;
23			private $pairs;
24
25	36		public function __construct(string $keyType, string $valueType)
26			{
27	36		$this->keySpec = $this->getSpecFor($keyType);
28	36		$this->valueSpec = $this->getSpecFor($valueType);
29	36		$this->keyType = new StringPrimitive($keyType);
30	36		$this->valueType = new StringPrimitive($valueType);
31	36		$this->keys = new Sequence;
32	36		$this->values = new Sequence;
33	36		$this->pairs = new Sequence;
34	36		}
35
36			/**
37			* {@inheritdoc}
38			*/
39	14		public function keyType(): StringPrimitive
40			{
41	14		return $this->keyType;
42			}
43
44			/**
45			* {@inheritdoc}
46			*/
47	13		public function valueType(): StringPrimitive
48			{
49	13		return $this->valueType;
50			}
51
52			/**
53			* {@inheritdoc}
54			*/
55	11		public function size(): int
56			{
57	11		return $this->keys->size();
58			}
59
60			/**
61			* {@inheritdoc}
62			*/
63			public function count(): int
64			{
65			return $this->keys->count();
66			}
67
68			/**
69			* {@inheritdoc}
70			*/
71	1		public function current()
72			{
73	1		return $this->values->current();
74			}
75
76			/**
77			* {@inheritdoc}
78			*/
79	1		public function key()
80			{
81	1		return $this->keys->current();
82			}
83
84			/**
85			* {@inheritdoc}
86			*/
87	1		public function next()
88			{
89	1		$this->keys->next();
90	1		$this->values->next();
91	1		$this->pairs->next();
92	1		}
93
94			/**
95			* {@inheritdoc}
96			*/
97	1		public function rewind()
98			{
99	1		$this->keys->rewind();
100	1		$this->values->rewind();
101	1		$this->pairs->rewind();
102	1		}
103
104			/**
105			* {@inheritdoc}
106			*/
107	1		public function valid()
108			{
109	1		return $this->keys->valid();
110			}
111
112			/**
113			* {@inheritdoc}
114			*/
115	1		public function offsetExists($offset): bool
116			{
117	1		return $this->keys->contains($offset);
118			}
119
120			/**
121			* {@inheritdoc}
122			*/
123	2		public function offsetGet($offset)
124			{
125	2		return $this->get($offset);
126			}
127
128			/**
129			* {@inheritdoc}
130			*/
131	1		public function offsetSet($offset, $value)
132			{
133	1		throw new LogicException('You can\'t modify a map');
134			}
135
136			/**
137			* {@inheritdoc}
138			*/
139	1		public function offsetUnset($offset)
140			{
141	1		throw new LogicException('You can\'t modify a map');
142			}
143
144			/**
145			* {@inheritdoc}
146			*/
147	30		public function put($key, $value): MapInterface
148			{
149	30		$this->keySpec->validate($key);
150	29		$this->valueSpec->validate($value);
151
152	27		$map = clone $this;
153
154	27		if ($this->keys->contains($key)) {
155	5		$index = $this->keys->indexOf($key);
156	5		$map->values = (new Sequence)
157	5		->append($this->values->take($index))
158	5		->add($value)
159	5		->append($this->values->drop($index + 1));
160	5		$map->pairs = (new Sequence)
161	5		->append($this->pairs->take($index))
162	5		->add(new Pair($key, $value))
163	5		->append($this->pairs->drop($index + 1));
164			} else {
165	27		$map->keys = $this->keys->add($key);
166	27		$map->values = $this->values->add($value);
167	27		$map->pairs = $this->pairs->add(new Pair($key, $value));
168			}
169
170	27		return $map;
171			}
172
173			/**
174			* {@inheritdoc}
175			*/
176	12		public function get($key)
177			{
178	12		if (!$this->keys->contains($key)) {
179	2		throw new ElementNotFoundException;
180			}
181
182	10		return $this->values->get(
183	10		$this->keys->indexOf($key)
184			);
185			}
186
187			/**
188			* {@inheritdoc}
189			*/
190	10		public function contains($key): bool
191			{
192	10		return $this->keys->contains($key);
193			}
194
195			/**
196			* {@inheritdoc}
197			*/
198	1	View Code Duplication	public function drop(int $size): MapInterface
			0 ignored issues – show Duplication introduced 2016-02-29 07:43 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
199			{
200	1		$map = clone $this;
201	1		$map->keys = $this->keys->drop($size);
202	1		$map->values = $this->values->drop($size);
203	1		$map->pairs = $this->pairs->drop($size);
204
205	1		return $map;
206			}
207
208			/**
209			* {@inheritdoc}
210			*/
211	1	View Code Duplication	public function dropEnd(int $size): MapInterface
			0 ignored issues – show Duplication introduced 2016-02-29 07:43 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
212			{
213	1		$map = clone $this;
214	1		$map->keys = $this->keys->dropEnd($size);
215	1		$map->values = $this->values->dropEnd($size);
216	1		$map->pairs = $this->pairs->dropEnd($size);
217
218	1		return $map;
219			}
220
221			/**
222			* {@inheritdoc}
223			*/
224	4		public function clear(): MapInterface
225			{
226	4		$map = clone $this;
227	4		$map->keys = new Sequence;
228	4		$map->values = new Sequence;
229	4		$map->pairs = new Sequence;
230
231	4		return $map;
232			}
233
234			/**
235			* {@inheritdoc}
236			*/
237	2		public function equals(MapInterface $map): bool
238			{
239	2		if ($map->keys()->equals($this->keys())) {
240	1		return true;
241			}
242
243	2		return $map->values()->equals($this->values());
244			}
245
246			/**
247			* {@inheritdoc}
248			*/
249	1		public function filter(\Closure $predicate): MapInterface
250			{
251	1		$map = $this->clear();
252
253	1		foreach ($this->keys as $index => $key) {
254	1		$value = $this->values->get($index);
255
256	1		if ($predicate($key, $value) === true) {
257	1		$map->keys = $map->keys->add($key);
258	1		$map->values = $map->values->add($value);
259	1		$map->pairs = $map->pairs->add($this->pairs->get($index));
260			}
261			}
262
263	1		return $map;
264			}
265
266			/**
267			* {@inheritdoc}
268			*/
269			public function foreach(\Closure $function): MapInterface
270			{
271	2		foreach ($this->keys as $index => $key) {
272	2		$function($key, $this->values->get($index));
273			}
274
275	2		return $this;
276			}
277
278			/**
279			* {@inheritdoc}
280			*/
281	2		public function groupBy(\Closure $discriminator): MapInterface
282			{
283	2		if ($this->size() === 0) {
284	1		throw new GroupEmptyMapException;
285			}
286
287	1		$map = null;
288
289	1		foreach ($this->keys as $index => $key) {
290	1		$newKey = $discriminator($key, $this->values->get($index));
291
292	1	View Code Duplication	if ($map === null) {
			0 ignored issues – show Duplication introduced 2016-02-29 07:43 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
293	1		$type = gettype($newKey);
294	1		$map = new self(
295	1		$type === 'object' ? get_class($newKey) : $type,
296	1		SequenceInterface::class
297			);
298			}
299
300	1		$pair = $this->pairs->get($index);
301
302	1		if ($map->contains($newKey)) {
303	1		$map = $map->put(
304			$newKey,
305	1		$map->get($newKey)->add($pair)
306			);
307			} else {
308	1		$map = $map->put($newKey, new Sequence($pair));
309			}
310			}
311
312	1		return $map;
313			}
314
315			/**
316			* {@inheritdoc}
317			*/
318	1		public function first(): Pair
319			{
320	1		return $this->pairs->first();
321			}
322
323			/**
324			* {@inheritdoc}
325			*/
326	1		public function last(): Pair
327			{
328	1		return $this->pairs->last();
329			}
330
331			/**
332			* {@inheritdoc}
333			*/
334	8		public function keys(): SequenceInterface
335			{
336	8		return $this->keys;
337			}
338
339			/**
340			* {@inheritdoc}
341			*/
342	6		public function values(): SequenceInterface
343			{
344	6		return $this->values;
345			}
346
347			/**
348			* {@inheritdoc}
349			*/
350	1		public function map(\Closure $function): MapInterface
351			{
352	1		$map = $this->clear();
353
354	1	View Code Duplication	foreach ($this->keys as $index => $key) {
			0 ignored issues – show Duplication introduced 2016-03-17 07:00 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
355	1		$return = $function(
356			$key,
357	1		$this->values->get($index)
358			);
359
360	1		if ($return instanceof Pair) {
361	1		$key = $return->key();
362	1		$value = $return->value();
363			} else {
364	1		$value = $return;
365			}
366
367	1		$map = $map->put($key, $value);
368			}
369
370	1		return $map;
371			}
372
373			/**
374			* {@inheritdoc}
375			*/
376	1	View Code Duplication	public function take(int $size): MapInterface
			0 ignored issues – show Duplication introduced 2016-02-29 07:43 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
377			{
378	1		$map = clone $this;
379	1		$map->keys = $this->keys->take($size);
380	1		$map->values = $this->values->take($size);
381	1		$map->pairs = $this->pairs->take($size);
382
383	1		return $map;
384			}
385
386			/**
387			* {@inheritdoc}
388			*/
389	1	View Code Duplication	public function takeEnd(int $size): MapInterface
			0 ignored issues – show Duplication introduced 2016-02-29 07:43 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
390			{
391	1		$map = clone $this;
392	1		$map->keys = $this->keys->takeEnd($size);
393	1		$map->values = $this->values->takeEnd($size);
394	1		$map->pairs = $this->pairs->takeEnd($size);
395
396	1		return $map;
397			}
398
399			/**
400			* {@inheritdoc}
401			*/
402	1		public function join(string $separator): StringPrimitive
403			{
404	1		return $this->values->join($separator);
405			}
406
407			/**
408			* {@inheritdoc}
409			*/
410	1		public function remove($key): MapInterface
411			{
412	1		if (!$this->contains($key)) {
413	1		return $this;
414			}
415
416	1		$index = $this->keys->indexOf($key);
417	1		$map = clone $this;
418	1		$map->keys = $this
419	1		->keys
420	1		->slice(0, $index)
421	1		->append($this->keys->slice($index + 1, $this->keys->size()));
422	1		$map->values = $this
423	1		->values
424	1		->slice(0, $index)
425	1		->append($this->values->slice($index + 1, $this->values->size()));
426	1		$map->pairs = $this
427	1		->pairs
428	1		->slice(0, $index)
429	1		->append($this->pairs->slice($index + 1, $this->pairs->size()));
430
431	1		return $map;
432			}
433
434			/**
435			* {@inheritdoc}
436			*/
437	2		public function merge(MapInterface $map): MapInterface
438			{
439			if (
440	2		!$this->keyType()->equals($map->keyType()) \|\|
441	2		!$this->valueType()->equals($map->valueType())
442			) {
443	1		throw new InvalidArgumentException(
444	1		'The 2 maps does not reference the same types'
445			);
446			}
447
448	1		$newMap = clone $this;
449
450	1		$map->foreach(function($key, $value) use (&$newMap) {
451	1		$newMap = $newMap->put($key, $value);
452	1		});
453
454	1		return $newMap;
455			}
456
457			/**
458			* {@inheritdoc}
459			*/
460	1		public function partition(\Closure $predicate): MapInterface
461			{
462	1		$truthy = $this->clear();
463	1		$falsy = $this->clear();
464
465	1	View Code Duplication	foreach ($this->keys as $index => $key) {
			0 ignored issues – show Duplication introduced 2016-03-17 07:00 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
466	1		$return = $predicate(
467			$key,
468	1		$value = $this->values->get($index)
469			);
470
471	1		if ($return === true) {
472	1		$truthy = $truthy->put($key, $value);
473			} else {
474	1		$falsy = $falsy->put($key, $value);
475			}
476			}
477
478	1		return (new self('bool', MapInterface::class))
479	1		->put(true, $truthy)
480	1		->put(false, $falsy);
481			}
482			}
483

Innmind / Immutable

GitHub Access Token became invalid