Add Set.intersect function (#25)

Author: jeparlefrancais

CHANGELOG.md

@@ -1,5 +1,6 @@
 # Changelog
 
+- add `Set.intersect` ([#25](https://github.com/seaofvoices/luau-disk/pull/25))
 - add `Set.toArray` ([#24](https://github.com/seaofvoices/luau-disk/pull/24))
 - add `Set.removeValues` ([#23](https://github.com/seaofvoices/luau-disk/pull/23))
 - add `Set.filter` ([#22](https://github.com/seaofvoices/luau-disk/pull/22))

docs/Set.md

@@ -63,6 +63,19 @@ local result = Set.isEmpty({ key = true }) -- false
 
 *Related [count](#count)*
 
+## intersect
+
+Returns a new set containing only the values that are present in all given sets.
+
+```lua
+local set1 = Set.fromArray({ "a", "b", "c" })
+local set2 = Set.fromArray({ "b", "c", "d" })
+local result = Set.intersect(set1, set2)
+-- result is { b = true, c = true }
+```
+
+*Related [merge](#merge)*
+
 ## map
 
 Returns a new set where each value is converted with a mapping function. When the mapping function returns a `nil` value, the entry is removed.
@@ -88,6 +101,8 @@ local result = Set.merge(set1, set2)
 
 The function will skip `nil` values when merging.
 
+*Related [intersect](#intersect)*
+
 ## removeValues
 
 Returns a new set with all the given values removed.

src/init.lua

@@ -70,6 +70,7 @@ local Disk = {
         count = require('./set/count'),
         filter = require('./set/filter'),
         fromArray = require('./set/fromArray'),
+        intersect = require('./set/intersect'),
         isEmpty = require('./set/isEmpty'),
         map = require('./set/map'),
         merge = require('./set/merge'),

src/set/__tests__/intersect.test.lua

@@ -0,0 +1,179 @@
+local jestGlobals = require('@pkg/@jsdotlua/jest-globals')
+
+local fromArray = require('../fromArray')
+local intersect = require('../intersect')
+
+local expect = jestGlobals.expect
+local it = jestGlobals.it
+
+it('returns intersection of two sets with common elements', function()
+    local set1 = fromArray({ 1, 2, 3, 4 })
+    local set2 = fromArray({ 3, 4, 5, 6 })
+    local result = intersect(set1, set2)
+
+    expect(result).toEqual(fromArray({ 3, 4 }))
+end)
+
+it('returns empty set when sets have no common elements', function()
+    local set1 = fromArray({ 1, 2, 3 })
+    local set2 = fromArray({ 4, 5, 6 })
+    local result = intersect(set1, set2)
+
+    expect(result).toEqual({})
+end)
+
+it('returns intersection of multiple sets', function()
+    local set1 = fromArray({ 1, 2, 3, 4, 5 })
+    local set2 = fromArray({ 2, 3, 4, 5, 6 })
+    local set3 = fromArray({ 3, 4, 5, 6, 7 })
+    local result = intersect(set1, set2, set3)
+
+    expect(result).toEqual(fromArray({ 3, 4, 5 }))
+end)
+
+it('returns empty set when any set is empty', function()
+    local set1 = fromArray({ 1, 2, 3 })
+    local set2 = {}
+    local set3 = fromArray({ 2, 3, 4 })
+    local result = intersect(set1, set2, set3)
+
+    expect(result).toEqual({})
+end)
+
+it('returns empty set when no sets are provided', function()
+    local result = intersect()
+
+    expect(result).toEqual({})
+end)
+
+it('returns the original set when only one set is provided', function()
+    local set1 = fromArray({ 1, 2, 3, 4 })
+    local result = intersect(set1)
+
+    expect(result).toBe(set1)
+end)
+
+it('returns original set when other sets are nil', function()
+    local set1 = fromArray({ 1, 2, 3 })
+    local result = intersect(set1, nil, nil)
+
+    expect(result).toBe(set1)
+end)
+
+it('handles identical sets', function()
+    local set1 = fromArray({ 1, 2, 3 })
+    local set2 = fromArray({ 1, 2, 3 })
+    local result = intersect(set1, set2)
+
+    expect(result).toEqual(fromArray({ 1, 2, 3 }))
+end)
+
+it('works with string sets', function()
+    local set1 = fromArray({ 'apple', 'banana', 'cherry' })
+    local set2 = fromArray({ 'banana', 'cherry', 'date' })
+    local result = intersect(set1, set2)
+
+    expect(result).toEqual(fromArray({ 'banana', 'cherry' }))
+end)
+
+it('works with mixed type sets', function()
+    local set1 = fromArray({ 1 :: any, 'hello', true })
+    local set2 = fromArray({ 1 :: any, 'hello', false })
+    local result = intersect(set1, set2)
+
+    expect(result).toEqual(fromArray({ 1 :: any, 'hello' }))
+end)
+
+it('handles single element sets', function()
+    local set1 = fromArray({ 42 })
+    local set2 = fromArray({ 42 })
+    local result = intersect(set1, set2)
+
+    expect(result).toEqual(fromArray({ 42 }))
+end)
+
+it('returns empty set for single element sets with different elements', function()
+    local set1 = fromArray({ 42 })
+    local set2 = fromArray({ 24 })
+    local result = intersect(set1, set2)
+
+    expect(result).toEqual({})
+end)
+
+it('handles subsets correctly', function()
+    local set1 = fromArray({ 1, 2, 3, 4, 5 })
+    local set2 = fromArray({ 2, 3 })
+    local result = intersect(set1, set2)
+
+    expect(result).toEqual(fromArray({ 2, 3 }))
+end)
+
+it('handles supersets correctly', function()
+    local set1 = fromArray({ 2, 3 })
+    local set2 = fromArray({ 1, 2, 3, 4, 5 })
+    local result = intersect(set1, set2)
+
+    expect(result).toEqual(fromArray({ 2, 3 }))
+end)
+
+it('does not modify original sets', function()
+    local set1 = fromArray({ 1, 2, 3, 4 })
+    local set2 = fromArray({ 3, 4, 5, 6 })
+    local originalSet1 = table.clone(set1)
+    local originalSet2 = table.clone(set2)
+
+    local result = intersect(set1, set2)
+
+    expect(set1).toEqual(originalSet1)
+    expect(set2).toEqual(originalSet2)
+    expect(result).never.toBe(set1)
+    expect(result).never.toBe(set2)
+end)
+
+it('works with four sets', function()
+    local set1 = fromArray({ 1, 2, 3, 4, 5, 6 })
+    local set2 = fromArray({ 2, 3, 4, 5, 6, 7 })
+    local set3 = fromArray({ 3, 4, 5, 6, 7, 8 })
+    local set4 = fromArray({ 4, 5, 6, 7, 8, 9 })
+    local result = intersect(set1, set2, set3, set4)
+
+    expect(result).toEqual(fromArray({ 4, 5, 6 }))
+end)
+
+it('returns first set when all elements are common', function()
+    local set1 = fromArray({ 1, 2, 3 })
+    local set2 = fromArray({ 1, 2, 3, 4, 5 })
+    local set3 = fromArray({ 1, 2, 3, 6, 7 })
+    local result = intersect(set1, set2, set3)
+
+    expect(result).toBe(set1)
+end)
+
+it('handles boolean values in sets', function()
+    local set1 = fromArray({ true, false })
+    local set2 = fromArray({ true })
+    local result = intersect(set1, set2)
+
+    expect(result).toEqual(fromArray({ true }))
+end)
+
+it('handles empty intersection with multiple sets', function()
+    local set1 = fromArray({ 1, 2 })
+    local set2 = fromArray({ 3, 4 })
+    local set3 = fromArray({ 5, 6 })
+    local result = intersect(set1, set2, set3)
+
+    expect(result).toEqual({})
+end)
+
+it('handles nested tables as set elements', function()
+    local table1 = { 1, 2, 3 }
+    local table2 = { 4, 5, 6 }
+    local set1 = fromArray({ table1, table2 })
+    local set2 = fromArray({ table1 })
+    local result = intersect(set1, set2)
+
+    expect(result).toEqual(fromArray({ table1 }))
+end)
+
+return nil

src/set/intersect.lua

@@ -0,0 +1,54 @@
+local SetType = require('./type')
+
+type Set<T> = SetType.Set<T>
+
+local function intersect<T>(...: Set<T>?): Set<T>
+    local sets = {}
+
+    for i = 1, select('#', ...) do
+        local setValue = select(i, ...)
+        if setValue then
+            if next(setValue) == nil then
+                return {}
+            end
+
+            table.insert(sets, setValue)
+        end
+    end
+
+    local length = #sets
+
+    if length == 0 then
+        return {}
+    elseif length == 1 then
+        return sets[1]
+    else
+        local removeKeys = {}
+        local first = sets[1]
+
+        for key in first do
+            for i = 2, length do
+                local currentSet = sets[i]
+
+                if not currentSet[key] then
+                    table.insert(removeKeys, key)
+                    break
+                end
+            end
+        end
+
+        if #removeKeys == 0 then
+            return first
+        end
+
+        local result: Set<T> = table.clone(first)
+
+        for _, key in removeKeys do
+            result[key] = nil
+        end
+
+        return result
+    end
+end
+
+return intersect