Add ElementsMatch, ElementsMatchBy (#589)

* Add ElementsMatch, ElementsMatchBy

* Update intersect.go

* Update README.md

---------

Co-authored-by: Samuel Berthe <[email protected]>

Author: senago

README.md

@@ -221,6 +221,8 @@ Supported intersection helpers:
 - [WithoutBy](#withoutby)
 - [WithoutEmpty](#withoutempty)
 - [WithoutNth](#withoutnth)
+- [ElementsMatch](#ElementsMatch)
+- [ElementsMatchBy](#ElementsMatchBy)
 
 Supported search helpers:
 
@@ -2400,6 +2402,36 @@ subset := lo.WithoutNth([]int{-2, -1, 0, 1, 2}, 3, -42, 1)
 // []int{-2, 0, 2}
 ```
 
+### ElementsMatch
+
+Returns true if lists contain the same set of elements (including empty set).
+
+If there are duplicate elements, the number of appearances of each of them in both lists should match.
+
+The order of elements is not checked.
+
+```go
+b := lo.ElementsMatch([]int{1, 1, 2}, []int{2, 1, 1})
+// true
+```
+
+### ElementsMatchBy
+
+Returns true if lists contain the same set of elements' keys (including empty set).
+
+If there are duplicate keys, the number of appearances of each of them in both lists should match.
+
+The order of elements is not checked.
+
+```go
+b := lo.ElementsMatchBy(
+    []someType{a, b},
+    []someType{b, a},
+    func(item someType) string { return item.ID() },
+)
+// true
+```
+
 ### IndexOf
 
 Returns the index at which the first occurrence of a value is found in an array or return -1 if the value cannot be found.

intersect.go

@@ -225,3 +225,41 @@ func WithoutNth[T comparable, Slice ~[]T](collection Slice, nths ...int) Slice {
 
 	return result
 }
+
+// ElementsMatch returns true if lists contain the same set of elements (including empty set).
+// If there are duplicate elements, the number of appearances of each of them in both lists should match.
+// The order of elements is not checked.
+func ElementsMatch[T comparable, Slice ~[]T](list1 Slice, list2 Slice) bool {
+	return ElementsMatchBy(list1, list2, func(item T) T { return item })
+}
+
+// ElementsMatchBy returns true if lists contain the same set of elements' keys (including empty set).
+// If there are duplicate keys, the number of appearances of each of them in both lists should match.
+// The order of elements is not checked.
+func ElementsMatchBy[T any, K comparable](list1 []T, list2 []T, iteratee func(item T) K) bool {
+	if len(list1) != len(list2) {
+		return false
+	}
+
+	if len(list1) == 0 {
+		return true
+	}
+
+	counters := make(map[K]int, len(list1))
+
+	for _, el := range list1 {
+		counters[iteratee(el)]++
+	}
+
+	for _, el := range list2 {
+		counters[iteratee(el)]--
+	}
+
+	for _, count := range counters {
+		if count != 0 {
+			return false
+		}
+	}
+
+	return true
+}

intersect_test.go

@@ -330,3 +330,34 @@ func TestWithoutNth(t *testing.T) {
 	nonempty := WithoutNth(allStrings)
 	is.IsType(nonempty, allStrings, "type preserved")
 }
+
+func TestElementsMatch(t *testing.T) {
+	t.Parallel()
+	is := assert.New(t)
+
+	is.False(ElementsMatch([]int{}, []int{1}))
+	is.False(ElementsMatch([]int{1}, []int{2}))
+	is.False(ElementsMatch([]int{1}, []int{1, 2}))
+	is.False(ElementsMatch([]int{1, 1, 2}, []int{2, 2, 1}))
+
+	is.True(ElementsMatch([]int{}, nil))
+	is.True(ElementsMatch([]int{1}, []int{1}))
+	is.True(ElementsMatch([]int{1, 1}, []int{1, 1}))
+	is.True(ElementsMatch([]int{1, 2}, []int{2, 1}))
+	is.True(ElementsMatch([]int{1, 1, 2}, []int{1, 2, 1}))
+}
+
+func TestElementsMatchBy(t *testing.T) {
+	t.Parallel()
+	is := assert.New(t)
+
+	type someType struct {
+		key string
+	}
+
+	is.True(ElementsMatchBy(
+		[]someType{{key: "a"}, {key: "b"}},
+		[]someType{{key: "b"}, {key: "a"}},
+		func(item someType) string { return item.key },
+	))
+}