1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
|
// run
// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
type Iterator[T any] interface {
Iterate(fn func(T) bool)
}
type IteratorFunc[T any] func(fn func(T) bool)
func (f IteratorFunc[T]) Iterate(fn func(T) bool) {
f(fn)
}
type Stream[T any] struct {
it Iterator[T]
}
func (s Stream[T]) Iterate(fn func(T) bool) {
if s.it == nil {
return
}
s.it.Iterate(fn)
}
func FromIterator[T any](it Iterator[T]) Stream[T] {
return Stream[T]{it: it}
}
func (s Stream[T]) DropWhile(fn func(T) bool) Stream[T] {
return Pipe[T, T](s, func(t T) (T, bool) {
return t, true
})
}
func Pipe[T, R any](s Stream[T], op func(d T) (R, bool)) Stream[R] {
it := func(fn func(R) bool) {
// XXX Not getting the closure right when converting to interface.
// s.it.Iterate(func(t T) bool {
// r, ok := op(t)
// if !ok {
// return true
// }
// return fn(r)
// })
}
return FromIterator[R](IteratorFunc[R](it))
}
func Reduce[T, U any](s Stream[T], identity U, acc func(U, T) U) (r U) {
r = identity
s.Iterate(func(t T) bool {
r = acc(r, t)
return true
})
return r
}
type myIterator struct {
}
func (myIterator) Iterate(fn func(int) bool) {
}
func main() {
s := Stream[int]{}
s.it = myIterator{}
s = s.DropWhile(func(i int) bool {
return false
})
Reduce(s, nil, func(acc []int, e int) []int {
return append(acc, e)
})
}
|
