wip: more slice fixings

Author: shoenig

collection.go

@@ -3,8 +3,6 @@
 
 package set
 
-import "fmt"
-
 // Collection is a minimal common interface that all sets implement.
 
 // Fundamental set operations and familiar utility methods are part of this
@@ -187,11 +185,8 @@ func intersect[T any](destination, a, b Collection[T]) {
 }
 
 func containsSlice[T any](col Collection[T], items []T) bool {
-	fmt.Println("containsSlice", "col", col, "items", items)
 	for _, item := range items {
-		fmt.Println("checking item", item)
 		if !col.Contains(item) {
-			fmt.Println("missing item", item)
 			return false
 		}
 	}

examples_set_test.go

@@ -107,7 +107,7 @@ func ExampleSet_ContainsSlice() {
 	fmt.Println(s.ContainsSlice([]string{"red", "blue", "green"}))
 
 	// Output:
-	// false
+	// true
 	// false
 	// true
 }

hashset_test.go

@@ -600,7 +600,7 @@ func TestHashSet_EqualSlice(t *testing.T) {
 	t.Run("duplicates", func(t *testing.T) {
 		a := HashSetFrom[*company, string]([]*company{c1, c2, c3, c4, c5})
 		b := []*company{c1, c2, c2, c3, c3, c4, c5}
-		must.False(t, a.EqualSlice(b))
+		must.True(t, a.EqualSlice(b))
 	})
 }
 

set.go

@@ -139,8 +139,7 @@ func (s *Set[T]) Contains(item T) bool {
 	return exists
 }
 
-// ContainsSlice returns whether all elements in items are present
-// in s.
+// ContainsSlice returns whether all elements in items are present in s.
 func (s *Set[T]) ContainsSlice(items []T) bool {
 	return containsSlice(s, items)
 }

treeset.go

@@ -307,18 +307,9 @@ func (s *TreeSet[T]) Contains(item T) bool {
 	return s.locate(s.root, item) != nil
 }
 
-// ContainsSlice returns whether s contains the same set of elements that are in
-// items. The items slice may contain duplicate elements.
-//
-// If the items slice is known to be set-like (no duplicates), EqualSlice provides
-// a more efficient implementation.
+// ContainsSlice returns whether all elements in items are present in s.
 func (s *TreeSet[T]) ContainsSlice(items []T) bool {
-	for _, item := range items {
-		if !s.Contains(item) {
-			return false
-		}
-	}
-	return true
+	return containsSlice(s, items)
 }
 
 // Size returns the number of elements in s.
@@ -483,11 +474,31 @@ func (s *TreeSet[T]) EqualSet(col Collection[T]) bool {
 }
 
 // EqualSlice returns whether s and items contain the same elements.
+//
+// The items slice may contain duplicates.
+//
+// If the items slice is known to contain no duplicates, EqualSliceSet may be
+// used instead as a faster implementation.
+//
+// To detect if a slice is a subset of s, use ContainsSlice.
 func (s *TreeSet[T]) EqualSlice(items []T) bool {
+	other := TreeSetFrom[T](items, s.comparison)
+	return s.Equal(other)
+}
+
+// EqualSliceSet returns whether s and items contain exactly the same elements.
+//
+// If items contains duplicates EqualSliceSet will return false. The elements of
+// items are assumed to be set-like. For comparing s to a slice that may contain
+// duplicate elements, use EqualSlice instead.
+//
+// To detect if a slice is a subset of s, use ContainsSlice.
+func (s *TreeSet[T]) EqualSliceSet(items []T) bool {
+	// TODO optimize
 	if s.Size() != len(items) {
 		return false
 	}
-	return s.ContainsSlice(items)
+	return s.EqualSlice(items)
 }
 
 // String creates a string representation of s, using "%v" printf formatting