fixed static typing when working with transforming methods

Author: transistive

src/Types/AbstractCypherSequence.php

@@ -23,30 +23,24 @@
 /**
  * Abstract immutable sequence with basic functional methods.
  *
- * @template TKey of array-key
  * @template TValue
+ * @template TKey of array-key
  *
  * @extends AbstractCypherObject<TKey, TValue>
  *
  * @psalm-immutable
+ *
+ * @psalm-suppress UnsafeInstantiation
  */
 abstract class AbstractCypherSequence extends AbstractCypherObject implements Countable
 {
     /** @var array<TKey, TValue> */
-    protected array $sequence;
+    protected array $sequence = [];
 
     /**
-     * Creates a new instance from the given iterable.
-     *
-     * @template Value
-     *
-     * @param iterable<Value> $iterable
-     *
-     * @return static
-     *
-     * @pure
+     * @param iterable<TKey, TValue> $iterable
      */
-    abstract public static function fromIterable(iterable $iterable): self;
+    abstract public function __construct(iterable $iterable);
 
     final public function count(): int
     {
@@ -56,14 +50,14 @@ final public function count(): int
     /**
      * Copies the sequence.
      *
-     * @return static
+     * @return static<TValue, TKey>
      */
     final public function copy(): self
     {
         // Make sure the sequence is actually copied by reassigning it.
         $map = $this->sequence;
 
-        return $this::fromIterable($map);
+        return new static($map);
     }
 
     /**
@@ -89,7 +83,7 @@ final public function toArray(): array
      *
      * @param iterable<array-key, TValue> $values
      *
-     * @return static
+     * @return static<TValue, TKey>
      */
     abstract public function merge(iterable $values): self;
 
@@ -116,48 +110,50 @@ final public function hasValue($value): bool
     /**
      * Creates a filtered the sequence with the provided callback.
      *
-     * @param pure-callable(TValue, TKey):bool $callback
+     * @param callable(TValue, TKey):bool $callback
      *
-     * @return static
+     * @return static<TValue, TKey>
      */
     final public function filter(callable $callback): self
     {
+        /** @var array<TKey, TValue> $tbr */
         $tbr = [];
         foreach ($this->sequence as $key => $value) {
             if ($callback($value, $key)) {
                 $tbr[$key] = $value;
             }
         }
 
-        return $this::fromIterable($tbr);
+        return new static($tbr);
     }
 
     /**
      * Maps the values of this sequence to a new one with the provided callback.
      *
-     * @template U
+     * @template ReturnType
      *
-     * @param pure-callable(TValue, TKey):U $callback
+     * @param callable(TValue, TKey):ReturnType $callback
      *
-     * @return static
+     * @return static<ReturnType, TKey>
      */
     final public function map(callable $callback): self
     {
+        /** @var array<TKey, ReturnType> $tbr */
         $tbr = [];
         foreach ($this->sequence as $key => $value) {
             $tbr[$key] = $callback($value, $key);
         }
 
-        return $this::fromIterable($tbr);
+        return new static($tbr);
     }
 
     /**
      * Reduces this sequence with the given callback.
      *
      * @template TInitial
      *
-     * @param pure-callable(TInitial|null, TValue, TKey):TInitial $callback
-     * @param TInitial|null                                       $initial
+     * @param callable(TInitial|null, TValue, TKey):TInitial $callback
+     * @param TInitial|null                                  $initial
      *
      * @return TInitial
      */
@@ -185,24 +181,24 @@ final public function find($value)
     /**
      * Creates a reversed sequence.
      *
-     * @return static
+     * @return static<TValue, TKey>
      */
     abstract public function reversed(): self;
 
     /**
      * Slices a new sequence starting from the given offset with a certain length.
      * If the length is null it will slice the entire remainder starting from the offset.
      *
-     * @return static
+     * @return static<TValue, TKey>
      */
     abstract public function slice(int $offset, int $length = null): self;
 
     /**
      * Creates a sorted sequence. If the compoarator is null it will use natural ordering.
      *
-     * @param (pure-callable(TValue, TValue):int)|null $comparator
+     * @param (callable(TValue, TValue):int)|null $comparator
      *
-     * @return static
+     * @return static<TValue, TKey>
      */
     abstract public function sorted(?callable $comparator = null): self;
 

src/Types/ArrayList.php

@@ -29,14 +29,16 @@
  *
  * @template TValue
  *
- * @extends AbstractCypherSequence<int, TValue>
+ * @extends AbstractCypherSequence<TValue, int>
  *
  * @psalm-immutable
+ *
+ * @psalm-suppress UnsafeGenericInstantiation
  */
 class ArrayList extends AbstractCypherSequence
 {
     /**
-     * @param iterable<TValue> $iterable
+     * @param iterable<mixed, TValue> $iterable
      */
     final public function __construct(iterable $iterable = [])
     {
@@ -92,27 +94,27 @@ public function merge($values): ArrayList
             $tbr[] = $value;
         }
 
-        return static::fromIterable($tbr);
+        return new static($tbr);
     }
 
     /**
      * @return static<TValue>
      */
     public function reversed(): ArrayList
     {
-        return static::fromIterable(array_reverse($this->sequence));
+        return new static(array_reverse($this->sequence));
     }
 
     /**
      * @return static<TValue>
      */
     public function slice(int $offset, int $length = null): ArrayList
     {
-        return static::fromIterable(array_slice($this->sequence, $offset, $length));
+        return new static(array_slice($this->sequence, $offset, $length));
     }
 
     /**
-     * @param (pure-callable(TValue, TValue):int)|null $comparator
+     * @param (callable(TValue, TValue):int)|null $comparator
      *
      * @return static<TValue>
      */
@@ -122,18 +124,11 @@ public function sorted(callable $comparator = null): ArrayList
         if ($comparator === null) {
             sort($tbr);
         } else {
+            /** @psalm-suppress ImpureFunctionCall */
             usort($tbr, $comparator);
         }
 
-        return static::fromIterable($tbr);
-    }
-
-    /**
-     * @pure
-     */
-    public static function fromIterable(iterable $iterable): AbstractCypherSequence
-    {
-        return new static($iterable);
+        return new static($tbr);
     }
 
     /**
@@ -235,7 +230,7 @@ public function getAsMap(int $key): Map
             throw new RuntimeTypeException($value, Map::class);
         }
 
-        return Map::fromIterable($value);
+        return new Map($value);
     }
 
     /**
@@ -248,6 +243,21 @@ public function getAsArrayList(int $key): ArrayList
             throw new RuntimeTypeException($value, ArrayList::class);
         }
 
-        return ArrayList::fromIterable($value);
+        return new ArrayList($value);
+    }
+
+    /**
+     * @template Value
+     *
+     * @param iterable<Value> $iterable
+     *
+     * @return static<Value>
+     *
+     * @pure
+     */
+    public static function fromIterable(iterable $iterable): ArrayList
+    {
+        /** @psalm-suppress UnsafeGenericInstantiation */
+        return new static($iterable);
     }
 }