add Append() method for adding multiple elements to set (#93)

* add Append() method for adding multiple elements to set

* Fixing how Append gets dereferenced due to some recent changes.

We no longer need two layers of indirection.

---------

Co-authored-by: Ralph Caraveo <[email protected]>

Author: SignorMercurio

iterator_example_test.go

@@ -35,12 +35,12 @@ type yourType struct {
 
 func Test_ExampleIterator(t *testing.T) {
 
-	s := NewSet[*yourType](
+	s := NewSet(
 		[]*yourType{
-			&yourType{name: "Alise"},
-			&yourType{name: "Bob"},
-			&yourType{name: "John"},
-			&yourType{name: "Nick"},
+			{name: "Alise"},
+			{name: "Bob"},
+			{name: "John"},
+			{name: "Nick"},
 		}...,
 	)
 

set.go

@@ -43,6 +43,10 @@ type Set[T comparable] interface {
 	// the item was added.
 	Add(val T) bool
 
+	// Append multiple elements to the set. Returns
+	// the number of elements added.
+	Append(val ...T) int
+
 	// Cardinality returns the number of elements in the set.
 	Cardinality() int
 

set_test.go

@@ -45,6 +45,18 @@ func makeUnsafeSetInt(ints []int) Set[int] {
 	return s
 }
 
+func makeSetIntWithAppend(ints ...int) Set[int] {
+	s := NewSet[int]()
+	s.Append(ints...)
+	return s
+}
+
+func makeUnsafeSetIntWithAppend(ints ...int) Set[int] {
+	s := NewThreadUnsafeSet[int]()
+	s.Append(ints...)
+	return s
+}
+
 func assertEqual[T comparable](a, b Set[T], t *testing.T) {
 	if !a.Equal(b) {
 		t.Errorf("%v != %v\n", a, b)
@@ -88,6 +100,22 @@ func Test_AddUnsafeSet(t *testing.T) {
 	}
 }
 
+func Test_AppendSet(t *testing.T) {
+	a := makeSetIntWithAppend(1, 2, 3)
+
+	if a.Cardinality() != 3 {
+		t.Error("AppendSet does not have a size of 3 even though 3 items were added to a new set")
+	}
+}
+
+func Test_AppendUnsafeSet(t *testing.T) {
+	a := makeUnsafeSetIntWithAppend(1, 2, 3)
+
+	if a.Cardinality() != 3 {
+		t.Error("AppendSet does not have a size of 3 even though 3 items were added to a new set")
+	}
+}
+
 func Test_AddSetNoDuplicate(t *testing.T) {
 	a := makeSetInt([]int{7, 5, 3, 7})
 
@@ -112,6 +140,30 @@ func Test_AddUnsafeSetNoDuplicate(t *testing.T) {
 	}
 }
 
+func Test_AppendSetNoDuplicate(t *testing.T) {
+	a := makeSetIntWithAppend(7, 5, 3, 7)
+
+	if a.Cardinality() != 3 {
+		t.Error("AppendSetNoDuplicate set should have 3 elements since 7 is a duplicate")
+	}
+
+	if !(a.Contains(7) && a.Contains(5) && a.Contains(3)) {
+		t.Error("AppendSetNoDuplicate set should have a 7, 5, and 3 in it.")
+	}
+}
+
+func Test_AppendUnsafeSetNoDuplicate(t *testing.T) {
+	a := makeUnsafeSetIntWithAppend(7, 5, 3, 7)
+
+	if a.Cardinality() != 3 {
+		t.Error("AppendSetNoDuplicate set should have 3 elements since 7 is a duplicate")
+	}
+
+	if !(a.Contains(7) && a.Contains(5) && a.Contains(3)) {
+		t.Error("AppendSetNoDuplicate set should have a 7, 5, and 3 in it.")
+	}
+}
+
 func Test_RemoveSet(t *testing.T) {
 	a := makeSetInt([]int{6, 3, 1})
 

threadsafe.go

@@ -45,10 +45,18 @@ func (t *threadSafeSet[T]) Add(v T) bool {
 	return ret
 }
 
+func (t *threadSafeSet[T]) Append(v ...T) int {
+	t.Lock()
+	ret := t.uss.Append(v...)
+	t.Unlock()
+	return ret
+}
+
 func (t *threadSafeSet[T]) Contains(v ...T) bool {
 	t.RLock()
 	ret := t.uss.Contains(v...)
 	t.RUnlock()
+
 	return ret
 }
 

threadsafe_test.go

@@ -59,6 +59,30 @@ func Test_AddConcurrent(t *testing.T) {
 	}
 }
 
+func Test_AppendConcurrent(t *testing.T) {
+	runtime.GOMAXPROCS(2)
+
+	s := NewSet[int]()
+	ints := rand.Perm(N)
+
+	n := len(ints) >> 1
+	var wg sync.WaitGroup
+	wg.Add(n)
+	for i := 0; i < n; i++ {
+		go func(i int) {
+			s.Append(i, N-i-1)
+			wg.Done()
+		}(i)
+	}
+
+	wg.Wait()
+	for _, i := range ints {
+		if !s.Contains(i) {
+			t.Errorf("Set is missing element: %v", i)
+		}
+	}
+}
+
 func Test_CardinalityConcurrent(t *testing.T) {
 	runtime.GOMAXPROCS(2)
 

threadunsafe.go

@@ -47,6 +47,14 @@ func (s threadUnsafeSet[T]) Add(v T) bool {
 	return prevLen != len(s)
 }
 
+func (s threadUnsafeSet[T]) Append(v ...T) int {
+	prevLen := len(s)
+	for _, val := range v {
+		(s)[val] = struct{}{}
+	}
+	return len(s) - prevLen
+}
+
 // private version of Add which doesn't return a value
 func (s threadUnsafeSet[T]) add(v T) {
 	s[v] = struct{}{}