Merge branch 'develop'

* develop: specify next release test against php 8.2 support lazy and deferred Set flatMap expose the implementation of the flatmap
Innmind · Dec 17, 2022 · 2f1ebbd · 2f1ebbd
2 parents 8de9051 + 675092a
commit 2f1ebbd
Show file tree

Hide file tree

Showing 13 changed files with 123 additions and 35 deletions.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -8,7 +8,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macOS-latest]
-        php-version: ['8.0', '8.1']
+        php-version: ['8.0', '8.1', '8.2']
     name: 'PHPUnit'
     steps:
       - name: Checkout
@@ -30,7 +30,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macOS-latest]
-        php-version: ['8.0', '8.1']
+        php-version: ['8.0', '8.1', '8.2']
     name: 'Coverage'
     steps:
       - name: Checkout
@@ -54,7 +54,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        php-version: ['8.0', '8.1']
+        php-version: ['8.0', '8.1', '8.2']
     name: 'Psalm'
     steps:
       - name: Checkout

diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## 4.9.0 - 2022-12-17
+
+### Changed
+
+- Support lazy and deferred `Set::flatMap()`
+
 ## 4.8.0 - 2022-12-11
 
 ### Added

diff --git a/src/Sequence.php b/src/Sequence.php
@@ -411,7 +411,7 @@ public function flatMap(callable $map): self
         /** @var callable(self<S>): Sequence\Implementation<S> */
         $exfiltrate = static fn(self $sequence): Sequence\Implementation => $sequence->implementation;
 
-        return $this->implementation->flatMap($map, $exfiltrate);
+        return new self($this->implementation->flatMap($map, $exfiltrate));
     }
 
     /**

diff --git a/src/Sequence/Defer.php b/src/Sequence/Defer.php
@@ -327,22 +327,23 @@ public function map(callable $function): Implementation
 
     /**
      * @template S
+     * @template C of Sequence<S>|Set<S>
      *
-     * @param callable(T): Sequence<S> $map
-     * @param callable(Sequence<S>): Implementation<S> $exfiltrate
+     * @param callable(T): C $map
+     * @param callable(C): Implementation<S> $exfiltrate
      *
-     * @return Sequence<S>
+     * @return self<S>
      */
-    public function flatMap(callable $map, callable $exfiltrate): Sequence
+    public function flatMap(callable $map, callable $exfiltrate): self
     {
         /** @psalm-suppress ImpureFunctionCall */
-        return Sequence::defer(
+        return new self(
             (static function(\Iterator $values, callable $map, callable $exfiltrate): \Generator {
                 /** @var T $value */
                 foreach ($values as $value) {
                     /**
-                     * @var callable(T): Sequence<S> $map
-                     * @var callable(Sequence<S>): Implementation<S> $exfiltrate
+                     * @var callable(T): C $map
+                     * @var callable(C): Implementation<S> $exfiltrate
                      */
                     foreach ($exfiltrate($map($value))->iterator() as $inner) {
                         yield $inner;

diff --git a/src/Sequence/Implementation.php b/src/Sequence/Implementation.php
@@ -164,13 +164,14 @@ public function map(callable $function): self;
 
     /**
      * @template S
+     * @template C of Sequence<S>|Set<S>
      *
-     * @param callable(T): Sequence<S> $map
-     * @param callable(Sequence<S>): self<S> $exfiltrate
+     * @param callable(T): C $map
+     * @param callable(C): self<S> $exfiltrate
      *
-     * @return Sequence<S>
+     * @return self<S>
      */
-    public function flatMap(callable $map, callable $exfiltrate): Sequence;
+    public function flatMap(callable $map, callable $exfiltrate): self;
 
     /**
      * Pad the sequence to a defined size with the given element

diff --git a/src/Sequence/Lazy.php b/src/Sequence/Lazy.php
@@ -352,17 +352,18 @@ static function(callable $registerCleanup) use ($values, $function): \Generator
 
     /**
      * @template S
+     * @template C of Sequence<S>|Set<S>
      *
-     * @param callable(T): Sequence<S> $map
-     * @param callable(Sequence<S>): Implementation<S> $exfiltrate
+     * @param callable(T): C $map
+     * @param callable(C): Implementation<S> $exfiltrate
      *
-     * @return Sequence<S>
+     * @return self<S>
      */
-    public function flatMap(callable $map, callable $exfiltrate): Sequence
+    public function flatMap(callable $map, callable $exfiltrate): self
     {
         $values = $this->values;
 
-        return Sequence::lazy(
+        return new self(
             static function(callable $registerCleanup) use ($values, $map, $exfiltrate): \Generator {
                 foreach ($values($registerCleanup) as $value) {
                     $generator = self::open(

diff --git a/src/Sequence/Primitive.php b/src/Sequence/Primitive.php
@@ -256,21 +256,24 @@ public function map(callable $function): self
 
     /**
      * @template S
+     * @template C of Sequence<S>|Set<S>
      *
-     * @param callable(T): Sequence<S> $map
-     * @param callable(Sequence<S>): Implementation<S> $exfiltrate
+     * @param callable(T): C $map
+     * @param callable(C): Implementation<S> $exfiltrate
      *
-     * @return Sequence<S>
+     * @return Implementation<S>
      */
-    public function flatMap(callable $map, callable $exfiltrate): Sequence
+    public function flatMap(callable $map, callable $exfiltrate): Implementation
     {
         /**
          * @psalm-suppress MixedArgument
-         * @var Sequence<S>
+         * @psalm-suppress InvalidArgument
+         * @psalm-suppress ImpureFunctionCall
+         * @var Implementation<S>
          */
         return $this->reduce(
-            Sequence::of(),
-            static fn(Sequence $carry, $value) => $carry->append($map($value)),
+            new self,
+            static fn(self $carry, $value) => $carry->append($exfiltrate($map($value))),
         );
     }
 

diff --git a/src/Set.php b/src/Set.php
@@ -333,14 +333,10 @@ public function map(callable $function): self
      */
     public function flatMap(callable $map): self
     {
-        /**
-         * @psalm-suppress InvalidArgument
-         * @psalm-suppress MixedArgument
-         */
-        return $this->reduce(
-            self::of(),
-            static fn(self $carry, $value) => $carry->merge($map($value)),
-        );
+        /** @var callable(self<S>): Sequence\Implementation<S> */
+        $exfiltrate = static fn(self $set): Sequence\Implementation => $set->implementation->sequence();
+
+        return new self($this->implementation->flatMap($map, $exfiltrate));
     }
 
     /**

diff --git a/src/Set/Defer.php b/src/Set/Defer.php
@@ -173,6 +173,19 @@ public function map(callable $function): self
         return self::distinct($this->values->map($function));
     }
 
+    /**
+     * @template S
+     *
+     * @param callable(T): Set<S> $map
+     * @param callable(Set<S>): Sequence\Implementation<S> $exfiltrate
+     *
+     * @return self<S>
+     */
+    public function flatMap(callable $map, callable $exfiltrate): self
+    {
+        return self::distinct($this->values->flatMap($map, $exfiltrate));
+    }
+
     /**
      * @param callable(T): bool $predicate
      *

diff --git a/src/Set/Implementation.php b/src/Set/Implementation.php
@@ -117,6 +117,16 @@ public function groupBy(callable $discriminator): Map;
      */
     public function map(callable $function): self;
 
+    /**
+     * @template S
+     *
+     * @param callable(T): Set<S> $map
+     * @param callable(Set<S>): Sequence\Implementation<S> $exfiltrate
+     *
+     * @return self<S>
+     */
+    public function flatMap(callable $map, callable $exfiltrate): self;
+
     /**
      * Return a sequence of 2 sets partitioned according to the given predicate
      *

diff --git a/src/Set/Lazy.php b/src/Set/Lazy.php
@@ -174,6 +174,19 @@ public function map(callable $function): self
         return self::distinct($this->values->map($function));
     }
 
+    /**
+     * @template S
+     *
+     * @param callable(T): Set<S> $map
+     * @param callable(Set<S>): Sequence\Implementation<S> $exfiltrate
+     *
+     * @return self<S>
+     */
+    public function flatMap(callable $map, callable $exfiltrate): self
+    {
+        return self::distinct($this->values->flatMap($map, $exfiltrate));
+    }
+
     /**
      * @param callable(T): bool $predicate
      *

diff --git a/src/Set/Primitive.php b/src/Set/Primitive.php
@@ -177,6 +177,24 @@ public function map(callable $function): self
         return new self($this->values->map($function)->distinct());
     }
 
+    /**
+     * @template S
+     *
+     * @param callable(T): Set<S> $map
+     * @param callable(Set<S>): Sequence\Implementation<S> $exfiltrate
+     *
+     * @return Implementation<S>
+     */
+    public function flatMap(callable $map, callable $exfiltrate): Implementation
+    {
+        return new self(
+            $this
+                ->values
+                ->flatMap($map, $exfiltrate)
+                ->distinct(),
+        );
+    }
+
     /**
      * @param callable(T): bool $predicate
      *

diff --git a/tests/SetTest.php b/tests/SetTest.php
@@ -302,6 +302,32 @@ public function testFlatMap()
         $this->assertNotSame($set, $set2);
         $this->assertSame([1, 2, 3, 4], $set->toList());
         $this->assertSame([1, 3, 2, 4, 5, 6], $set2->toList());
+
+        $loaded = false;
+        $set = Set::lazy(static function() use (&$loaded) {
+            yield 1;
+            yield 2;
+            yield 3;
+            $loaded = true;
+        })->flatMap(static fn($i) => Set::of($i, $i + 1));
+
+        $this->assertInstanceOf(Set::class, $set);
+        $this->assertFalse($loaded);
+        $this->assertSame([1, 2, 3, 4], $set->toList());
+        $this->assertTrue($loaded);
+
+        $loaded = false;
+        $set = Set::defer((static function() use (&$loaded) {
+            yield 1;
+            yield 2;
+            yield 3;
+            $loaded = true;
+        })())->flatMap(static fn($i) => Set::of($i, $i + 1));
+
+        $this->assertInstanceOf(Set::class, $set);
+        $this->assertFalse($loaded);
+        $this->assertSame([1, 2, 3, 4], $set->toList());
+        $this->assertTrue($loaded);
     }
 
     public function testPartition()