#13 - RemoveValues accepts multiple items and returns number of removed items (#32)

* #13 - RemoveValues accepts multiple items and returns number of removed items

* #13 - optimize empty case if values to remove is empty

* #13 - cr - optimize valuesCouter usage

Author: maciej-sz

README.adoc

@@ -18,7 +18,7 @@ making them well suited for rapid prototyping.
 
 1. Provide convenient abstraction for collection data structures
 1. Focus on developer experience
-1. Reduce repetition in day-to-day collections operations
+1. Reduce repetition of common collections operations
 1. Address the missing ordered map data structure
 1. Provide API for in-place modifications of collections
 1. Reduce strain of juggling between empty slice pointers `[]V(nil) vs []V{}`

cmpmutable_cases_test.go

@@ -17,62 +17,111 @@ func getRemoveValuesCases(builder cmpMutableCollIntBuilder) []cmpMutableTestCase
 			args:  cmpMutableIntArgs{value: 1},
 			want1: []int(nil),
 			want2: map[int]int{},
+			want3: 0,
 		},
 		{
 			name:  "RemoveValues() on one-item collection",
 			coll:  builder.One(),
 			args:  cmpMutableIntArgs{value: 111},
 			want1: []int(nil),
 			want2: map[int]int{},
+			want3: 1,
 		},
 		{
 			name:  "RemoveValues() on three-item collection - first item",
 			coll:  builder.Three(),
 			args:  cmpMutableIntArgs{value: 111},
 			want1: []int{222, 333},
 			want2: map[int]int{222: 1, 333: 1},
+			want3: 1,
 		},
 		{
 			name:  "RemoveValues() on three-item collection - second item",
 			coll:  builder.Three(),
 			args:  cmpMutableIntArgs{value: 222},
 			want1: []int{111, 333},
 			want2: map[int]int{111: 1, 333: 1},
+			want3: 1,
 		},
 		{
 			name:  "RemoveValues() on three-item collection - third item",
 			coll:  builder.Three(),
 			args:  cmpMutableIntArgs{value: 333},
 			want1: []int{111, 222},
 			want2: map[int]int{111: 1, 222: 1},
+			want3: 1,
 		},
 		{
 			name:  "RemoveValues() on three-item collection, not found",
 			coll:  builder.Three(),
 			args:  cmpMutableIntArgs{value: 999},
 			want1: []int{111, 222, 333},
 			want2: map[int]int{111: 1, 222: 1, 333: 1},
+			want3: 0,
 		},
 		{
 			name:  "RemoveValues() on six-item collection, 2 `111` found ",
 			coll:  builder.SixWithDuplicates(),
 			args:  cmpMutableIntArgs{value: 111},
 			want1: []int{222, 333, 222, 333},
 			want2: map[int]int{222: 2, 333: 2},
+			want3: 2,
 		},
 		{
 			name:  "RemoveValues() on six-item collection, 2 `222` found ",
 			coll:  builder.SixWithDuplicates(),
 			args:  cmpMutableIntArgs{value: 222},
 			want1: []int{111, 333, 111, 333},
 			want2: map[int]int{111: 2, 333: 2},
+			want3: 2,
 		},
 		{
 			name:  "RemoveValues() on six-item collection, 2 `333` found ",
 			coll:  builder.SixWithDuplicates(),
 			args:  cmpMutableIntArgs{value: 333},
 			want1: []int{111, 222, 111, 222},
 			want2: map[int]int{111: 2, 222: 2},
+			want3: 2,
+		},
+		{
+			name:  "RemoveValues() on six-item collection, one found",
+			coll:  builder.SixWithDuplicates(),
+			args:  cmpMutableIntArgs{values: []int{111}},
+			want1: []int{222, 333, 222, 333},
+			want2: map[int]int{222: 2, 333: 2},
+			want3: 2,
+		},
+		{
+			name:  "RemoveValues() on six-item collection, two found",
+			coll:  builder.SixWithDuplicates(),
+			args:  cmpMutableIntArgs{values: []int{111, 222}},
+			want1: []int{333, 333},
+			want2: map[int]int{333: 2},
+			want3: 4,
+		},
+		{
+			name:  "RemoveValues() on six-item collection, three found",
+			coll:  builder.SixWithDuplicates(),
+			args:  cmpMutableIntArgs{values: []int{111, 222, 333}},
+			want1: []int(nil),
+			want2: map[int]int{},
+			want3: 6,
+		},
+		{
+			name:  "RemoveValues() on six-item collection, none found",
+			coll:  builder.SixWithDuplicates(),
+			args:  cmpMutableIntArgs{values: []int{999, 888, 777}},
+			want1: []int{111, 222, 333, 111, 222, 333},
+			want2: map[int]int{111: 2, 222: 2, 333: 2},
+			want3: 0,
+		},
+		{
+			name:  "RemoveValues() on six-item collection, empty values",
+			coll:  builder.SixWithDuplicates(),
+			args:  cmpMutableIntArgs{values: []int{}},
+			want1: []int{111, 222, 333, 111, 222, 333},
+			want2: map[int]int{111: 2, 222: 2, 333: 2},
+			want3: 0,
 		},
 	}
 }
@@ -81,7 +130,12 @@ func testRemoveValues(t *testing.T, builder cmpMutableCollIntBuilder) {
 	cases := getRemoveValuesCases(builder)
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
-			tt.coll.RemoveValues(tt.args.value)
+			var count int
+			if tt.args.values != nil {
+				count = tt.coll.RemoveValues(tt.args.values...)
+			} else {
+				count = tt.coll.RemoveValues(tt.args.value)
+			}
 			actualSlice := builder.extractRawValues(tt.coll)
 			actualVC := builder.extractUnderlyingValsCount(tt.coll)
 			if !reflect.DeepEqual(actualSlice, tt.want1) {
@@ -90,6 +144,9 @@ func testRemoveValues(t *testing.T, builder cmpMutableCollIntBuilder) {
 			if !reflect.DeepEqual(actualVC, tt.want2) {
 				t.Errorf("RemoveValues() did not remove correctly from values counter")
 			}
+			if count != tt.want3 {
+				t.Errorf("RemoveValues() returned wrong count: %v, but wanted %v", count, tt.want3)
+			}
 		})
 	}
 }

definitions.go

@@ -89,6 +89,7 @@ type Mutable[V any] interface {
 	Clear()
 
 	// RemoveMatching removes all elements that match the given predicate.
+	// Returns the number of removed items.
 	RemoveMatching(predicate Predicate[V]) (count int)
 }
 
@@ -135,7 +136,8 @@ type CmpMutable[V cmp.Ordered] interface {
 	Cmp[V]
 
 	// RemoveValues removes all occurrences of the given value.
-	RemoveValues(v V) // TODO: replace with multiple values (v ...V)
+	// Returns the number of removed items.
+	RemoveValues(v ...V) (count int)
 
 	// SortAsc sorts the collection in ascending order.
 	SortAsc()

mapcmp.go

@@ -216,9 +216,24 @@ func (c *comfyCmpMap[K, V]) RemoveMatching(predicate Predicate[Pair[K, V]]) (cou
 	return count
 }
 
-func (c *comfyCmpMap[K, V]) RemoveValues(v V) {
-	c.RemoveMatching(func(pair Pair[K, V]) bool {
-		return pair.Val() == v
+func (c *comfyCmpMap[K, V]) RemoveValues(v ...V) (count int) {
+	toRemove := newValuesCounter[V]()
+	for _, v := range v {
+		if c.vc.Count(v) > 0 {
+			toRemove.Set(v, c.vc.Count(v))
+		}
+	}
+
+	if toRemove.IsEmpty() {
+		return 0
+	}
+
+	return c.RemoveMatching(func(pair Pair[K, V]) bool {
+		doRemove := toRemove.Count(pair.Val()) > 0
+		if doRemove {
+			toRemove.Decrement(pair.Val())
+		}
+		return doRemove
 	})
 }
 

sequencecmp.go

@@ -156,17 +156,35 @@ func (c *comfyCmpSeq[V]) RemoveMatching(predicate Predicate[V]) (count int) {
 	return count
 }
 
-func (c *comfyCmpSeq[V]) RemoveValues(v V) {
+func (c *comfyCmpSeq[V]) RemoveValues(v ...V) (count int) {
 	newS := []V(nil)
 	newVC := newValuesCounter[V]()
+
+	toRemove := newValuesCounter[V]()
+	for _, v := range v {
+		if c.vc.Count(v) > 0 {
+			toRemove.Set(v, c.vc.Count(v))
+		}
+	}
+
+	if toRemove.IsEmpty() {
+		return 0
+	}
+
 	for _, current := range c.s {
-		if current != v {
+		if toRemove.Count(current) == 0 {
 			newS = append(newS, current)
 			newVC.Increment(current)
+		} else {
+			count++
+			toRemove.Decrement(current)
 		}
 	}
+
 	c.s = newS
 	c.vc = newVC
+
+	return count
 }
 
 func (c *comfyCmpSeq[V]) Reverse() {

cmp.go vc.gocmp.go renamed to vc.go

@@ -1,6 +1,8 @@
 package coll
 
-import "cmp"
+import (
+	"cmp"
+)
 
 type valuesCounter[V cmp.Ordered] struct {
 	counter map[V]int
@@ -31,3 +33,15 @@ func (c *valuesCounter[V]) Decrement(v V) {
 		c.counter[v]--
 	}
 }
+
+func (c *valuesCounter[V]) Set(v V, count int) {
+	if count < 1 {
+		delete(c.counter, v)
+	} else {
+		c.counter[v] = count
+	}
+}
+
+func (c *valuesCounter[V]) IsEmpty() bool {
+	return len(c.counter) == 0
+}

vc_test.go

@@ -0,0 +1,11 @@
+package coll
+
+import "testing"
+
+func Test_valuesCounter_Set_WithZeroValue(t *testing.T) {
+	vc := newValuesCounter[int]()
+	vc.Set(1, 0)
+	if len(vc.counter) != 0 {
+		t.Error("Set() did not remove the value when count is 0")
+	}
+}