Merge pull request #48 from InnoT20/support-max-collection

[Collection] Add support max and maxBy to collections

Author: klimick

src/Fp/Collections/ArrayList.php

@@ -28,6 +28,8 @@
 use Fp\Operations\LastOfOperation;
 use Fp\Operations\LastOperation;
 use Fp\Operations\MapValuesOperation;
+use Fp\Operations\MaxByElementOperation;
+use Fp\Operations\MaxElementOperation;
 use Fp\Operations\MkStringOperation;
 use Fp\Operations\PrependedAllOperation;
 use Fp\Operations\PrependedOperation;
@@ -606,4 +608,23 @@ public function mkString(string $start = '', string $sep = ',', string $end = ''
     {
         return MkStringOperation::of($this->getIterator())($start, $sep, $end);
     }
+
+    /**
+     * @inheritDoc
+     * @return Option<TV>
+     */
+    public function max(): Option
+    {
+        return MaxElementOperation::of($this->getIterator())();
+    }
+
+    /**
+     * @inheritDoc
+     * @psalm-param callable(TV): mixed $callback
+     * @return Option<TV>
+     */
+    public function maxBy(callable $callback): Option
+    {
+        return MaxByElementOperation::of($this->getIterator())($callback);
+    }
 }

src/Fp/Collections/LinkedList.php

@@ -29,6 +29,8 @@
 use Fp\Operations\LastOfOperation;
 use Fp\Operations\LastOperation;
 use Fp\Operations\MapValuesOperation;
+use Fp\Operations\MaxByElementOperation;
+use Fp\Operations\MaxElementOperation;
 use Fp\Operations\MkStringOperation;
 use Fp\Operations\PrependedAllOperation;
 use Fp\Operations\ReduceOperation;
@@ -618,4 +620,23 @@ public function mkString(string $start = '', string $sep = ',', string $end = ''
     {
         return MkStringOperation::of($this->getIterator())($start, $sep, $end);
     }
+
+    /**
+     * @inheritDoc
+     * @return Option<TV>
+     */
+    public function max(): Option
+    {
+        return MaxElementOperation::of($this->getIterator())();
+    }
+
+    /**
+     * @inheritDoc
+     * @psalm-param callable(TV): mixed $callback
+     * @return Option<TV>
+     */
+    public function maxBy(callable $callback): Option
+    {
+        return MaxByElementOperation::of($this->getIterator())($callback);
+    }
 }

src/Fp/Collections/SeqTerminalOps.php

@@ -283,4 +283,29 @@ public function isNonEmpty(): bool;
      * ```
      */
     public function mkString(string $start = '', string $sep = ',', string $end = ''): string;
+
+    /**
+     * Returns the maximum value from collection
+     *
+     * ```php
+     * >>> LinkedList::collect([1, 4, 2])->max()->get();
+     * => 4
+     * ```
+     *
+     * @psalm-return Option<TV>
+     */
+    public function max(): Option;
+
+    /**
+     * Returns the maximum value from collection by iterating each element using the callback
+     *
+     * ```php
+     * >>> LinkedList::collect([new Foo(1), new Bar(6), new Foo(2)])->maxBy(fn(Foo $foo) => $foo->a)->get();
+     * => 6
+     * ```
+     *
+     * @psalm-param callable(TV): mixed $callback
+     * @psalm-return Option<TV>
+     */
+    public function maxBy(callable $callback): Option;
 }

src/Fp/Functions/Cast/AsList.php

@@ -12,9 +12,8 @@
  * => [1, 2, 3, 4]
  * ```
  *
- * @psalm-template TK of array-key
  * @psalm-template TV
- * @psalm-param iterable<TK, TV> ...$collections
+ * @psalm-param iterable<mixed, TV> ...$collections
  * @psalm-return (
  *     $collections is non-empty-array
  *         ? non-empty-list<TV>

src/Fp/Operations/MaxByElementOperation.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fp\Operations;
+
+use Fp\Functional\Option\Option;
+
+/**
+ * @psalm-immutable
+ * @template TK
+ * @template TV
+ * @extends AbstractOperation<TK, TV>
+ */
+class MaxByElementOperation extends AbstractOperation
+{
+    /**
+     * @psalm-param callable(TV): mixed $by
+     * @return Option<TV>
+     */
+    public function __invoke(callable $by): Option
+    {
+        $f =
+            /**
+             * @param TV $r
+             * @param TV $l
+             * @return int
+             */
+            fn(mixed $r, mixed $l): int => $by($l) <=> $by($r);
+
+        $gen = SortedOperation::of($this->gen)($f);
+
+        return FirstOperation::of($gen)();
+    }
+
+}

src/Fp/Operations/MaxElementOperation.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fp\Operations;
+
+use Fp\Functional\Option\Option;
+
+use function Fp\Cast\asList;
+
+/**
+ * @psalm-immutable
+ * @template TK
+ * @template TV
+ * @extends AbstractOperation<TK, TV>
+ */
+class MaxElementOperation extends AbstractOperation
+{
+    /**
+     * @return Option<TV>
+     */
+    public function __invoke(): Option
+    {
+        $list = asList($this->gen);
+
+        return Option::fromNullable(!empty($list) ? max($list) : null);
+    }
+}

tests/Runtime/Interfaces/Seq/SeqOpsTest.php

@@ -176,7 +176,7 @@ public function testFilterMap(Seq $seq): void
     {
         $this->assertEquals(
             [1, 2],
-            $seq->filterMap(fn($e) => is_numeric($e) ? Option::some((int) $e) : Option::none())
+            $seq->filterMap(fn($e) => is_numeric($e) ? Option::some((int)$e) : Option::none())
                 ->toArray()
         );
     }
@@ -330,7 +330,7 @@ public function testMap(Seq $seq): void
     {
         $this->assertEquals(
             ['2', '3', '4'],
-            $seq->map(fn($e) => (string) ($e + 1))->toArray()
+            $seq->map(fn($e) => (string)($e + 1))->toArray()
         );
     }
 
@@ -554,7 +554,7 @@ public function provideTestIntersperseData(): Generator
      */
     public function testIntersperse(Seq $seq): void
     {
-        $this->assertEquals([0 , ',', 1, ',', 2], $seq->intersperse(',')->toArray());
+        $this->assertEquals([0, ',', 1, ',', 2], $seq->intersperse(',')->toArray());
     }
 
     public function provideTestZipData(): Generator
@@ -585,4 +585,76 @@ public function testMkString(Seq $seq, Seq $emptySeq): void
         $this->assertEquals('(0,1,2)', $seq->mkString('(', ',', ')'));
         $this->assertEquals('()', $emptySeq->mkString('(', ',', ')'));
     }
+
+    public function provideTestMaxNotEmptyCollections(): Generator
+    {
+        yield ArrayList::class => [ArrayList::collect([3, 7, 2]), Option::some(7)];
+        yield LinkedList::class => [LinkedList::collect([9, 1, 2]), Option::some(9)];
+    }
+
+    /**
+     * @dataProvider provideTestMaxNotEmptyCollections
+     */
+    public function testMaxInNotEmptyCollection(Seq $seq, Option $option): void
+    {
+        $this->assertEquals($option, $seq->max());
+    }
+
+    public function provideTestMaxEmptyCollections(): Generator
+    {
+        yield ArrayList::class => [ArrayList::collect([]), Option::none()];
+        yield LinkedList::class => [LinkedList::collect([]), Option::none()];
+    }
+
+    /**
+     * @dataProvider provideTestMaxEmptyCollections
+     */
+    public function testMaxInEmptyCollection(Seq $seq, Option $option): void
+    {
+        $this->assertEquals($option, $seq->max());
+    }
+
+    public function provideTestMaxByNotEmptyCollections(): Generator
+    {
+        yield ArrayList::class => [
+            ArrayList::collect([new Foo(1), new Foo(5), new Foo(2)]),
+            Option::some(new Foo(5))
+        ];
+        yield LinkedList::class => [
+            LinkedList::collect([new Foo(9), new Foo(1), new Foo(2)]),
+            Option::some(new Foo(9))
+        ];
+    }
+
+    /**
+     * @param Seq<Foo> $seq
+     * @param Option<Foo> $option
+     * @dataProvider provideTestMaxByNotEmptyCollections
+     */
+    public function testMaxByInNotEmptyCollection(Seq $seq, Option $option): void
+    {
+        $this->assertEquals($option, $seq->maxBy(fn(Foo $foo) => $foo->a));
+    }
+
+    public function provideTestMaxByEmptyCollections(): Generator
+    {
+        yield ArrayList::class => [
+            ArrayList::collect([]),
+            Option::none()
+        ];
+        yield LinkedList::class => [
+            LinkedList::collect([]),
+            Option::none()
+        ];
+    }
+
+    /**
+     * @param Seq<Foo> $seq
+     * @param Option<Foo> $option
+     * @dataProvider provideTestMaxByEmptyCollections
+     */
+    public function testMaxByInEmptyCollection(Seq $seq, Option $option): void
+    {
+        $this->assertEquals($option, $seq->maxBy(fn(Foo $foo) => $foo->a));
+    }
 }