Refactor: move filter / map logic into IterableObject

composer.json

@@ -21,6 +21,7 @@
         "php": "^7.3 || ^8.0"
     },
     "require-dev": {
+        "bentools/cartesian-product": "^1.3",
         "doctrine/coding-standard": "^8.2",
         "pestphp/pest": "^1.0",
         "phpstan/extension-installer": "^1.1",

src/IterableObject.php

@@ -4,10 +4,15 @@
 
 namespace BenTools\IterableFunctions;
 
-use EmptyIterator;
+use CallbackFilterIterator;
 use IteratorAggregate;
+use IteratorIterator;
 use Traversable;
 
+use function array_filter;
+use function array_map;
+use function iterator_to_array;
+
 /**
  * @internal
  *
@@ -18,73 +23,51 @@ final class IterableObject implements IteratorAggregate
     /** @var iterable<mixed> */
     private $iterable;
 
-    /** @var callable|null */
-    private $filterFn;
-
-    /** @var callable|null */
-    private $mapFn;
-
-    /**
-     * @param iterable<mixed>|null $iterable
-     */
-    private function __construct(?iterable $iterable = null, ?callable $filter = null, ?callable $map = null)
-    {
-        $this->iterable = $iterable ?? new EmptyIterator();
-        $this->filterFn = $filter;
-        $this->mapFn = $map;
-    }
-
     /**
-     * @param iterable<mixed>|null $iterable
+     * @param iterable<mixed> $iterable
      */
-    public static function new(?iterable $iterable = null): self
+    public function __construct(iterable $iterable)
     {
-        return new self($iterable);
+        $this->iterable = $iterable;
     }
 
     public function filter(?callable $filter = null): self
     {
-        $filter = $filter ?? function ($value): bool {
-            return (bool) $value;
-        };
+        if ($this->iterable instanceof Traversable) {
+            $filter = $filter ??
+                /** @param mixed $value */
+                static function ($value): bool {
+                    return (bool) $value;
+                };
+
+            return new self(new CallbackFilterIterator(new IteratorIterator($this->iterable), $filter));
+        }
+
+        $filtered = $filter === null ? array_filter($this->iterable) : array_filter($this->iterable, $filter);
 
-        return new self($this->iterable, $filter, $this->mapFn);
+        return new self($filtered);
     }
 
-    public function map(callable $map): self
+    public function map(callable $mapper): self
     {
-        return new self($this->iterable, $this->filterFn, $map);
+        if ($this->iterable instanceof Traversable) {
+            return new self(new MappedTraversable($this->iterable, $mapper));
+        }
+
+        return new self(array_map($mapper, $this->iterable));
     }
 
     /**
      * @return Traversable<mixed>
      */
     public function getIterator(): Traversable
     {
-        $iterable = $this->iterable;
-        if ($this->filterFn !== null) {
-            $iterable = iterable_filter($iterable, $this->filterFn);
-        }
-
-        if ($this->mapFn !== null) {
-            $iterable = iterable_map($iterable, $this->mapFn);
-        }
-
-        return iterable_to_traversable($iterable);
+        yield from $this->iterable;
     }
 
     /** @return array<mixed> */
     public function asArray(): array
     {
-        $iterable = $this->iterable;
-        if ($this->filterFn !== null) {
-            $iterable = iterable_filter($iterable, $this->filterFn);
-        }
-
-        if ($this->mapFn !== null) {
-            $iterable = iterable_map($iterable, $this->mapFn);
-        }
-
-        return iterable_to_array($iterable);
+        return $this->iterable instanceof Traversable ? iterator_to_array($this->iterable) : $this->iterable;
     }
 }

src/MappedTraversable.php

@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace BenTools\IterableFunctions;
+
+use IteratorAggregate;
+use Traversable;
+
+/**
+ * @internal
+ *
+ * @implements IteratorAggregate<mixed>
+ */
+final class MappedTraversable implements IteratorAggregate
+{
+    /** @var Traversable<mixed> */
+    private $traversable;
+
+    /** @var callable */
+    private $mapper;
+
+    /**
+     * @param Traversable<mixed> $traversable
+     */
+    public function __construct(Traversable $traversable, callable $mapper)
+    {
+        $this->traversable = $traversable;
+        $this->mapper = $mapper;
+    }
+
+    /**
+     * @return Traversable<mixed>
+     */
+    public function getIterator(): Traversable
+    {
+        foreach ($this->traversable as $key => $value) {
+            yield $key => ($this->mapper)($value);
+        }
+    }
+}

src/iterable-functions.php

@@ -5,12 +5,11 @@
 namespace BenTools\IterableFunctions;
 
 use ArrayIterator;
-use CallbackFilterIterator;
-use IteratorIterator;
+use EmptyIterator;
 use Traversable;
 
-use function array_filter;
 use function array_values;
+use function is_array;
 use function iterator_to_array;
 
 /**
@@ -22,9 +21,9 @@
  */
 function iterable_map(iterable $iterable, callable $map): iterable
 {
-    foreach ($iterable as $key => $item) {
-        yield $key => $map($item);
-    }
+    $mapped = iterable($iterable)->map($map);
+
+    return is_array($iterable) ? $mapped->asArray() : $mapped;
 }
 
 /**
@@ -65,23 +64,13 @@ function iterable_to_traversable(iterable $iterable): Traversable
  *
  * @param iterable<mixed> $iterable
  *
- * @return array<mixed>|CallbackFilterIterator
+ * @return iterable<mixed>
  */
-function iterable_filter(iterable $iterable, ?callable $filter = null)
+function iterable_filter(iterable $iterable, ?callable $filter = null): iterable
 {
-    if ($filter === null) {
-        $filter =
-            /** @param mixed $value */
-            static function ($value): bool {
-                return (bool) $value;
-            };
-    }
-
-    if ($iterable instanceof Traversable) {
-        return new CallbackFilterIterator(new IteratorIterator($iterable), $filter);
-    }
+    $filtered = iterable($iterable)->filter($filter);
 
-    return array_filter($iterable, $filter);
+    return is_array($iterable) ? $filtered->asArray() : $filtered;
 }
 
 /**
@@ -111,7 +100,7 @@ function iterable_reduce(iterable $iterable, callable $reduce, $initial = null)
 /**
  * @param iterable<mixed> $iterable
  */
-function iterable(iterable $iterable): IterableObject
+function iterable(?iterable $iterable): IterableObject
 {
-    return IterableObject::new($iterable);
+    return new IterableObject($iterable ?? new EmptyIterator());
 }

tests/IterableFilterTest.php

@@ -5,20 +5,24 @@
 namespace BenTools\IterableFunctions\Tests;
 
 use SplFixedArray;
+use Traversable;
 
+use function assert;
 use function BenTools\IterableFunctions\iterable_filter;
-use function BenTools\IterableFunctions\iterable_to_array;
 use function it;
-use function PHPUnit\Framework\assertEquals;
+use function iterator_to_array;
+use function PHPUnit\Framework\assertSame;
 
 it('filters an array', function (): void {
     $iterable = [false, true];
-    assertEquals([1 => true], iterable_to_array(iterable_filter($iterable)));
+    assertSame([1 => true], iterable_filter($iterable));
 });
 
 it('filters a Traversable object', function (): void {
     $iterable = SplFixedArray::fromArray([false, true]);
-    assertEquals([1 => true], iterable_to_array(iterable_filter($iterable)));
+    $filtered = iterable_filter($iterable);
+    assert($filtered instanceof Traversable);
+    assertSame([1 => true], iterator_to_array($filtered));
 });
 
 it('filters an array with a callback', function (): void {
@@ -28,7 +32,7 @@
     static function ($input): bool {
         return $input === 'bar';
     };
-    assertEquals([1 => 'bar'], iterable_to_array(iterable_filter($iterable, $filter)));
+    assertSame([1 => 'bar'], iterable_filter($iterable, $filter));
 });
 
 it('filters a Travsersable object with a callback', function (): void {
@@ -38,5 +42,7 @@ static function ($input): bool {
     static function ($input): bool {
         return $input === 'bar';
     };
-    assertEquals([1 => 'bar'], iterable_to_array(iterable_filter($iterable, $filter)));
+    $filtered = iterable_filter($iterable, $filter);
+    assert($filtered instanceof Traversable);
+    assertSame([1 => 'bar'], iterator_to_array($filtered));
 });

tests/IterableMapTest.php

@@ -8,24 +8,27 @@
 use PHPUnit\Framework\Assert;
 use SplFixedArray;
 use stdClass;
+use Traversable;
 
+use function assert;
 use function BenTools\IterableFunctions\iterable_map;
-use function BenTools\IterableFunctions\iterable_to_array;
 use function it;
-use function PHPUnit\Framework\assertEquals;
+use function iterator_to_array;
 use function PHPUnit\Framework\assertInstanceOf;
 use function PHPUnit\Framework\assertSame;
 
 it('maps an array', function (): void {
     $iterable = ['foo', 'bar'];
     $map = 'strtoupper';
-    assertEquals(['FOO', 'BAR'], iterable_to_array(iterable_map($iterable, $map)));
+    assertSame(['FOO', 'BAR'], iterable_map($iterable, $map));
 });
 
 it('maps a Traversable object', function (): void {
     $iterable = SplFixedArray::fromArray(['foo', 'bar']);
     $map = 'strtoupper';
-    assertEquals(['FOO', 'BAR'], iterable_to_array(iterable_map($iterable, $map)));
+    $mapped = iterable_map($iterable, $map);
+    assert($mapped instanceof Traversable);
+    assertSame(['FOO', 'BAR'], iterator_to_array($mapped));
 });
 
 it('maps iterable with object keys', function (): void {