[Collection] Set/NonEmptySet intersect and diff ops.

Author: whsv26

src/Fp/Collections/HashSet.php

@@ -404,4 +404,24 @@ public function subsetOf(Set|NonEmptySet $superset): bool
 
         return $isSubset;
     }
+
+    /**
+     * @inheritDoc
+     * @param Set<TV>|NonEmptySet<TV> $that
+     * @return Set<TV>
+     */
+    public function intersect(Set|NonEmptySet $that): Set
+    {
+        return $this->filter(fn($elem) => /** @var TV $elem */ $that($elem));
+    }
+
+    /**
+     * @inheritDoc
+     * @param Set<TV>|NonEmptySet<TV> $that
+     * @return Set<TV>
+     */
+    public function diff(Set|NonEmptySet $that): Set
+    {
+        return $this->filter(fn($elem) => /** @var TV $elem */ !$that($elem));
+    }
 }

src/Fp/Collections/NonEmptyHashSet.php

@@ -445,4 +445,24 @@ public function subsetOf(Set|NonEmptySet $superset): bool
 
         return $isSubset;
     }
+
+    /**
+     * @inheritDoc
+     * @param Set<TV>|NonEmptySet<TV> $that
+     * @return Set<TV>
+     */
+    public function intersect(Set|NonEmptySet $that): Set
+    {
+        return $this->filter(fn($elem) => /** @var TV $elem */ $that($elem));
+    }
+
+    /**
+     * @inheritDoc
+     * @param Set<TV>|NonEmptySet<TV> $that
+     * @return Set<TV>
+     */
+    public function diff(Set|NonEmptySet $that): Set
+    {
+        return $this->filter(fn($elem) => /** @var TV $elem */ !$that($elem));
+    }
 }

src/Fp/Collections/NonEmptySetChainableOps.php

@@ -155,4 +155,34 @@ public function tap(callable $callback): NonEmptySet;
      * @psalm-return Set<TV>
      */
     public function tail(): Set;
+
+    /**
+     * Computes the intersection between this set and another set.
+     *
+     * ```php
+     * >>> NonEmptyHashSet::collectNonEmpty([1, 2, 3])
+     *     ->intersect(HashSet::collect([2, 3]))->toArray();
+     * => [2, 3]
+     * ```
+     *
+     * @param Set<TV>|NonEmptySet<TV> $that the set to intersect with.
+     * @return Set<TV> a new set consisting of all elements that are both in this
+     * set and in the given set `that`.
+     */
+    public function intersect(Set|NonEmptySet $that): Set;
+
+    /**
+     * Computes the difference of this set and another set.
+     *
+     * ```php
+     * >>> NonEmptyHashSet::collectNonEmpty([1, 2, 3])
+     *     ->diff(HashSet::collect([2, 3]))->toArray();
+     * => [1]
+     * ```
+     *
+     * @param Set<TV>|NonEmptySet<TV> $that the set of elements to exclude.
+     * @return Set<TV> a set containing those elements of this
+     * set that are not also contained in the given set `that`.
+     */
+    public function diff(Set|NonEmptySet $that): Set;
 }

src/Fp/Collections/SetChainableOps.php

@@ -47,8 +47,8 @@ public function removed(mixed $element): Set;
      * => [2]
      * ```
      *
-     * @psalm-param callable(TV): bool $predicate
-     * @psalm-return Set<TV>
+     * @param callable(TV): bool $predicate
+     * @return Set<TV>
      */
     public function filter(callable $predicate): Set;
 
@@ -60,10 +60,10 @@ public function filter(callable $predicate): Set;
      * => [Foo(2)]
      * ```
      *
-     * @psalm-template TVO
-     * @psalm-param class-string<TVO> $fqcn fully qualified class name
-     * @psalm-param bool $invariant if turned on then subclasses are not allowed
-     * @psalm-return Set<TVO>
+     * @template TVO
+     * @param class-string<TVO> $fqcn fully qualified class name
+     * @param bool $invariant if turned on then subclasses are not allowed
+     * @return Set<TVO>
      */
     public function filterOf(string $fqcn, bool $invariant = false): Set;
 
@@ -75,7 +75,7 @@ public function filterOf(string $fqcn, bool $invariant = false): Set;
      * => [1]
      * ```
      *
-     * @psalm-return Set<TV>
+     * @return Set<TV>
      */
     public function filterNotNull(): Set;
 
@@ -92,9 +92,9 @@ public function filterNotNull(): Set;
      * => [1, 2]
      * ```
      *
-     * @psalm-template TVO
-     * @psalm-param callable(TV): Option<TVO> $callback
-     * @psalm-return Set<TVO>
+     * @template TVO
+     * @param callable(TV): Option<TVO> $callback
+     * @return Set<TVO>
      */
     public function filterMap(callable $callback): Set;
 
@@ -104,9 +104,9 @@ public function filterMap(callable $callback): Set;
      * => [1, 2, 3, 4, 5, 6]
      * ```
      *
-     * @psalm-template TVO
-     * @psalm-param callable(TV): iterable<TVO> $callback
-     * @psalm-return Set<TVO>
+     * @template TVO
+     * @param callable(TV): iterable<TVO> $callback
+     * @return Set<TVO>
      */
     public function flatMap(callable $callback): Set;
 
@@ -120,8 +120,8 @@ public function flatMap(callable $callback): Set;
      * ```
      *
      * @template TVO
-     * @psalm-param callable(TV): TVO $callback
-     * @psalm-return Set<TVO>
+     * @param callable(TV): TVO $callback
+     * @return Set<TVO>
      */
     public function map(callable $callback): Set;
 
@@ -137,7 +137,7 @@ public function map(callable $callback): Set;
      * ```
      *
      * @param callable(TV): void $callback
-     * @psalm-return Set<TV>
+     * @return Set<TV>
      */
     public function tap(callable $callback): Set;
 
@@ -149,7 +149,37 @@ public function tap(callable $callback): Set;
      * => [2, 3]
      * ```
      *
-     * @psalm-return Set<TV>
+     * @return Set<TV>
      */
     public function tail(): Set;
+
+    /**
+     * Computes the intersection between this set and another set.
+     *
+     * ```php
+     * >>> HashSet::collect([1, 2, 3])
+     *     ->intersect(HashSet::collect([2, 3]))->toArray();
+     * => [2, 3]
+     * ```
+     *
+     * @param Set<TV>|NonEmptySet<TV> $that the set to intersect with.
+     * @return Set<TV> a new set consisting of all elements that are both in this
+     * set and in the given set `that`.
+     */
+    public function intersect(Set|NonEmptySet $that): Set;
+
+    /**
+     * Computes the difference of this set and another set.
+     *
+     * ```php
+     * >>> HashSet::collect([1, 2, 3])
+     *     ->diff(HashSet::collect([2, 3]))->toArray();
+     * => [1]
+     * ```
+     *
+     * @param Set<TV>|NonEmptySet<TV> $that the set of elements to exclude.
+     * @return Set<TV> a set containing those elements of this
+     * set that are not also contained in the given set `that`.
+     */
+    public function diff(Set|NonEmptySet $that): Set;
 }

tests/Runtime/Interfaces/NonEmptySet/NonEmptySetOpsTest.php

@@ -185,4 +185,21 @@ public function testTail(): void
             NonEmptyHashSet::collectNonEmpty([1, 2, 3])->tail()->toArray()
         );
     }
+
+    public function testIntersectAndDiff(): void
+    {
+        $this->assertEquals(
+            [2, 3],
+            NonEmptyHashSet::collectNonEmpty([1, 2, 3])
+                ->intersect(HashSet::collect([2, 3]))
+                ->toArray()
+        );
+
+        $this->assertEquals(
+            [1],
+            NonEmptyHashSet::collectNonEmpty([1, 2, 3])
+                ->diff(HashSet::collect([2, 3]))
+                ->toArray()
+        );
+    }
 }

tests/Runtime/Interfaces/Set/SetOpsTest.php

@@ -192,4 +192,21 @@ public function testTail(): void
             HashSet::collect([1, 2, 3])->tail()->toArray()
         );
     }
+
+    public function testIntersectAndDiff(): void
+    {
+        $this->assertEquals(
+            [2, 3],
+            HashSet::collect([1, 2, 3])
+                ->intersect(HashSet::collect([2, 3]))
+                ->toArray()
+        );
+
+        $this->assertEquals(
+            [1],
+            HashSet::collect([1, 2, 3])
+                ->diff(HashSet::collect([2, 3]))
+                ->toArray()
+        );
+    }
 }