Merge branch 'develop'

* develop:
  specify next release
  CS
  fix loading an extra element when not necessary
  bump minimum version of static analysis
  fix psalm errors
  use innmind/static-analysis

Author: Baptouuuu

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 5.11.2 - 2025-02-23
+
+### Fixed
+
+- A lazy `Sequence` would load an extra element that is never used when calling `take`
+
 ## 5.11.1 - 2025-01-16
 
 ### Fixed

composer.json

@@ -30,7 +30,7 @@
         }
     },
     "require-dev": {
-        "vimeo/psalm": "~5.6|dev-master",
+        "innmind/static-analysis": "^1.2.1",
         "innmind/black-box": "^5.5.1",
         "innmind/coding-standard": "~2.0"
     },

proofs/sequence.php

@@ -413,4 +413,25 @@ static function($assert, $prefix, $suffix) {
             );
         },
     );
+
+    yield proof(
+        'Sequence::lazy()->take() should not load an extra element',
+        given(
+            Set\Sequence::of(Set\Type::any()),
+        ),
+        static function($assert, $values) {
+            $sequence = Sequence::lazy(static function() use ($values) {
+                yield from $values;
+
+                throw new Exception;
+            })->take(\count($values));
+
+            $assert->not()->throws(
+                static fn() => $assert->same(
+                    $values,
+                    $sequence->toList(),
+                ),
+            );
+        },
+    );
 };

src/Accumulate.php

@@ -31,6 +31,7 @@ public function __construct(\Generator $generator)
     /**
      * @return S
      */
+    #[\Override]
     public function current(): mixed
     {
         /** @psalm-suppress InaccessibleProperty */
@@ -45,6 +46,7 @@ public function current(): mixed
     /**
      * @return int<0, max>|null
      */
+    #[\Override]
     public function key(): ?int
     {
         /** @psalm-suppress InaccessibleProperty */
@@ -55,6 +57,7 @@ public function key(): ?int
         return \key($this->values);
     }
 
+    #[\Override]
     public function next(): void
     {
         /** @psalm-suppress InaccessibleProperty */
@@ -68,6 +71,7 @@ public function next(): void
         }
     }
 
+    #[\Override]
     public function rewind(): void
     {
         /** @psalm-suppress InaccessibleProperty */
@@ -76,6 +80,7 @@ public function rewind(): void
         \reset($this->values);
     }
 
+    #[\Override]
     public function valid(): bool
     {
         /** @psalm-suppress InaccessibleProperty */

src/Attempt/Defer.php

@@ -30,39 +30,45 @@ public function __construct(callable $deferred)
         $this->deferred = $deferred;
     }
 
+    #[\Override]
     public function map(callable $map): self
     {
         $captured = $this->capture();
 
         return new self(static fn() => self::detonate($captured)->map($map));
     }
 
+    #[\Override]
     public function flatMap(callable $map): Attempt
     {
         $captured = $this->capture();
 
         return Attempt::defer(static fn() => self::detonate($captured)->flatMap($map));
     }
 
+    #[\Override]
     public function match(callable $result, callable $error)
     {
         return $this->unwrap()->match($result, $error);
     }
 
+    #[\Override]
     public function recover(callable $recover): Attempt
     {
         $captured = $this->capture();
 
         return Attempt::defer(static fn() => self::detonate($captured)->recover($recover));
     }
 
+    #[\Override]
     public function maybe(): Maybe
     {
         $captured = $this->capture();
 
         return Maybe::defer(static fn() => self::detonate($captured)->maybe());
     }
 
+    #[\Override]
     public function either(): Either
     {
         $captured = $this->capture();
@@ -73,6 +79,7 @@ public function either(): Either
     /**
      * @return Attempt<R1>
      */
+    #[\Override]
     public function memoize(): Attempt
     {
         return $this->unwrap();

src/Attempt/Error.php

@@ -29,34 +29,40 @@ public function __construct(
      *
      * @return self<T>
      */
+    #[\Override]
     public function map(callable $map): self
     {
         /** @var self<T> */
         return $this;
     }
 
+    #[\Override]
     public function flatMap(callable $map): Attempt
     {
         return Attempt::error($this->value);
     }
 
+    #[\Override]
     public function match(callable $result, callable $error)
     {
         /** @psalm-suppress ImpureFunctionCall */
         return $error($this->value);
     }
 
+    #[\Override]
     public function recover(callable $recover): Attempt
     {
         /** @psalm-suppress ImpureFunctionCall */
         return $recover($this->value);
     }
 
+    #[\Override]
     public function maybe(): Maybe
     {
         return Maybe::nothing();
     }
 
+    #[\Override]
     public function either(): Either
     {
         return Either::left($this->value);
@@ -65,6 +71,7 @@ public function either(): Either
     /**
      * @return Attempt<R1>
      */
+    #[\Override]
     public function memoize(): Attempt
     {
         return Attempt::error($this->value);

src/Attempt/Result.php

@@ -25,34 +25,40 @@ public function __construct(
     ) {
     }
 
+    #[\Override]
     public function map(callable $map): self
     {
         /** @psalm-suppress ImpureFunctionCall */
         return new self($map($this->value));
     }
 
+    #[\Override]
     public function flatMap(callable $map): Attempt
     {
         /** @psalm-suppress ImpureFunctionCall */
         return $map($this->value);
     }
 
+    #[\Override]
     public function match(callable $result, callable $error)
     {
         /** @psalm-suppress ImpureFunctionCall */
         return $result($this->value);
     }
 
+    #[\Override]
     public function recover(callable $recover): Attempt
     {
         return Attempt::result($this->value);
     }
 
+    #[\Override]
     public function maybe(): Maybe
     {
         return Maybe::just($this->value);
     }
 
+    #[\Override]
     public function either(): Either
     {
         return Either::right($this->value);
@@ -61,6 +67,7 @@ public function either(): Either
     /**
      * @return Attempt<R1>
      */
+    #[\Override]
     public function memoize(): Attempt
     {
         return Attempt::result($this->value);

src/Either/Defer.php

@@ -30,46 +30,53 @@ public function __construct($deferred)
         $this->deferred = $deferred;
     }
 
+    #[\Override]
     public function map(callable $map): self
     {
         $captured = $this->capture();
 
         return new self(static fn() => self::detonate($captured)->map($map));
     }
 
+    #[\Override]
     public function flatMap(callable $map): Either
     {
         $captured = $this->capture();
 
         return Either::defer(static fn() => self::detonate($captured)->flatMap($map));
     }
 
+    #[\Override]
     public function leftMap(callable $map): self
     {
         $captured = $this->capture();
 
         return new self(static fn() => self::detonate($captured)->leftMap($map));
     }
 
+    #[\Override]
     public function match(callable $right, callable $left)
     {
         return $this->unwrap()->match($right, $left);
     }
 
+    #[\Override]
     public function otherwise(callable $otherwise): Either
     {
         $captured = $this->capture();
 
         return Either::defer(static fn() => self::detonate($captured)->otherwise($otherwise));
     }
 
+    #[\Override]
     public function filter(callable $predicate, callable $otherwise): Implementation
     {
         $captured = $this->capture();
 
         return new self(static fn() => self::detonate($captured)->filter($predicate, $otherwise));
     }
 
+    #[\Override]
     public function maybe(): Maybe
     {
         $captured = $this->capture();
@@ -80,18 +87,21 @@ public function maybe(): Maybe
     /**
      * @return Either<L1, R1>
      */
+    #[\Override]
     public function memoize(): Either
     {
         return $this->unwrap();
     }
 
+    #[\Override]
     public function flip(): self
     {
         $captured = $this->capture();
 
         return new self(static fn() => self::detonate($captured)->flip());
     }
 
+    #[\Override]
     public function eitherWay(callable $right, callable $left): Either
     {
         $captured = $this->capture();

src/Either/Left.php

@@ -35,40 +35,47 @@ public function __construct($value)
      *
      * @return self<L1, T>
      */
+    #[\Override]
     public function map(callable $map): self
     {
         /** @var self<L1, T> */
         return $this;
     }
 
+    #[\Override]
     public function flatMap(callable $map): Either
     {
         return Either::left($this->value);
     }
 
+    #[\Override]
     public function leftMap(callable $map): self
     {
         /** @psalm-suppress ImpureFunctionCall */
         return new self($map($this->value));
     }
 
+    #[\Override]
     public function match(callable $right, callable $left)
     {
         /** @psalm-suppress ImpureFunctionCall */
         return $left($this->value);
     }
 
+    #[\Override]
     public function otherwise(callable $otherwise): Either
     {
         /** @psalm-suppress ImpureFunctionCall */
         return $otherwise($this->value);
     }
 
+    #[\Override]
     public function filter(callable $predicate, callable $otherwise): self
     {
         return $this;
     }
 
+    #[\Override]
     public function maybe(): Maybe
     {
         return Maybe::nothing();
@@ -77,16 +84,19 @@ public function maybe(): Maybe
     /**
      * @return Either<L1, R1>
      */
+    #[\Override]
     public function memoize(): Either
     {
         return Either::left($this->value);
     }
 
+    #[\Override]
     public function flip(): Implementation
     {
         return new Right($this->value);
     }
 
+    #[\Override]
     public function eitherWay(callable $right, callable $left): Either
     {
         /** @psalm-suppress ImpureFunctionCall */