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

Completed

Push — master ( 023ec3...45d736 )

by Baptiste

created 2017-02-04 17:39 UTC

Stream B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	474
Duplicated Lines	15.61 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

100%

Importance

Changes

Metric	Value
wmc	50
lcom	1
cbo	9
dl	74
loc	474
ccs	164
cts	164
cp	1
rs	8.6206
c	0
b	0
f	0

42 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	type()	0	4	1
A	size()	0	4	1
A	count()	0	4	1
A	toPrimitive()	0	4	1
A	current()	0	4	1
A	key()	0	4	1
A	next()	0	4	1
A	rewind()	0	4	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
A	get()	0	4	1
A	diff()	0	11	1
A	distinct()	0	7	1
A	drop()	0	7	1
A	dropEnd()	0	7	1
A	equals()	0	8	1
A	filter()	0	7	1
A	foreach()	0	6	1
B	groupBy()	34	34	6
A	first()	0	4	1
A	last()	0	4	1
A	contains()	0	4	1
A	indexOf()	0	4	1
A	indices()	0	7	1
A	map()	0	11	1
A	pad()	9	9	1
A	partition()	0	17	3
A	slice()	0	7	1
A	splitAt()	0	11	1
A	take()	0	7	1
A	takeEnd()	0	7	1
A	append()	11	11	1
A	intersect()	11	11	1
A	join()	0	4	1
A	add()	9	9	1
A	sort()	0	7	1
A	reduce()	0	4	1
A	validate()	0	8	2

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 Stream 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 Stream, and based on these observations, apply Extract Interface, too.

<?php
declare(strict_types = 1);

namespace Innmind\Immutable;

use Innmind\Immutable\Exception\{
    LogicException,
    GroupEmptySequenceException,
    InvalidArgumentException
};

/**
 * {@inheritdoc}
 */
class Stream implements StreamInterface
{
    use Type;

    private $type;
    private $spec;
    private $values;

    public function __construct(string $type)
    {
        $this->type = new Str($type);
        $this->spec = $this->getSpecFor($type);
        $this->values = new Sequence;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * {@inheritdoc}
     */
    public function diff(StreamInterface $stream): StreamInterface
    {
        $this->validate($stream);

        $newStream = clone $this;
        $newStream->values = $this->values->diff(
            new Sequence(...$stream)
        );

        return $newStream;
    }

    /**
     * {@inheritdoc}
     */
    public function distinct(): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->distinct();

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function drop(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->drop($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function dropEnd(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->dropEnd($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function equals(StreamInterface $stream): bool
    {
        $this->validate($stream);

        return $this->values->equals(
            new Sequence(...$stream)
        );
    }

    /**
     * {@inheritdoc}
     */
    public function filter(callable $predicate): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->filter($predicate);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function foreach(callable $function): StreamInterface
    {
        $this->values->foreach($function);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function groupBy(callable $discriminator): MapInterface

    {
        if ($this->size() === 0) {
            throw new GroupEmptySequenceException;
        }

        $map = null;

        foreach ($this->values as $value) {
            $key = $discriminator($value);

            if ($map === null) {
                $type = gettype($key);
                $map = new Map(
                    $type === 'object' ? get_class($key) : $type,
                    StreamInterface::class
                );
            }

            if ($map->contains($key)) {
                $map = $map->put(
                    $key,
                    $map->get($key)->add($value)
                );
            } else {
                $map = $map->put(
                    $key,
                    (new self((string) $this->type))->add($value)
                );
            }
        }

        return $map;
    }

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

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

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

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

    /**
     * {@inheritdoc}
     */
    public function indices(): StreamInterface
    {
        $stream = new self('int');
        $stream->values = $this->values->indices();

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function map(callable $function): StreamInterface
    {
        return $this
            ->values
            ->reduce(
                new self((string) $this->type),
                function(self $carry, $element) use($function): StreamInterface {
                    return $carry->add($function($element));
                }
            );
    }

    /**
     * {@inheritdoc}
     */
    public function pad(int $size, $element): StreamInterface

    {
        $this->spec->validate($element);

        $stream = clone $this;
        $stream->values = $this->values->pad($size, $element);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function partition(callable $predicate): MapInterface
    {
        $truthy = new self((string) $this->type);
        $falsy = new self((string) $this->type);

        foreach ($this->values as $value) {
            if ($predicate($value) === true) {
                $truthy = $truthy->add($value);
            } else {
                $falsy = $falsy->add($value);
            }
        }

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

    /**
     * {@inheritdoc}
     */
    public function slice(int $from, int $until): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->slice($from, $until);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function splitAt(int $position): StreamInterface
    {
        $stream = new self(StreamInterface::class);
        $splitted = $this->values->splitAt($position);
        $first = new self((string) $this->type);
        $second = new self((string) $this->type);
        $first->values = $splitted->first();
        $second->values = $splitted->last();

        return $stream->add($first)->add($second);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * {@inheritdoc}
     */
    public function take(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->take($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function takeEnd(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->takeEnd($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function append(StreamInterface $stream): StreamInterface

    {
        $this->validate($stream);

        $self = clone $this;
        $self->values = $this->values->append(
            new Sequence(...$stream)
        );

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function intersect(StreamInterface $stream): StreamInterface

    {
        $this->validate($stream);

        $self = clone $this;
        $self->values = $this->values->intersect(
            new Sequence(...$stream)
        );

        return $self;
    }

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

    /**
     * {@inheritdoc}
     */
    public function add($element): StreamInterface

    {
        $this->spec->validate($element);

        $stream = clone $this;
        $stream->values = $this->values->add($element);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function sort(callable $function): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->sort($function);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function reduce($carry, callable $reducer)
    {
        return $this->values->reduce($carry, $reducer);
    }

    /**
     * Make sure the stream is compatible with the current one
     *
     * @param StreamInterface $stream
     *
     * @throws InvalidArgumentException
     *
     * @return void
     */
    private function validate(StreamInterface $stream)
    {
        if (!$stream->type()->equals($this->type)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            throw new InvalidArgumentException(
                'The 2 streams does not reference the same type'
            );
        }
    }
}


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

Innmind / Immutable

GitHub Access Token became invalid