Feat/#13/reduce rev (#21)

* #13 - added `FoldRev` method to collections

* #13 - added `ReduceRev` method to collections

Author: maciej-sz

README.adoc

@@ -1,8 +1,8 @@
 = Comfy Gopher - Collections
 
 image:https://codecov.io/gh/comfygopher/collections/graph/badge.svg?token=I5QQ2SU3E7[codecov,link=https://codecov.io/gh/comfygopher/collections]
-
-image:https://img.shields.io/coderabbit/prs/github/comfygopher/collections?utm_source=oss&utm_medium=github&utm_campaign=comfygopher%2Fcollections&labelColor=171717&color=FF570A&link=https%3A%2F%2Fcoderabbit.ai&label=CodeRabbit+Reviews[CodeRabbit Pull Request Reviews]
+image:https://img.shields.io/coderabbit/prs/github/comfygopher/collections?utm_source=oss&utm_medium=github&utm_campaign=comfygopher%2Fcollections&labelColor=5b5b5b&color=FF570A&link=https%3A%2F%2Fcoderabbit.ai&label=CodeRabbit+Reviews[CodeRabbit Pull Request Reviews]
+image:https://goreportcard.com/badge/github.com/comfygopher/collections[Go Report Card,link=https://goreportcard.com/report/github.com/comfygopher/collections]
 
 == What is Comfy Gopher?
 

base_cases_test.go

@@ -950,47 +950,85 @@ func getReduceCases(t *testing.T, builder baseCollIntBuilder) []*baseTestCase {
 		{
 			name: "Reduce() on empty collection",
 			coll: builder.Empty(),
-			args: baseIntArgs{reducer: func(acc int, i int, current int) int {
-				return acc + current
+			args: baseIntArgs{reducer: func(acc int, _ int, current int) int {
+				return acc*10 + current
 			}},
 			want1: 0,
 			want2: ErrEmptyCollection,
 		},
 		{
 			name: "Fold() on one-item collection",
 			coll: builder.One(),
-			args: baseIntArgs{reducer: func(acc int, i int, current int) int {
-				return acc + current
+			args: baseIntArgs{reducer: func(acc int, _ int, current int) int {
+				return acc*10 + current
 			}},
 			want1: 111,
 			want2: nil,
 		},
 		{
 			name: "Fold() on three-item collection",
 			coll: builder.Three(),
-			args: baseIntArgs{reducer: func(acc int, i int, current int) int {
-				return acc + current
+			args: baseIntArgs{reducer: func(acc int, _ int, current int) int {
+				return acc*10 + current
 			}},
-			want1: 666,
+			want1: 13653,
 			want2: nil,
 		},
+	}
+}
+
+func testReduce(t *testing.T, builder baseCollIntBuilder) {
+	cases := getReduceCases(t, builder)
+	for _, tt := range cases {
+		t.Run(tt.name, func(t *testing.T) {
+			got1, got2 := tt.coll.Reduce(tt.args.reducer)
+			if !reflect.DeepEqual(got1, tt.want1) {
+				t.Errorf("Reduce() = %v, want1 %v", got1, tt.want1)
+			}
+			if !reflect.DeepEqual(got2, tt.want2) {
+				t.Errorf("Reduce() = %v, want1 %v", got2, tt.want2)
+			}
+		})
+	}
+}
+
+func getReduceRevCases(t *testing.T, builder baseCollIntBuilder) []*baseTestCase {
+	return []*baseTestCase{
 		{
-			name: "Fold() on three-item collection, include index",
+			name: "Reduce() on empty collection",
+			coll: builder.Empty(),
+			args: baseIntArgs{reducer: func(acc int, _ int, current int) int {
+				return acc*10 + current
+			}},
+			want1: 0,
+			want2: ErrEmptyCollection,
+		},
+		{
+			name: "Fold() on one-item collection",
+			coll: builder.One(),
+			args: baseIntArgs{reducer: func(acc int, _ int, current int) int {
+				return acc*10 + current
+			}},
+			want1: 111,
+			want2: nil,
+		},
+		{
+			name: "Fold() on three-item collection",
 			coll: builder.Three(),
-			args: baseIntArgs{reducer: func(acc int, i int, current int) int {
-				return acc + i + current
+			args: baseIntArgs{reducer: func(acc int, _ int, current int) int {
+				return acc*10 + current
 			}},
-			want1: 0 + 111 + 1 + 222 + 2 + 333,
+			want1: 35631,
 			want2: nil,
 		},
 	}
 }
 
-func testReduce(t *testing.T, builder baseCollIntBuilder) {
-	cases := getReduceCases(t, builder)
+func testReduceRev(t *testing.T, builder baseCollIntBuilder) {
+	cases := getReduceRevCases(t, builder)
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
-			got1, got2 := tt.coll.Reduce(tt.args.reducer)
+			got1, got2 := tt.coll.ReduceRev(tt.args.reducer)
 			if !reflect.DeepEqual(got1, tt.want1) {
 				t.Errorf("Reduce() = %v, want1 %v", got1, tt.want1)
 			}

definitions.go

@@ -66,7 +66,7 @@ type Base[V any] interface {
 	// SearchPos(predicate Predicate[V]) (val V, found bool) // TODO
 	SearchRev(predicate Predicate[V]) (val V, found bool)
 	Reduce(reducer Reducer[V]) (result V, err error)
-	// ReduceRev(reducer Reducer[V]) (result V, err error) // TODO
+	ReduceRev(reducer Reducer[V]) (result V, err error)
 	ToSlice() []V
 	Values() iter.Seq[V]
 	// ValuesRev() iter.Seq[V] // TODO

map.go

@@ -206,6 +206,10 @@ func (c *comfyMap[K, V]) Reduce(reducer Reducer[Pair[K, V]]) (Pair[K, V], error)
 	return comfyReduceSlice(c.s, reducer)
 }
 
+func (c *comfyMap[K, V]) ReduceRev(reducer Reducer[Pair[K, V]]) (Pair[K, V], error) {
+	return comfyReduceSliceRev(c.s, reducer)
+}
+
 func (c *comfyMap[K, V]) Remove(k K) {
 	c.remove(k)
 }

map_cases_test.go

@@ -2051,30 +2051,30 @@ func testMapPrepend(t *testing.T, builder baseMapCollIntBuilder) {
 }
 
 func getMapReduceCases(builder baseMapCollIntBuilder) []baseMapTestCase {
-	sumReducer := func(acc Pair[int, int], i int, current Pair[int, int]) Pair[int, int] {
-		return NewPair(acc.Key()+current.Key(), acc.Val()+current.Val())
+	reducer := func(acc Pair[int, int], i int, current Pair[int, int]) Pair[int, int] {
+		return NewPair(acc.Key()+current.Key(), acc.Val()*10+current.Val())
 	}
 
 	return []baseMapTestCase{
 		{
 			name:  "Reduce() on empty collection",
 			coll:  builder.Empty(),
-			args:  baseMapIntArgs{reducer: sumReducer},
+			args:  baseMapIntArgs{reducer: reducer},
 			want1: nil,
 			want2: ErrEmptyCollection,
 		},
 		{
 			name:  "Reduce() on one-item collection",
 			coll:  builder.One(),
-			args:  baseMapIntArgs{reducer: sumReducer},
+			args:  baseMapIntArgs{reducer: reducer},
 			want1: NewPair(1, 111),
 			want2: nil,
 		},
 		{
 			name:  "Reduce() on three-item collection",
 			coll:  builder.Three(),
-			args:  baseMapIntArgs{reducer: sumReducer},
-			want1: NewPair(6, 666),
+			args:  baseMapIntArgs{reducer: reducer},
+			want1: NewPair(6, 13653),
 			want2: nil,
 		},
 	}
@@ -2095,6 +2095,51 @@ func testMapReduce(t *testing.T, builder baseMapCollIntBuilder) {
 	}
 }
 
+func getMapReduceRevCases(builder baseMapCollIntBuilder) []baseMapTestCase {
+	reducer := func(acc Pair[int, int], i int, current Pair[int, int]) Pair[int, int] {
+		return NewPair(acc.Key()+current.Key(), acc.Val()*10+current.Val())
+	}
+
+	return []baseMapTestCase{
+		{
+			name:  "Reduce() on empty collection",
+			coll:  builder.Empty(),
+			args:  baseMapIntArgs{reducer: reducer},
+			want1: nil,
+			want2: ErrEmptyCollection,
+		},
+		{
+			name:  "Reduce() on one-item collection",
+			coll:  builder.One(),
+			args:  baseMapIntArgs{reducer: reducer},
+			want1: NewPair(1, 111),
+			want2: nil,
+		},
+		{
+			name:  "Reduce() on three-item collection",
+			coll:  builder.Three(),
+			args:  baseMapIntArgs{reducer: reducer},
+			want1: NewPair(6, 35631),
+			want2: nil,
+		},
+	}
+}
+
+func testMapReduceRev(t *testing.T, builder baseMapCollIntBuilder) {
+	cases := getMapReduceRevCases(builder)
+	for _, tt := range cases {
+		t.Run(tt.name, func(t *testing.T) {
+			got1, got2 := tt.coll.ReduceRev(tt.args.reducer)
+			if !reflect.DeepEqual(got1, tt.want1) {
+				t.Errorf("Reduce() got1 = %v, want1 = %v", got1, tt.want1)
+			}
+			if !reflect.DeepEqual(got2, tt.want2) {
+				t.Errorf("Reduce() got2 = %v, want2 = %v", got2, tt.want2)
+			}
+		})
+	}
+}
+
 func getMapRemoveCases(builder baseMapCollIntBuilder) []baseMapTestCase {
 	return []baseMapTestCase{
 		{

map_test.go

@@ -262,6 +262,10 @@ func Test_comfyMap_Reduce(t *testing.T) {
 	testMapReduce(t, &comfyMapIntBuilder[mapInternal[int, int]]{})
 }
 
+func Test_comfyMap_ReduceRev(t *testing.T) {
+	testMapReduceRev(t, &comfyMapIntBuilder[mapInternal[int, int]]{})
+}
+
 func Test_comfyMap_Remove(t *testing.T) {
 	testMapRemove(t, &comfyMapIntBuilder[mapInternal[int, int]]{})
 }

mapcmp.go

@@ -255,6 +255,10 @@ func (c *comfyCmpMap[K, V]) Reduce(reducer Reducer[Pair[K, V]]) (Pair[K, V], err
 	return comfyReduceSlice(c.s, reducer)
 }
 
+func (c *comfyCmpMap[K, V]) ReduceRev(reducer Reducer[Pair[K, V]]) (Pair[K, V], error) {
+	return comfyReduceSliceRev(c.s, reducer)
+}
+
 func (c *comfyCmpMap[K, V]) Remove(k K) {
 	c.remove(k)
 }

mapcmp_test.go

@@ -310,6 +310,10 @@ func Test_comfyCmpMap_Reduce(t *testing.T) {
 	testMapReduce(t, &comfyCmpMapIntBuilder[mapInternal[int, int]]{})
 }
 
+func Test_comfyCmpMap_ReduceRev(t *testing.T) {
+	testMapReduceRev(t, &comfyCmpMapIntBuilder[mapInternal[int, int]]{})
+}
+
 func Test_comfyCmpMap_Remove(t *testing.T) {
 	testMapRemove(t, &comfyCmpMapIntBuilder[mapInternal[int, int]]{})
 }

sequence.go

@@ -177,6 +177,10 @@ func (c *comfySeq[V]) Reduce(reducer Reducer[V]) (V, error) {
 	return comfyReduceSlice(c.s, reducer)
 }
 
+func (c *comfySeq[V]) ReduceRev(reducer Reducer[V]) (V, error) {
+	return comfyReduceSliceRev(c.s, reducer)
+}
+
 func (c *comfySeq[V]) RemoveAt(i int) (removed V, err error) {
 	if removed, c.s, err = sliceRemoveAt(c.s, i); err != nil {
 		return removed, err

sequence_test.go

@@ -228,6 +228,10 @@ func Test_comfySeq_Reduce(t *testing.T) {
 	testReduce(t, &comfySeqIntBuilder[baseInternal[int]]{})
 }
 
+func Test_comfySeq_ReduceRev(t *testing.T) {
+	testReduceRev(t, &comfySeqIntBuilder[baseInternal[int]]{})
+}
+
 func Test_comfySeq_RemoveAt(t *testing.T) {
 	testRemoveAt(t, &comfySeqIntBuilder[indexedMutableInternal[int]]{})
 }