Fix psalm errors

composer.json

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

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 */