Merge branch 'develop'

* develop:
  specify next release
  add Sequence::zip()
  Fix third value

Author: Baptouuuu

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 4.5.0 - 2022-09-18
+
+### Added
+
+- `Innmind\Immutable\Sequence::zip()`
+
 ## 4.4.0 - 2022-07-14
 
 ### Added

docs/MONOIDS.md

@@ -2,7 +2,7 @@
 
 Monoids describe a way to combine two values of a given type. A monoid contains an identity value that when combined with another value doesn't change its value. The combine operation has to be associative meaning `combine(a, combine(b, c))` is the same as `combine(combine(a, b), c)`.
 
-A simple monoid is an addition because adding `0` (the identity value) to any other integer won't change the value and `add(1, add(2, 3))` is the the same result as `add(add(1, 2), 6)` (both return 6).
+A simple monoid is an addition because adding `0` (the identity value) to any other integer won't change the value and `add(1, add(2, 3))` is the the same result as `add(add(1, 2), 3)` (both return 6).
 
 This library comes with a few monoids:
 - `Innmind\Immutable\Monoid\Concat` to append 2 instances of `Innmind\Immutable\Str` together

docs/SEQUENCE.md

@@ -456,3 +456,17 @@ $result; // 10
 ```
 
 **Important**: for lasy sequences bear in mind that the values will be kept in memory while the first call to `->match` didn't return.
+
+## `->zip()`
+
+This method allows to merge 2 sequences into a new one by combining the values of the 2 into pairs.
+
+```php
+$firnames = Sequence::of('John', 'Luke', 'James');
+$lastnames = Sequence::of('Doe', 'Skywalker', 'Kirk');
+
+$pairs = $firnames
+    ->zip($lastnames)
+    ->toList();
+$pairs; // [['John', 'Doe'], ['Luke', 'Skywalker'], ['James', 'Kirk']]
+```

src/Sequence.php

@@ -593,4 +593,19 @@ public function any(callable $predicate): bool
             static fn() => false,
         );
     }
+
+    /**
+     * If both sequences are not of the same length it will stop when it has
+     * reached the end of the shortest of the two
+     *
+     * @template S
+     *
+     * @param self<S> $sequence
+     *
+     * @return self<array{T, S}>
+     */
+    public function zip(self $sequence): self
+    {
+        return new self($this->implementation->zip($sequence->implementation));
+    }
 }

src/Sequence/Defer.php

@@ -578,6 +578,31 @@ public function match(callable $wrap, callable $match, callable $empty)
             );
     }
 
+    /**
+     * @template S
+     *
+     * @param Implementation<S> $sequence
+     *
+     * @return Implementation<array{T, S}>
+     */
+    public function zip(Implementation $sequence): Implementation
+    {
+        /** @var Implementation<array{T, S}> */
+        return new self(
+            (static function(\Iterator $self, \Iterator $other) {
+                /** @var \Iterator<T> $self */
+                foreach ($self as $value) {
+                    if (!$other->valid()) {
+                        return;
+                    }
+
+                    yield [$value, $other->current()];
+                    $other->next();
+                }
+            })($this->values, $sequence->iterator()),
+        );
+    }
+
     /**
      * @return Implementation<T>
      */

src/Sequence/Implementation.php

@@ -284,4 +284,13 @@ public function find(callable $predicate): Maybe;
      * @return R
      */
     public function match(callable $wrap, callable $match, callable $empty);
+
+    /**
+     * @template S
+     *
+     * @param self<S> $sequence
+     *
+     * @return self<array{T, S}>
+     */
+    public function zip(self $sequence): self;
 }

src/Sequence/Lazy.php

@@ -648,6 +648,35 @@ public function match(callable $wrap, callable $match, callable $empty)
         return (new Defer($generator))->match($wrap, $match, $empty);
     }
 
+    /**
+     * @template S
+     *
+     * @param Implementation<S> $sequence
+     *
+     * @return Implementation<array{T, S}>
+     */
+    public function zip(Implementation $sequence): Implementation
+    {
+        $values = $this->values;
+
+        /** @var Implementation<array{T, S}> */
+        return new self(
+            static function(callable $registerCleanup) use ($values, $sequence) {
+                /** @var RegisterCleanup $registerCleanup */
+                $other = self::open($sequence, $registerCleanup);
+
+                foreach ($values($registerCleanup) as $value) {
+                    if (!$other->valid()) {
+                        return;
+                    }
+
+                    yield [$value, $other->current()];
+                    $other->next();
+                }
+            },
+        );
+    }
+
     /**
      * @return Implementation<T>
      */

src/Sequence/Primitive.php

@@ -451,6 +451,35 @@ public function match(callable $wrap, callable $match, callable $empty)
             );
     }
 
+    /**
+     * @template S
+     *
+     * @param Implementation<S> $sequence
+     *
+     * @return Implementation<array{T, S}>
+     */
+    public function zip(Implementation $sequence): Implementation
+    {
+        /** @var list<array{T, S}> */
+        $values = [];
+        $other = $sequence->iterator();
+
+        foreach ($this->iterator() as $value) {
+            /** @psalm-suppress ImpureMethodCall */
+            if (!$other->valid()) {
+                break;
+            }
+
+            /** @psalm-suppress ImpureMethodCall */
+            $values[] = [$value, $other->current()];
+            /** @psalm-suppress ImpureMethodCall */
+            $other->next();
+        }
+
+        /** @var Implementation<array{T, S}> */
+        return new self($values);
+    }
+
     private function has(int $index): bool
     {
         return \array_key_exists($index, $this->values);

tests/SequenceTest.php

@@ -833,6 +833,148 @@ public function testFold()
         $this->assertSame('bazfoobar', $str->toString());
     }
 
+    public function testZip()
+    {
+        $zipped = Sequence::of(0, 1, 2, 3)->zip(
+            Sequence::of('a', 'b', 'c', 'd'),
+        );
+
+        $this->assertSame(
+            [[0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']],
+            $zipped->toList(),
+        );
+
+        $zipped = Sequence::defer((static function() {
+            yield 0;
+            yield 1;
+            yield 2;
+            yield 3;
+        })())->zip(
+            Sequence::defer((static function() {
+                yield 'a';
+                yield 'b';
+                yield 'c';
+                yield 'd';
+            })()),
+        );
+
+        $this->assertSame(
+            [[0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']],
+            $zipped->toList(),
+        );
+
+        $zipped = Sequence::lazy(static function() {
+            yield 0;
+            yield 1;
+            yield 2;
+            yield 3;
+        })->zip(
+            Sequence::lazy(static function() {
+                yield 'a';
+                yield 'b';
+                yield 'c';
+                yield 'd';
+            }),
+        );
+
+        $this->assertSame(
+            [[0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']],
+            $zipped->toList(),
+        );
+    }
+
+    public function testZipOfDifferentLengths()
+    {
+        $zipped = Sequence::of(0, 1, 2)->zip(
+            Sequence::of('a', 'b', 'c', 'd'),
+        );
+
+        $this->assertSame(
+            [[0, 'a'], [1, 'b'], [2, 'c']],
+            $zipped->toList(),
+        );
+        $zipped = Sequence::of(0, 1, 2, 3)->zip(
+            Sequence::of('a', 'b', 'c'),
+        );
+
+        $this->assertSame(
+            [[0, 'a'], [1, 'b'], [2, 'c']],
+            $zipped->toList(),
+        );
+
+        $zipped = Sequence::defer((static function() {
+            yield 0;
+            yield 1;
+            yield 2;
+        })())->zip(
+            Sequence::defer((static function() {
+                yield 'a';
+                yield 'b';
+                yield 'c';
+                yield 'd';
+            })()),
+        );
+
+        $this->assertSame(
+            [[0, 'a'], [1, 'b'], [2, 'c']],
+            $zipped->toList(),
+        );
+
+        $zipped = Sequence::defer((static function() {
+            yield 0;
+            yield 1;
+            yield 2;
+            yield 3;
+        })())->zip(
+            Sequence::defer((static function() {
+                yield 'a';
+                yield 'b';
+                yield 'c';
+            })()),
+        );
+
+        $this->assertSame(
+            [[0, 'a'], [1, 'b'], [2, 'c']],
+            $zipped->toList(),
+        );
+
+        $zipped = Sequence::lazy(static function() {
+            yield 0;
+            yield 1;
+            yield 2;
+        })->zip(
+            Sequence::lazy(static function() {
+                yield 'a';
+                yield 'b';
+                yield 'c';
+                yield 'd';
+            }),
+        );
+
+        $this->assertSame(
+            [[0, 'a'], [1, 'b'], [2, 'c']],
+            $zipped->toList(),
+        );
+
+        $zipped = Sequence::lazy(static function() {
+            yield 0;
+            yield 1;
+            yield 2;
+            yield 3;
+        })->zip(
+            Sequence::lazy(static function() {
+                yield 'a';
+                yield 'b';
+                yield 'c';
+            }),
+        );
+
+        $this->assertSame(
+            [[0, 'a'], [1, 'b'], [2, 'c']],
+            $zipped->toList(),
+        );
+    }
+
     public function get($map, $index)
     {
         return $map->get($index)->match(