bug(orderedmap): provide support for callbacks deleting items.

Author: fgm

orderedmap/slice.go

@@ -52,6 +52,21 @@ func (s *Slice[K, V]) Range(f func(key K, value V) bool) {
 	}
 }
 
+func (s *Slice[K, V]) RangeMutable(f func(key K, value V) bool) {
+	order := make([]K, len(s.order))
+	copy(order, s.order)
+	store := make(map[K]V, len(s.store))
+	for k, v := range s.store {
+		store[k] = v
+	}
+	snap := Slice[K, V]{
+		order:  order,
+		store:  store,
+		stable: s.stable,
+	}
+	snap.Range(f)
+}
+
 func (s *Slice[K, V]) Store(k K, v V) {
 	_, loaded := s.store[k]
 	if !loaded {

orderedmap/slice_transparent_test.go

@@ -109,18 +109,23 @@ func TestSlice_Range_Mutators(t *testing.T) {
 		}
 	}
 	tests := [...]struct {
-		name          string
-		fn            func(*testType) func(key, value int) bool
-		expectedPanic error
-		expected      []int
+		name            string
+		useRangeMutable bool
+		fn              func(*testType) func(key, value int) bool
+		expectedPanic   error
+		expected        []int
 	}{
-		{"nop/plain range", fnNop, nil, []int{0, 0, 0, 1, 1, 2, 2, 3, 3}},
+		{"nop/plain range", false, fnNop, nil, []int{0, 0, 0, 1, 1, 2, 2, 3, 3}},
+		{"nop/mutable", true, fnNop, nil, []int{0, 0, 0, 1, 1, 2, 2, 3, 3}},
 		// Mutating a value moves it to the end of the map.
-		{"mutateOne/plain range", fnMutateOne, nil, []int{0, 0, 0, 2, 2, 3, 3, 1, 10}},
+		{"mutateOne/plain range", false, fnMutateOne, nil, []int{0, 0, 0, 2, 2, 3, 3, 1, 10}},
+		{"mutateOne/mutable", false, fnMutateOne, nil, []int{0, 0, 0, 2, 2, 3, 3, 1, 10}},
 		// Store a value moves it to the end of the map.
-		{"insertOne/plain range", fnInsertOne, nil, []int{0, 0, 0, 1, 1, 2, 2, 3, 3, 10, 10}},
+		{"insertOne/plain range", false, fnInsertOne, nil, []int{0, 0, 0, 1, 1, 2, 2, 3, 3, 10, 10}},
+		{"insertOne/mutable", false, fnInsertOne, nil, []int{0, 0, 0, 1, 1, 2, 2, 3, 3, 10, 10}},
 		// This is why we need to some form of mutation support: observe the unexpected results.
-		{"deleteOdd/plain range", fnDeleteOdd, errors.New(""), []int{0, 0, 0, 2, 2}},
+		{"deleteOdd/plain range", false, fnDeleteOdd, errors.New(""), []int{0, 0, 0, 2, 2}},
+		{"deleteOdd/mutable", true, fnDeleteOdd, nil, []int{0, 0, 0, 2, 2}},
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
@@ -133,7 +138,11 @@ func TestSlice_Range_Mutators(t *testing.T) {
 						actualPanic = err.(error)
 					}
 				}()
-				input.Range(test.fn(&input))
+				if test.useRangeMutable {
+					input.RangeMutable(test.fn(&input))
+				} else {
+					input.Range(test.fn(&input))
+				}
 			}()
 			actual := transform(input)
 			t1, t2 := reflect.TypeOf(actualPanic), reflect.TypeOf(test.expectedPanic)

types.go

@@ -11,6 +11,12 @@ type OrderedMap[K comparable, V any] interface {
 	Store(key K, value V)
 }
 
+type OrderedMapWithRangeMutable[K comparable, V any] interface {
+	OrderedMap[K, V]
+	// RangeMutable allows its callbacks to delete map entries, operating on a snapshot.
+	RangeMutable(func(key K, value V) bool)
+}
+
 // Queue is a generic queue with no concurrency guarantees.
 // Instantiate by queue.New<implementation>Queue(sizeHint).
 // The size hint MAY be used by some implementations to optimize storage.