Modifying map to allow only key transform

Author: TheCelavi

src/RunOpenCode/Component/Dataset/src/Operator/Map.php

@@ -6,15 +6,18 @@
 
 use RunOpenCode\Component\Dataset\AbstractStream;
 use RunOpenCode\Component\Dataset\Contract\OperatorInterface;
+use RunOpenCode\Component\Dataset\Exception\LogicException;
 
 /**
  * Map operator.
  *
  * Map operator iterates over given collection and yields transformed items.
  *
- * User must provide a callable to transform each item value. Additionally,
- * user may provide a callable to transform each item key. If key transform
- * callable is not provided, original keys are preserved.
+ * User must provide a callable to transform each item value, or callable to
+ * transform each item key, or both.
+ *
+ * Where transforming function is not provided, original values will be
+ * preserved.
  *
  * Example usage:
  *
@@ -47,18 +50,22 @@ final class Map extends AbstractStream implements OperatorInterface
     private readonly \Closure $keyTransform;
 
     /**
-     * @param iterable<TKey, TValue>    $collection     Collection to iterate over.
-     * @param ValueTransformCallable    $valueTransform User defined callable to transform item values.
-     * @param KeyTransformCallable|null $keyTransform   User defined callable to transform item keys. If null, original keys are preserved.
+     * @param iterable<TKey, TValue>      $collection     Collection to iterate over.
+     * @param ValueTransformCallable|null $valueTransform User defined callable to transform item values. If null, original values are preserved.
+     * @param KeyTransformCallable|null   $keyTransform   User defined callable to transform item keys. If null, original keys are preserved.
      */
     public function __construct(
         private readonly iterable $collection,
-        callable                  $valueTransform,
+        ?callable                 $valueTransform = null,
         ?callable                 $keyTransform = null
     ) {
+        if (null === $valueTransform && null === $keyTransform) {
+            throw new LogicException('At least one transforming function must be provided, either for key or for value.');
+        }
+
         parent::__construct($this->collection);
-        $this->valueTransform = $valueTransform(...);
-        $this->keyTransform   = ($keyTransform ?? static fn($key, $value): mixed => $key)(...);
+        $this->valueTransform = ($valueTransform ?? static fn(mixed $value, mixed $key): mixed => $value)(...);
+        $this->keyTransform   = ($keyTransform ?? static fn(mixed $key, mixed $value): mixed => $key)(...);
     }
 
     /**

src/RunOpenCode/Component/Dataset/src/functions.php

@@ -236,18 +236,18 @@ function if_empty(iterable $collection, \Exception|callable $action): Stream
  * @template TModifiedKey
  * @template TModifiedValue
  *
- * @param iterable<TKey, TValue>                     $collection     Collection to iterate over.
- * @param callable(TValue, TKey=): TModifiedValue    $valueTransform User defined callable to be called on each item.
- * @param callable(TKey, TValue=): TModifiedKey|null $keyTransform   User defined callable to be called on each item key. If null, original keys are preserved.
+ * @param iterable<TKey, TValue>                       $collection     Collection to iterate over.
+ * @param callable(TValue, TKey=): TModifiedValue|null $valueTransform User defined callable to be called on each item. If null, original values are preserved.
+ * @param callable(TKey, TValue=): TModifiedKey|null   $keyTransform   User defined callable to be called on each item key. If null, original keys are preserved.
  *
- * @return Stream<($keyTransform is null ? TModifiedKey : TKey), TModifiedValue>
+ * @return Stream<($keyTransform is null ? TKey : TModifiedKey), ($valueTransform is null ? TValue : TModifiedValue)>
  *
  * @see Operator\Map
  */
-function map(iterable $collection, callable $valueTransform, ?callable $keyTransform = null): Stream
+function map(iterable $collection, ?callable $valueTransform = null, ?callable $keyTransform = null): Stream
 {
     /**
-     * @var StreamInterface<($keyTransform is null ? TKey : TModifiedKey), TModifiedValue> $map
+     * @var StreamInterface<($keyTransform is null ? TKey : TModifiedKey), ($valueTransform is null ? TValue : TModifiedValue)> $map
      */
     $map = new Operator\Map($collection, $valueTransform, $keyTransform);
 

src/RunOpenCode/Component/Dataset/tests/Operator/MapTest.php

@@ -6,20 +6,21 @@
 
 use PHPUnit\Framework\Attributes\Test;
 use PHPUnit\Framework\TestCase;
+use RunOpenCode\Component\Dataset\Exception\LogicException;
 
 use function RunOpenCode\Component\Dataset\map;
 
 final class MapTest extends TestCase
 {
     #[Test]
-    public function maps(): void
+    public function map(): void
     {
         $operator = map(
             [
-            'a' => 1,
-            'b' => 2,
-            'c' => 3,
-        ],
+                'a' => 1,
+                'b' => 2,
+                'c' => 3,
+            ],
             static fn(int $value): int => $value * 2,
             static fn(string $key): string => \sprintf('mapped_%s', $key),
         );
@@ -30,4 +31,54 @@ public function maps(): void
             'mapped_c' => 6,
         ], \iterator_to_array($operator));
     }
+
+    #[Test]
+    public function map_keys(): void
+    {
+        $operator = map(
+            [
+                'a' => 1,
+                'b' => 2,
+                'c' => 3,
+            ],
+            keyTransform: static fn(string $key): string => \sprintf('mapped_%s', $key),
+        );
+
+        $this->assertSame([
+            'mapped_a' => 1,
+            'mapped_b' => 2,
+            'mapped_c' => 3,
+        ], \iterator_to_array($operator));
+    }
+
+    #[Test]
+    public function map_values(): void
+    {
+        $operator = map(
+            [
+                'a' => 1,
+                'b' => 2,
+                'c' => 3,
+            ],
+            valueTransform: static fn(int $value): int => $value * 2,
+        );
+
+        $this->assertSame([
+            'a' => 2,
+            'b' => 4,
+            'c' => 6,
+        ], \iterator_to_array($operator));
+    }
+
+    #[Test]
+    public function map_throws_exception_when_transform_function_missing(): void
+    {
+        $this->expectException(LogicException::class);
+
+        map([
+            'a' => 1,
+            'b' => 2,
+            'c' => 3,
+        ]);
+    }
 }