Comprehension::collapse() - Code Metrics - Innmind/Immutable - Measure and Improve Code Quality continuously with Scrutinizer

Comprehension::collapse() A
last analyzed 2022-07-02 13:48 UTC

↳ Parent: Comprehension

Complexity

Conditions	1
Paths	1

Size

Total Lines	14
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	1
eloc	6
c	1
b	0
f	1
nc	1
nop	0
dl	0
loc	14
rs	10

<?php
declare(strict_types = 1);

namespace Innmind\Immutable\Maybe;

use Innmind\Immutable\Maybe;

/**
 * @psalm-immutable
 */
final class Comprehension
{
    private Maybe $first;
    /** @var list<Maybe> */
filter:
    dependency_paths: ["lib/*"]
    private array $rest;

    /**
     * @no-named-arguments
     */
    private function __construct(Maybe $first, Maybe ...$rest)
    {
        $this->first = $first;
        $this->rest = $rest;

    }

    /**
     * @internal
     * @psalm-pure
     * @no-named-arguments
     */
    public static function of(Maybe $first, Maybe ...$rest): self
    {
        return new self($first, ...$rest);
    }

    /**
     * @template T
     *
     * @param callable(...mixed): T $map
     *
     * @return Maybe<T>
     */
    public function map(callable $map): Maybe
    {
        return $this->collapse()->map(static fn(array $args) => $map(...$args));
    }

    /**
     * @template T
     *
     * @param callable(...mixed): Maybe<T> $map
     *
     * @return Maybe<T>
     */
    public function flatMap(callable $map): Maybe
    {
        return $this->collapse()->flatMap(static fn(array $args) => $map(...$args));
    }

    /**
     * @return Maybe<list<mixed>>
     */
    private function collapse(): Maybe
    {
        /**
         * @psalm-suppress MixedArgumentTypeCoercion
         * @var Maybe<list<mixed>>
         */
        return \array_reduce(
            $this->rest,
            static fn(Maybe $carry, Maybe $maybe): Maybe => $carry->flatMap(
                static fn(array $args) => $maybe->map(
                    static fn($value) => \array_merge($args, [$value]),
                ),
            ),
            $this->first->map(static fn($value) => [$value]),
        );
    }
}


1			<?php
2			declare(strict_types = 1);
3
4			namespace Innmind\Immutable\Maybe;
5
6			use Innmind\Immutable\Maybe;
7
8			/**
9			* @psalm-immutable
10			*/
11			final class Comprehension
12			{
13			private Maybe $first;
14			/** @var list<Maybe> */
			0 ignored issues – show Bug introduced 2022-03-26 14:35 UTC by Report Bug Copy Issue Report The type `Innmind\Immutable\Maybe\list` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
15			private array $rest;
16
17			/**
18			* @no-named-arguments
19			*/
20			private function __construct(Maybe $first, Maybe ...$rest)
21			{
22			$this->first = $first;
23			$this->rest = $rest;
			0 ignored issues – show Documentation Bug introduced 2022-03-26 14:35 UTC by Report Bug Copy Issue Report It seems like `$rest` of type `array<integer,Innmind\Immutable\Maybe>` is incompatible with the declared type `Innmind\Immutable\Maybe\list` of property `$rest`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
24			}
25
26			/**
27			* @internal
28			* @psalm-pure
29			* @no-named-arguments
30			*/
31			public static function of(Maybe $first, Maybe ...$rest): self
32			{
33			return new self($first, ...$rest);
34			}
35
36			/**
37			* @template T
38			*
39			* @param callable(...mixed): T $map
40			*
41			* @return Maybe<T>
42			*/
43			public function map(callable $map): Maybe
44			{
45			return $this->collapse()->map(static fn(array $args) => $map(...$args));
46			}
47
48			/**
49			* @template T
50			*
51			* @param callable(...mixed): Maybe<T> $map
52			*
53			* @return Maybe<T>
54			*/
55			public function flatMap(callable $map): Maybe
56			{
57			return $this->collapse()->flatMap(static fn(array $args) => $map(...$args));
58			}
59
60			/**
61			* @return Maybe<list<mixed>>
62			*/
63			private function collapse(): Maybe
64			{
65			/**
66			* @psalm-suppress MixedArgumentTypeCoercion
67			* @var Maybe<list<mixed>>
68			*/
69			return \array_reduce(
70			$this->rest,
71			static fn(Maybe $carry, Maybe $maybe): Maybe => $carry->flatMap(
72			static fn(array $args) => $maybe->map(
73			static fn($value) => \array_merge($args, [$value]),
74			),
75			),
76			$this->first->map(static fn($value) => [$value]),
77			);
78			}
79			}
80

Innmind / Immutable

GitHub Access Token became invalid

Comprehension::collapse() A last analyzed 2022-07-02 13:48 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Comprehension::collapse() A
last analyzed 2022-07-02 13:48 UTC