Feat: Adding the equivalent of checking if two slices are the same

README.md

@@ -196,6 +196,7 @@ Supported intersection helpers:
 - [ContainsBy](#containsby)
 - [Every](#every)
 - [EveryBy](#everyby)
+- [Equivalent](#equivalent)
 - [Some](#some)
 - [SomeBy](#someby)
 - [None](#none)
@@ -1947,6 +1948,16 @@ b := EveryBy([]int{1, 2, 3, 4}, func(x int) bool {
 // true
 ```
 
+### EqualUnordered
+
+Returns true if the subset has the same elements and the same number of each element as the collection.
+Unlike slices.Equal(), which returns effected by order, Equivalent does not care about the order of the elements.
+
+```go
+b := EqualUnordered([]int{0, 1, 1, 3, 0, 0}, []int{0, 1, 3, 0, 1, 0})
+// true
+```
+
 ### Some
 
 Returns true if at least 1 element of a subset is contained into a collection.

intersect.go

@@ -44,6 +44,27 @@ func EveryBy[T any](collection []T, predicate func(item T) bool) bool {
 	return true
 }
 
+// EqualUnordered returns true if the subset has the same elements and the same number of each element as the collection.
+// Unlike slices.Equal(), which returns effected by order, EqualUnordered does not care about the order of the elements.
+func EqualUnordered[T comparable, Slice ~[]T](collection, subset Slice) bool {
+	l := len(collection)
+	if l != len(subset) {
+		return false
+	}
+
+	var m = make(map[T]int, l)
+	for i := 0; i < l; i++ {
+		m[collection[i]] += 1
+		m[subset[i]] -= 1
+	}
+	for _, v := range m {
+		if v != 0 {
+			return false
+		}
+	}
+	return true
+}
+
 // Some returns true if at least 1 element of a subset is contained into a collection.
 // If the subset is empty Some returns false.
 func Some[T comparable](collection []T, subset []T) bool {

intersect_test.go

@@ -84,6 +84,29 @@ func TestEveryBy(t *testing.T) {
 	is.True(result4)
 }
 
+func TestEqualUnordered(t *testing.T) {
+	t.Parallel()
+	is := assert.New(t)
+
+	result1 := EqualUnordered([]int{0, 1, 2, 3, 4, 5}, []int{0, 1, 2, 3, 4, 5})
+	is.True(result1)
+
+	result2 := EqualUnordered([]int{2, 3, 4, 5, 0, 1}, []int{0, 1, 2, 3, 4, 5})
+	is.True(result2)
+
+	result3 := EqualUnordered([]int{0, 1, 1, 3, 0, 0}, []int{0, 1, 3, 0, 1, 0})
+	is.True(result3)
+
+	result4 := EqualUnordered([]int{0, 1, 2, 3, 4}, []int{0, 1, 2, 3, 4, 5})
+	is.False(result4)
+
+	result5 := EqualUnordered([]int{0, 1, 2, 3, 4, 6}, []int{0, 1, 2, 3, 4, 5})
+	is.False(result5)
+
+	result6 := EqualUnordered([]int{0, 1, 1, 1, 1, 1}, []int{0, 0, 1, 1, 1, 1})
+	is.False(result6)
+}
+
 func TestSome(t *testing.T) {
 	t.Parallel()
 	is := assert.New(t)