Skip to content

Commit 823c8ac

Browse files
hsldymqhsldymq
committed
add Through methods
1 parent 45b7483 commit 823c8ac

File tree

3 files changed

+181
-147
lines changed

3 files changed

+181
-147
lines changed

‎iterator.go

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -59,3 +59,7 @@ func (it Iterator[T]) Count() int {
5959
func (it Iterator[T]) ToSlice() []T {
6060
return ToSlice(it)
6161
}
62+
63+
func (it Iterator[T]) Through(f func(T) T) Iterator[T] {
64+
return Transform(it, f)
65+
}

‎iterator2.go

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -59,3 +59,7 @@ func (it Iterator2[T1, T2]) Reverse() Iterator2[T1, T2] {
5959
func (it Iterator2[T1, T2]) Count() int {
6060
return Count2(it)
6161
}
62+
63+
func (it Iterator2[T1, T2]) Through(f func(T1, T2) (T1, T2)) Iterator2[T1, T2] {
64+
return Transform2(it, f)
65+
}

‎transformation_test.go

Lines changed: 173 additions & 147 deletions
Original file line numberDiff line numberDiff line change
@@ -3,172 +3,198 @@
33
package goiter
44

55
import (
6-
"fmt"
7-
"maps"
8-
"slices"
9-
"testing"
6+
"fmt"
7+
"maps"
8+
"slices"
9+
"testing"
1010
)
1111

1212
func TestPick1(t *testing.T) {
13-
actual := make([]int, 0, 3)
14-
for idx := range PickV1(Slice([]int{7, 8, 9})).Seq() {
15-
actual = append(actual, idx)
16-
}
17-
18-
expect := []int{0, 1, 2}
19-
if !slices.Equal(expect, actual) {
20-
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
21-
}
13+
actual := make([]int, 0, 3)
14+
for idx := range PickV1(Slice([]int{7, 8, 9})).Seq() {
15+
actual = append(actual, idx)
16+
}
17+
18+
expect := []int{0, 1, 2}
19+
if !slices.Equal(expect, actual) {
20+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
21+
}
2222
}
2323

2424
func TestPick2(t *testing.T) {
25-
actual := make([]int, 0, 3)
26-
for v := range PickV2(Slice([]int{7, 8, 9})) {
27-
actual = append(actual, v)
28-
}
29-
30-
expect := []int{7, 8, 9}
31-
if !slices.Equal(expect, actual) {
32-
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
33-
}
25+
actual := make([]int, 0, 3)
26+
for v := range PickV2(Slice([]int{7, 8, 9})) {
27+
actual = append(actual, v)
28+
}
29+
30+
expect := []int{7, 8, 9}
31+
if !slices.Equal(expect, actual) {
32+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
33+
}
3434
}
3535

3636
func TestSwap(t *testing.T) {
37-
input := map[string]int{"1": 1, "2": 2}
38-
actual := make(map[int]string)
39-
for val, key := range Swap(Map(input)).Seq() {
40-
actual[val] = key
41-
}
42-
expect := map[int]string{1: "1", 2: "2"}
43-
if !maps.Equal(expect, actual) {
44-
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
45-
}
37+
input := map[string]int{"1": 1, "2": 2}
38+
actual := make(map[int]string)
39+
for val, key := range Swap(Map(input)).Seq() {
40+
actual[val] = key
41+
}
42+
expect := map[int]string{1: "1", 2: "2"}
43+
if !maps.Equal(expect, actual) {
44+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
45+
}
4646
}
4747

4848
func TestTransform(t *testing.T) {
49-
transformFunc := func(v int) string {
50-
return fmt.Sprintf("%d", v)
51-
}
52-
53-
actual := make([]string, 0, 3)
54-
for v := range Transform(SliceElem([]int{1, 2, 3}), transformFunc) {
55-
actual = append(actual, v)
56-
}
57-
expect := []string{"1", "2", "3"}
58-
if !slices.Equal(expect, actual) {
59-
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
60-
}
61-
62-
actual = make([]string, 0, 2)
63-
i := 0
64-
for v := range Transform(SliceElem([]int{1, 2, 3}), transformFunc) {
65-
actual = append(actual, v)
66-
i++
67-
if i >= 2 {
68-
break
69-
}
70-
}
71-
expect = []string{"1", "2"}
72-
if !slices.Equal(expect, actual) {
73-
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
74-
}
49+
transformFunc := func(v int) string {
50+
return fmt.Sprintf("%d", v)
51+
}
52+
53+
actual := make([]string, 0, 3)
54+
for v := range Transform(SliceElem([]int{1, 2, 3}), transformFunc) {
55+
actual = append(actual, v)
56+
}
57+
expect := []string{"1", "2", "3"}
58+
if !slices.Equal(expect, actual) {
59+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
60+
}
61+
62+
transformFunc2 := func(v int) int { return v * 2 }
63+
actual2 := make([]int, 0, 3)
64+
for v := range SliceElem([]int{1, 2, 3}).Through(transformFunc2) {
65+
actual2 = append(actual2, v)
66+
}
67+
expect2 := []int{2, 4, 6}
68+
if !slices.Equal(expect2, actual2) {
69+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect2, actual2))
70+
}
71+
72+
actual = make([]string, 0, 2)
73+
i := 0
74+
for v := range Transform(SliceElem([]int{1, 2, 3}), transformFunc) {
75+
actual = append(actual, v)
76+
i++
77+
if i >= 2 {
78+
break
79+
}
80+
}
81+
expect = []string{"1", "2"}
82+
if !slices.Equal(expect, actual) {
83+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
84+
}
7585
}
7686

7787
func TestTransform2(t *testing.T) {
78-
transformFunc := func(k int, v int) (string, string) {
79-
return fmt.Sprintf("%d", k+10), fmt.Sprintf("%d", v+100)
80-
}
81-
82-
actualV1 := make([]string, 0, 3)
83-
actualV2 := make([]string, 0, 3)
84-
for v1, v2 := range Transform2(Slice([]int{1, 2, 3}), transformFunc) {
85-
actualV1 = append(actualV1, v1)
86-
actualV2 = append(actualV2, v2)
87-
}
88-
expectV1 := []string{"10", "11", "12"}
89-
if !slices.Equal(expectV1, actualV1) {
90-
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV1, actualV1))
91-
}
92-
expectV2 := []string{"101", "102", "103"}
93-
if !slices.Equal(expectV2, actualV2) {
94-
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV2, actualV2))
95-
}
96-
97-
actualV2 = make([]string, 0, 3)
98-
i := 0
99-
for _, v := range Transform2(Slice([]int{1, 2, 3}), transformFunc) {
100-
actualV2 = append(actualV2, v)
101-
i++
102-
if i >= 2 {
103-
break
104-
}
105-
}
106-
expectV2 = []string{"101", "102"}
107-
if !slices.Equal(expectV2, actualV2) {
108-
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV2, actualV2))
109-
}
88+
transformFunc := func(k int, v int) (string, string) {
89+
return fmt.Sprintf("%d", k+10), fmt.Sprintf("%d", v+100)
90+
}
91+
92+
actualV1 := make([]string, 0, 3)
93+
actualV2 := make([]string, 0, 3)
94+
for v1, v2 := range Transform2(Slice([]int{1, 2, 3}), transformFunc) {
95+
actualV1 = append(actualV1, v1)
96+
actualV2 = append(actualV2, v2)
97+
}
98+
expectV1 := []string{"10", "11", "12"}
99+
if !slices.Equal(expectV1, actualV1) {
100+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV1, actualV1))
101+
}
102+
expectV2 := []string{"101", "102", "103"}
103+
if !slices.Equal(expectV2, actualV2) {
104+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV2, actualV2))
105+
}
106+
107+
transformFunc2 := func(v1 int, v2 int) (int, int) { return v1 * 10, v2 * 100 }
108+
actualV21 := make([]int, 0, 3)
109+
actualV22 := make([]int, 0, 3)
110+
for v1, v2 := range Slice([]int{1, 2, 3}).Through(transformFunc2) {
111+
actualV21 = append(actualV21, v1)
112+
actualV22 = append(actualV22, v2)
113+
}
114+
expectV21 := []int{0, 10, 20}
115+
if !slices.Equal(expectV21, actualV21) {
116+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV21, actualV21))
117+
}
118+
expectV22 := []int{100, 200, 300}
119+
if !slices.Equal(expectV22, actualV22) {
120+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV22, actualV22))
121+
}
122+
123+
actualV2 = make([]string, 0, 3)
124+
i := 0
125+
for _, v := range Transform2(Slice([]int{1, 2, 3}), transformFunc) {
126+
actualV2 = append(actualV2, v)
127+
i++
128+
if i >= 2 {
129+
break
130+
}
131+
}
132+
expectV2 = []string{"101", "102"}
133+
if !slices.Equal(expectV2, actualV2) {
134+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV2, actualV2))
135+
}
110136
}
111137

112138
func TestTransform12(t *testing.T) {
113-
transformFunc := func(v int) (int, string) {
114-
return v + 10, fmt.Sprintf("%d", v)
115-
}
116-
117-
actualV1 := make([]int, 0, 3)
118-
actualV2 := make([]string, 0, 3)
119-
for v1, v2 := range Transform12(SliceElem([]int{1, 2, 3}), transformFunc) {
120-
actualV1 = append(actualV1, v1)
121-
actualV2 = append(actualV2, v2)
122-
}
123-
expectV1 := []int{11, 12, 13}
124-
if !slices.Equal(expectV1, actualV1) {
125-
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV1, actualV1))
126-
}
127-
expectV2 := []string{"1", "2", "3"}
128-
if !slices.Equal(expectV2, actualV2) {
129-
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV2, actualV2))
130-
}
131-
132-
actualV1 = make([]int, 0, 3)
133-
i := 0
134-
for v1, _ := range Transform12(SliceElem([]int{1, 2, 3}), transformFunc) {
135-
actualV1 = append(actualV1, v1)
136-
i++
137-
if i >= 2 {
138-
break
139-
}
140-
}
141-
expectV1 = []int{11, 12}
142-
if !slices.Equal(expectV1, actualV1) {
143-
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV1, actualV1))
144-
}
139+
transformFunc := func(v int) (int, string) {
140+
return v + 10, fmt.Sprintf("%d", v)
141+
}
142+
143+
actualV1 := make([]int, 0, 3)
144+
actualV2 := make([]string, 0, 3)
145+
for v1, v2 := range Transform12(SliceElem([]int{1, 2, 3}), transformFunc) {
146+
actualV1 = append(actualV1, v1)
147+
actualV2 = append(actualV2, v2)
148+
}
149+
expectV1 := []int{11, 12, 13}
150+
if !slices.Equal(expectV1, actualV1) {
151+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV1, actualV1))
152+
}
153+
expectV2 := []string{"1", "2", "3"}
154+
if !slices.Equal(expectV2, actualV2) {
155+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV2, actualV2))
156+
}
157+
158+
actualV1 = make([]int, 0, 3)
159+
i := 0
160+
for v1, _ := range Transform12(SliceElem([]int{1, 2, 3}), transformFunc) {
161+
actualV1 = append(actualV1, v1)
162+
i++
163+
if i >= 2 {
164+
break
165+
}
166+
}
167+
expectV1 = []int{11, 12}
168+
if !slices.Equal(expectV1, actualV1) {
169+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expectV1, actualV1))
170+
}
145171
}
146172

147173
func TestTransform21(t *testing.T) {
148-
transformFunc := func(k int, v int) string {
149-
return fmt.Sprintf("%d_%d", k, v)
150-
}
151-
152-
actual := make([]string, 0, 3)
153-
for v := range Transform21(Slice([]int{1, 2, 3}), transformFunc) {
154-
actual = append(actual, v)
155-
}
156-
expect := []string{"0_1", "1_2", "2_3"}
157-
if !slices.Equal(expect, actual) {
158-
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
159-
}
160-
161-
actual = make([]string, 0, 3)
162-
i := 0
163-
for v := range Transform21(Slice([]int{1, 2, 3}), transformFunc) {
164-
actual = append(actual, v)
165-
i++
166-
if i >= 2 {
167-
break
168-
}
169-
}
170-
expect = []string{"0_1", "1_2"}
171-
if !slices.Equal(expect, actual) {
172-
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
173-
}
174+
transformFunc := func(k int, v int) string {
175+
return fmt.Sprintf("%d_%d", k, v)
176+
}
177+
178+
actual := make([]string, 0, 3)
179+
for v := range Transform21(Slice([]int{1, 2, 3}), transformFunc) {
180+
actual = append(actual, v)
181+
}
182+
expect := []string{"0_1", "1_2", "2_3"}
183+
if !slices.Equal(expect, actual) {
184+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
185+
}
186+
187+
actual = make([]string, 0, 3)
188+
i := 0
189+
for v := range Transform21(Slice([]int{1, 2, 3}), transformFunc) {
190+
actual = append(actual, v)
191+
i++
192+
if i >= 2 {
193+
break
194+
}
195+
}
196+
expect = []string{"0_1", "1_2"}
197+
if !slices.Equal(expect, actual) {
198+
t.Fatal(fmt.Sprintf("expect: %v, actual: %v", expect, actual))
199+
}
174200
}

0 commit comments

Comments
 (0)