#13 - RemoveMatching methods return the number of removed items (#31)

maciej-sz · web-flow · commit 015875435f82 · 2025-03-17T21:38:32.000+01:00
* #13 - RemoveMatching methods return the number of removed items * #13 - Fix test to check the removed items count
diff --git a/common_test.go b/common_test.go
@@ -34,6 +34,7 @@ type testCase[C any, V any] struct {
 	want2       any
 	want3       any
 	want4       any
+	want5       any
 	got1        any
 	got2        any
 	got3        any
diff --git a/definitions.go b/definitions.go
@@ -89,7 +89,7 @@ type Mutable[V any] interface {
 	Clear()
 
 	// RemoveMatching removes all elements that match the given predicate.
-	RemoveMatching(predicate Predicate[V]) // TODO: return count of removed items
+	RemoveMatching(predicate Predicate[V]) (count int)
 }
 
 // IndexedMutable is a mutable collection that can be modified based on the indexes.
diff --git a/functions_internal.go b/functions_internal.go
@@ -58,17 +58,20 @@ func sliceRemoveAt[V any](s []V, i int) (removed V, newSLice []V, err error) {
 }
 
 // sliceRemoveMatching removes all elements for which the predicate returns true.
-func sliceRemoveMatching[V any](s []V, predicate Predicate[V]) []V {
+func sliceRemoveMatching[V any](s []V, predicate Predicate[V]) ([]V, int) {
+	removed := 0
 	newS := make([]V, 0, len(s))
 	for _, v := range s {
 		if !predicate(v) {
 			newS = append(newS, v)
+		} else {
+			removed++
 		}
 	}
 
 	if len(newS) == 0 {
-		return []V(nil)
+		return []V(nil), removed
 	}
 
-	return newS
+	return newS, removed
 }
diff --git a/map.go b/map.go
@@ -148,7 +148,7 @@ func (c *comfyMap[K, V]) RemoveMany(keys []K) {
 	c.removeMany(keys)
 }
 
-func (c *comfyMap[K, V]) RemoveMatching(predicate Predicate[Pair[K, V]]) {
+func (c *comfyMap[K, V]) RemoveMatching(predicate Predicate[Pair[K, V]]) (count int) {
 	newS := []Pair[K, V](nil)
 	newM := make(map[K]Pair[K, V])
 	newKP := make(map[K]int)
@@ -160,12 +160,15 @@ func (c *comfyMap[K, V]) RemoveMatching(predicate Predicate[Pair[K, V]]) {
 			newM[pair.Key()] = pair
 			newKP[pair.Key()] = idx
 			idx++
+		} else {
+			count++
 		}
 	}
 
 	c.s = newS
 	c.m = newM
 	c.kp = newKP
+	return count
 }
 
 func (c *comfyMap[K, V]) Reverse() {
diff --git a/map_cases_test.go b/map_cases_test.go
@@ -1449,6 +1449,7 @@ func getMapRemoveMatchingCases(builder baseMapCollIntBuilder) []baseMapTestCase
 			want2: map[int]int{},
 			want3: map[int]int{},
 			want4: map[int]int{},
+			want5: 0,
 		},
 		{
 			name:  "RemoveMatching() on one-item collection, found",
@@ -1458,6 +1459,7 @@ func getMapRemoveMatchingCases(builder baseMapCollIntBuilder) []baseMapTestCase
 			want2: map[int]int{},
 			want3: map[int]int{},
 			want4: map[int]int{},
+			want5: 1,
 		},
 		{
 			name:  "RemoveMatching() on one-item collection, not found",
@@ -1467,6 +1469,7 @@ func getMapRemoveMatchingCases(builder baseMapCollIntBuilder) []baseMapTestCase
 			want2: map[int]int{1: 111},
 			want3: map[int]int{1: 0},
 			want4: map[int]int{111: 1},
+			want5: 0,
 		},
 		{
 			name:  "RemoveMatching() on three-item collection, found all",
@@ -1476,6 +1479,7 @@ func getMapRemoveMatchingCases(builder baseMapCollIntBuilder) []baseMapTestCase
 			want2: map[int]int{},
 			want3: map[int]int{},
 			want4: map[int]int{},
+			want5: 3,
 		},
 		{
 			name:  "RemoveMatching() on three-item collection, found none",
@@ -1485,6 +1489,7 @@ func getMapRemoveMatchingCases(builder baseMapCollIntBuilder) []baseMapTestCase
 			want2: map[int]int{1: 111, 2: 222, 3: 333},
 			want3: map[int]int{1: 0, 2: 1, 3: 2},
 			want4: map[int]int{111: 1, 222: 1, 333: 1},
+			want5: 0,
 		},
 		{
 			name:  "RemoveMatching() on three-item collection, found first",
@@ -1494,6 +1499,7 @@ func getMapRemoveMatchingCases(builder baseMapCollIntBuilder) []baseMapTestCase
 			want2: map[int]int{2: 222, 3: 333},
 			want3: map[int]int{2: 0, 3: 1},
 			want4: map[int]int{222: 1, 333: 1},
+			want5: 1,
 		},
 		{
 			name:  "RemoveMatching() on three-item collection, found middle",
@@ -1503,6 +1509,7 @@ func getMapRemoveMatchingCases(builder baseMapCollIntBuilder) []baseMapTestCase
 			want2: map[int]int{1: 111, 3: 333},
 			want3: map[int]int{1: 0, 3: 1},
 			want4: map[int]int{111: 1, 333: 1},
+			want5: 1,
 		},
 		{
 			name:  "RemoveMatching() on three-item collection, found last",
@@ -1512,6 +1519,17 @@ func getMapRemoveMatchingCases(builder baseMapCollIntBuilder) []baseMapTestCase
 			want2: map[int]int{1: 111, 2: 222},
 			want3: map[int]int{1: 0, 2: 1},
 			want4: map[int]int{111: 1, 222: 1},
+			want5: 1,
+		},
+		{
+			name:  "RemoveMatching() on three-item collection, found even",
+			coll:  builder.Three(),
+			args:  baseMapIntArgs{predicate: func(p Pair[int, int]) bool { return p.Val()%2 != 0 }},
+			want1: []Pair[int, int]{NewPair(2, 222)},
+			want2: map[int]int{2: 222},
+			want3: map[int]int{2: 0},
+			want4: map[int]int{222: 1},
+			want5: 2,
 		},
 	}
 }
@@ -1520,7 +1538,7 @@ func testMapRemoveMatching(t *testing.T, builder baseMapCollIntBuilder) {
 	cases := getMapRemoveMatchingCases(builder)
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
-			tt.coll.RemoveMatching(tt.args.predicate)
+			count := tt.coll.RemoveMatching(tt.args.predicate)
 			actualSlice := builder.extractUnderlyingSlice(tt.coll)
 			actualMap := builder.extractUnderlyingMap(tt.coll)
 			actualKP := builder.extractUnderlyingKp(tt.coll)
@@ -1539,6 +1557,9 @@ func testMapRemoveMatching(t *testing.T, builder baseMapCollIntBuilder) {
 					t.Errorf("RemoveMatching() did not remove correctly from values counter")
 				}
 			}
+			if count != tt.want5 {
+				t.Errorf("RemoveMatching() returned wrong count: %v, but wanted = %v", count, tt.want5)
+			}
 		})
 	}
 }
diff --git a/mapcmp.go b/mapcmp.go
@@ -190,7 +190,7 @@ func (c *comfyCmpMap[K, V]) RemoveMany(keys []K) {
 	c.removeMany(keys)
 }
 
-func (c *comfyCmpMap[K, V]) RemoveMatching(predicate Predicate[Pair[K, V]]) {
+func (c *comfyCmpMap[K, V]) RemoveMatching(predicate Predicate[Pair[K, V]]) (count int) {
 	newS := []Pair[K, V](nil)
 	newM := make(map[K]Pair[K, V])
 	newKP := make(map[K]int)
@@ -204,13 +204,16 @@ func (c *comfyCmpMap[K, V]) RemoveMatching(predicate Predicate[Pair[K, V]]) {
 			newKP[pair.Key()] = idx
 			newVC.Increment(pair.Val())
 			idx++
+		} else {
+			count++
 		}
 	}
 
 	c.s = newS
 	c.m = newM
 	c.kp = newKP
 	c.vc = newVC
+	return count
 }
 
 func (c *comfyCmpMap[K, V]) RemoveValues(v V) {
diff --git a/mutable_cases_test.go b/mutable_cases_test.go
@@ -111,48 +111,55 @@ func getRemoveMatchingCases(builder mutableIntTestBuilder) []mutableIntTestCase
 			args:  mutableIntTestArgs{predicate: func(v int) bool { return true }},
 			want1: []int(nil),
 			want2: map[int]int{},
+			want3: 0,
 		},
 		{
 			name:  "RemoveMatching() on one-item collection",
 			coll:  builder.One(),
 			args:  mutableIntTestArgs{predicate: func(v int) bool { return v == 111 }},
 			want1: []int(nil),
 			want2: map[int]int{},
+			want3: 1,
 		},
 		{
 			name:  "RemoveMatching() on three-item collection",
 			coll:  builder.Three(),
 			args:  mutableIntTestArgs{predicate: func(v int) bool { return v == 222 }},
 			want1: []int{111, 333},
 			want2: map[int]int{111: 1, 333: 1},
+			want3: 1,
 		},
 		{
 			name:  "RemoveMatching() on three-item collection, all false",
 			coll:  builder.Three(),
 			args:  mutableIntTestArgs{predicate: func(v int) bool { return false }},
 			want1: []int{111, 222, 333},
 			want2: map[int]int{111: 1, 222: 1, 333: 1},
+			want3: 0,
 		},
 		{
 			name:  "RemoveMatching() on three-item collection, all true",
 			coll:  builder.Three(),
 			args:  mutableIntTestArgs{predicate: func(v int) bool { return true }},
 			want1: []int(nil),
 			want2: map[int]int{},
+			want3: 3,
 		},
 		{
 			name:  "RemoveMatching() on three-item collection, some mod 2",
 			coll:  builder.Three(),
 			args:  mutableIntTestArgs{predicate: func(v int) bool { return v%2 == 0 }},
 			want1: []int{111, 333},
 			want2: map[int]int{111: 1, 333: 1},
+			want3: 1,
 		},
 		{
 			name:  "RemoveMatching() on three-item collection, some not mod 2",
 			coll:  builder.Three(),
 			args:  mutableIntTestArgs{predicate: func(v int) bool { return v%2 != 0 }},
 			want1: []int{222},
 			want2: map[int]int{222: 1},
+			want3: 2,
 		},
 	}
 }
@@ -161,7 +168,7 @@ func testRemoveMatching(t *testing.T, builder mutableIntTestBuilder) {
 	cases := getRemoveMatchingCases(builder)
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
-			tt.coll.RemoveMatching(tt.args.predicate)
+			count := tt.coll.RemoveMatching(tt.args.predicate)
 
 			actualSlice := builder.extractUnderlyingSlice(tt.coll)
 			actualVC := builder.extractUnderlyingValsCount(tt.coll)
@@ -172,6 +179,9 @@ func testRemoveMatching(t *testing.T, builder mutableIntTestBuilder) {
 			if actualVC != nil && !reflect.DeepEqual(actualVC, tt.want2) {
 				t.Errorf("RemoveMatching() did not remove correctly from values counter")
 			}
+			if count != tt.want3 {
+				t.Errorf("RemoveMatching() returned wrong count: %v, but wanted = %v", count, tt.want3)
+			}
 		})
 	}
 }
diff --git a/sequence.go b/sequence.go
@@ -93,8 +93,9 @@ func (c *comfySeq[V]) RemoveAt(i int) (removed V, err error) {
 	return removed, nil
 }
 
-func (c *comfySeq[V]) RemoveMatching(predicate Predicate[V]) {
-	c.s = sliceRemoveMatching(c.s, predicate)
+func (c *comfySeq[V]) RemoveMatching(predicate Predicate[V]) (count int) {
+	c.s, count = sliceRemoveMatching(c.s, predicate)
+	return count
 }
 
 func (c *comfySeq[V]) Reverse() {
diff --git a/sequencecmp.go b/sequencecmp.go
@@ -140,17 +140,20 @@ func (c *comfyCmpSeq[V]) RemoveAt(i int) (removed V, err error) {
 	return removed, nil
 }
 
-func (c *comfyCmpSeq[V]) RemoveMatching(predicate Predicate[V]) {
+func (c *comfyCmpSeq[V]) RemoveMatching(predicate Predicate[V]) (count int) {
 	newS := []V(nil)
 	newVC := newValuesCounter[V]()
 	for _, v := range c.s {
 		if !predicate(v) {
 			newS = append(newS, v)
 			newVC.Increment(v)
+		} else {
+			count++
 		}
 	}
 	c.s = newS
 	c.vc = newVC
+	return count
 }
 
 func (c *comfyCmpSeq[V]) RemoveValues(v V) {

Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ type Mutable[V any] interface {`
`89`	`89`	`Clear()`
`90`	`90`
`91`	`91`	`// RemoveMatching removes all elements that match the given predicate.`
`92`		`- RemoveMatching(predicate Predicate[V]) // TODO: return count of removed items`
	`92`	`+ RemoveMatching(predicate Predicate[V]) (count int)`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`// IndexedMutable is a mutable collection that can be modified based on the indexes.`
Original file line number	Diff line number	Diff line change
`@@ -58,17 +58,20 @@ func sliceRemoveAt[V any](s []V, i int) (removed V, newSLice []V, err error) {`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`// sliceRemoveMatching removes all elements for which the predicate returns true.`
`61`		`-func sliceRemoveMatching[V any](s []V, predicate Predicate[V]) []V {`
	`61`	`+func sliceRemoveMatching[V any](s []V, predicate Predicate[V]) ([]V, int) {`
	`62`	`+ removed := 0`
`62`	`63`	`newS := make([]V, 0, len(s))`
`63`	`64`	`for _, v := range s {`
`64`	`65`	`if !predicate(v) {`
`65`	`66`	`newS = append(newS, v)`
	`67`	`+ } else {`
	`68`	`+ removed++`
`66`	`69`	`}`
`67`	`70`	`}`
`68`	`71`
`69`	`72`	`if len(newS) == 0 {`
`70`		`- return []V(nil)`
	`73`	`+ return []V(nil), removed`
`71`	`74`	`}`
`72`	`75`
`73`		`- return newS`
	`76`	`+ return newS, removed`
`74`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,7 @@ func (c *comfyMap[K, V]) RemoveMany(keys []K) {`
`148`	`148`	`c.removeMany(keys)`
`149`	`149`	`}`
`150`	`150`
`151`		`-func (c *comfyMap[K, V]) RemoveMatching(predicate Predicate[Pair[K, V]]) {`
	`151`	`+func (c *comfyMap[K, V]) RemoveMatching(predicate Predicate[Pair[K, V]]) (count int) {`
`152`	`152`	`newS := []Pair[K, V](nil)`
`153`	`153`	`newM := make(map[K]Pair[K, V])`
`154`	`154`	`newKP := make(map[K]int)`
`@@ -160,12 +160,15 @@ func (c *comfyMap[K, V]) RemoveMatching(predicate Predicate[Pair[K, V]]) {`
`160`	`160`	`newM[pair.Key()] = pair`
`161`	`161`	`newKP[pair.Key()] = idx`
`162`	`162`	`idx++`
	`163`	`+ } else {`
	`164`	`+ count++`
`163`	`165`	`}`
`164`	`166`	`}`
`165`	`167`
`166`	`168`	`c.s = newS`
`167`	`169`	`c.m = newM`
`168`	`170`	`c.kp = newKP`
	`171`	`+ return count`
`169`	`172`	`}`
`170`	`173`
`171`	`174`	`func (c *comfyMap[K, V]) Reverse() {`
Original file line number	Diff line number	Diff line change
`@@ -190,7 +190,7 @@ func (c *comfyCmpMap[K, V]) RemoveMany(keys []K) {`
`190`	`190`	`c.removeMany(keys)`
`191`	`191`	`}`
`192`	`192`
`193`		`-func (c *comfyCmpMap[K, V]) RemoveMatching(predicate Predicate[Pair[K, V]]) {`
	`193`	`+func (c *comfyCmpMap[K, V]) RemoveMatching(predicate Predicate[Pair[K, V]]) (count int) {`
`194`	`194`	`newS := []Pair[K, V](nil)`
`195`	`195`	`newM := make(map[K]Pair[K, V])`
`196`	`196`	`newKP := make(map[K]int)`
`@@ -204,13 +204,16 @@ func (c *comfyCmpMap[K, V]) RemoveMatching(predicate Predicate[Pair[K, V]]) {`
`204`	`204`	`newKP[pair.Key()] = idx`
`205`	`205`	`newVC.Increment(pair.Val())`
`206`	`206`	`idx++`
	`207`	`+ } else {`
	`208`	`+ count++`
`207`	`209`	`}`
`208`	`210`	`}`
`209`	`211`
`210`	`212`	`c.s = newS`
`211`	`213`	`c.m = newM`
`212`	`214`	`c.kp = newKP`
`213`	`215`	`c.vc = newVC`
	`216`	`+ return count`
`214`	`217`	`}`
`215`	`218`
`216`	`219`	`func (c *comfyCmpMap[K, V]) RemoveValues(v V) {`
Original file line number	Diff line number	Diff line change
`@@ -93,8 +93,9 @@ func (c *comfySeq[V]) RemoveAt(i int) (removed V, err error) {`
`93`	`93`	`return removed, nil`
`94`	`94`	`}`
`95`	`95`
`96`		`-func (c *comfySeq[V]) RemoveMatching(predicate Predicate[V]) {`
`97`		`- c.s = sliceRemoveMatching(c.s, predicate)`
	`96`	`+func (c *comfySeq[V]) RemoveMatching(predicate Predicate[V]) (count int) {`
	`97`	`+ c.s, count = sliceRemoveMatching(c.s, predicate)`
	`98`	`+ return count`
`98`	`99`	`}`
`99`	`100`
`100`	`101`	`func (c *comfySeq[V]) Reverse() {`
Original file line number	Diff line number	Diff line change
`@@ -140,17 +140,20 @@ func (c *comfyCmpSeq[V]) RemoveAt(i int) (removed V, err error) {`
`140`	`140`	`return removed, nil`
`141`	`141`	`}`
`142`	`142`
`143`		`-func (c *comfyCmpSeq[V]) RemoveMatching(predicate Predicate[V]) {`
	`143`	`+func (c *comfyCmpSeq[V]) RemoveMatching(predicate Predicate[V]) (count int) {`
`144`	`144`	`newS := []V(nil)`
`145`	`145`	`newVC := newValuesCounter[V]()`
`146`	`146`	`for _, v := range c.s {`
`147`	`147`	`if !predicate(v) {`
`148`	`148`	`newS = append(newS, v)`
`149`	`149`	`newVC.Increment(v)`
	`150`	`+ } else {`
	`151`	`+ count++`
`150`	`152`	`}`
`151`	`153`	`}`
`152`	`154`	`c.s = newS`
`153`	`155`	`c.vc = newVC`
	`156`	`+ return count`
`154`	`157`	`}`
`155`	`158`
`156`	`159`	`func (c *comfyCmpSeq[V]) RemoveValues(v V) {`