Documentation ¶
Index ¶
- func Count[...]() iter.Seq[V]
- func Drop[V any](delegate iter.Seq[V], count int) iter.Seq[V]
- func Drop2[V, W any](delegate iter.Seq2[V, W], count int) iter.Seq2[V, W]
- func Enumerate[V any](delegate iter.Seq[V]) iter.Seq2[int, V]
- func Exclude[V any](delegate iter.Seq[V], predicate func(V) bool) iter.Seq[V]
- func Exclude2[V, W any](delegate iter.Seq2[V, W], predicate func(V, W) bool) iter.Seq2[V, W]
- func Filter[V any](delegate iter.Seq[V], predicate func(V) bool) iter.Seq[V]
- func Filter2[V, W any](delegate iter.Seq2[V, W], predicate func(V, W) bool) iter.Seq2[V, W]
- func ForEach[V any](iter iter.Seq[V], fn func(V))
- func ForEach2[V, W any](iter iter.Seq2[V, W], fn func(V, W))
- func Map[V, W any](delegate iter.Seq[V], transform func(V) W) iter.Seq[W]
- func Map2[V, W, X, Y any](delegate iter.Seq2[V, W], transform func(V, W) (X, Y)) iter.Seq2[X, Y]
- func Reduce[V any, R any](iter iter.Seq[V], fn func(R, V) R, initial R) R
- func Reduce2[V, W any, R any](iter iter.Seq2[V, W], fn func(R, V, W) R, initial R) R
- func Take[V any](delegate iter.Seq[V], limit int) iter.Seq[V]
- func Take2[V, W any](delegate iter.Seq2[V, W], limit int) iter.Seq2[V, W]
- func Unzip[V, W any](delegate iter.Seq2[V, W]) (iter.Seq[V], iter.Seq[W])
- func Zip[V, W any](left iter.Seq[V], right iter.Seq[W]) iter.Seq2[V, W]
- type Iterator
- func (iterator Iterator[V]) Collect() []V
- func (iterator Iterator[V]) Drop(count int) Iterator[V]
- func (iterator Iterator[V]) Enumerate() Iterator2[int, V]
- func (iterator Iterator[V]) Exclude(predicate func(V) bool) Iterator[V]
- func (iterator Iterator[V]) Filter(predicate func(V) bool) Iterator[V]
- func (iterator Iterator[V]) ForEach(fn func(V))
- func (iterator Iterator[V]) Take(limit int) Iterator[V]
- type Iterator2
- func (iterator Iterator2[V, W]) Drop(count int) Iterator2[V, W]
- func (iterator Iterator2[V, W]) Exclude(predicate func(V, W) bool) Iterator2[V, W]
- func (iterator Iterator2[V, W]) Filter(predicate func(V, W) bool) Iterator2[V, W]
- func (iterator Iterator2[V, W]) ForEach(fn func(V, W))
- func (iterator Iterator2[V, W]) Take(limit int) Iterator2[V, W]
- func (iterator Iterator2[V, W]) Unzip() (Iterator[V], Iterator[W])
Examples ¶
- Count
- Drop
- Drop (Method)
- Drop2
- Drop2 (Method)
- Enumerate
- Enumerate (Method)
- Exclude
- Exclude (Method)
- Exclude2
- Exclude2 (Method)
- Filter
- Filter (Method)
- Filter2
- Filter2 (Method)
- ForEach
- ForEach (Method)
- ForEach2
- ForEach2 (Method)
- Map
- Map2
- Reduce
- Reduce2
- Take
- Take (Method)
- Take2
- Take2 (Method)
- Unzip
- Unzip (Method)
- Zip
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Count ¶
func Count[V ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~int | ~int8 | ~int16 | ~int32 | ~int64]() iter.Seq[V]
Count yields all non-negative integers in ascending order.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { for i := range iter.Count[int]() { if i >= 3 { break } fmt.Println(i) } }
Output: 0 1 2
func Drop ¶
Drop yields all values from a delegate Iterator except the first `count` values.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { for value := range iter.Drop(slices.Values([]int{1, 2, 3, 4, 5}), 2) { fmt.Println(value) } }
Output: 3 4 5
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { for value := range iter.Iterator[int](slices.Values([]int{1, 2, 3, 4, 5})).Drop(2) { fmt.Println(value) } }
Output: 3 4 5
func Drop2 ¶
Drop2 yields all pairs of values from a delegate Iterator2 except the first `count` pairs.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/maps" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { numbers := maps.Collect(iter.Drop2(maps.All(map[int]string{1: "one", 2: "two", 3: "three"}), 1)) fmt.Println(len(numbers)) }
Output: 2
Example (Method) ¶
package main import ( "fmt" it "iter" "github.com/BooleanCat/go-functional/v2/future/maps" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { numbers := iter.Iterator2[int, string](maps.All(map[int]string{1: "one", 2: "two", 3: "three"})).Drop(1) fmt.Println(len(maps.Collect(it.Seq2[int, string](numbers)))) }
Output: 2
func Enumerate ¶
Enumerate yields pairs of indices and values from an iterator.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { for index, value := range iter.Enumerate(slices.Values([]int{1, 2, 3})) { fmt.Println(index, value) } }
Output: 0 1 1 2 2 3
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { for index, value := range iter.Iterator[int](slices.Values([]int{1, 2, 3})).Enumerate() { fmt.Println(index, value) } }
Output: 0 1 1 2 2 3
func Exclude ¶
Exclude yields values from an iterator that do not satisfy a predicate.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" "github.com/BooleanCat/go-functional/v2/iter/filter" ) func main() { for number := range iter.Exclude(slices.Values([]int{1, 2, 3, 4, 5}), filter.IsEven) { fmt.Println(number) } }
Output: 1 3 5
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" "github.com/BooleanCat/go-functional/v2/iter/filter" ) func main() { for number := range iter.Iterator[int](slices.Values([]int{1, 2, 3, 4, 5})).Exclude(filter.IsEven) { fmt.Println(number) } }
Output: 1 3 5
func Exclude2 ¶
Exclude2 yields values from an iterator that do not satisfy a predicate.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/maps" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { isOne := func(n int, _ string) bool { return n == 1 } numbers := map[int]string{1: "one", 3: "three"} for key, value := range iter.Exclude2(maps.All(numbers), isOne) { fmt.Println(key, value) } }
Output: 3 three
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/maps" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { isOne := func(n int, _ string) bool { return n == 1 } numbers := map[int]string{1: "one", 3: "three"} for key, value := range iter.Iterator2[int, string](maps.All(numbers)).Exclude(isOne) { fmt.Println(key, value) } }
Output: 3 three
func Filter ¶
Filter yields values from an iterator that satisfy a predicate.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" "github.com/BooleanCat/go-functional/v2/iter/filter" ) func main() { for number := range iter.Filter(slices.Values([]int{1, 2, 3, 4, 5}), filter.IsEven) { fmt.Println(number) } }
Output: 2 4
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" "github.com/BooleanCat/go-functional/v2/iter/filter" ) func main() { for number := range iter.Iterator[int](slices.Values([]int{1, 2, 3, 4, 5})).Filter(filter.IsEven) { fmt.Println(number) } }
Output: 2 4
func Filter2 ¶
Filter2 yields values from an iterator that satisfy a predicate.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/maps" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { isOne := func(n int, _ string) bool { return n == 1 } numbers := map[int]string{1: "one", 2: "two", 3: "three"} for key, value := range iter.Filter2(maps.All(numbers), isOne) { fmt.Println(key, value) } }
Output: 1 one
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/maps" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { isOne := func(n int, _ string) bool { return n == 1 } numbers := map[int]string{1: "one", 2: "two", 3: "three"} for key, value := range iter.Iterator2[int, string](maps.All(numbers)).Filter(isOne) { fmt.Println(key, value) } }
Output: 1 one
func ForEach ¶
ForEach consumes an iterator and applies a function to each value yielded.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { iter.ForEach(slices.Values([]int{1, 2, 3}), func(number int) { fmt.Println(number) }) }
Output: 1 2 3
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { iter.Iterator[int](slices.Values([]int{1, 2, 3})).ForEach(func(number int) { fmt.Println(number) }) }
Output: 1 2 3
func ForEach2 ¶
ForEach2 consumes an iterator and applies a function to each pair of values.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { iter.ForEach2(iter.Enumerate[int](slices.Values([]int{1, 2, 3})), func(index int, number int) { fmt.Println(index, number) }) }
Output: 0 1 1 2 2 3
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { iter.Iterator[int](slices.Values([]int{1, 2, 3})).Enumerate().ForEach(func(index int, number int) { fmt.Println(index, number) }) }
Output: 0 1 1 2 2 3
func Map ¶
Map yields values from an iterator that have been transformed by a function.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { double := func(n int) int { return n * 2 } for number := range iter.Map(slices.Values([]int{1, 2, 3}), double) { fmt.Println(number) } }
Output: 2 4 6
func Map2 ¶
Map2 yields pairs of values from an iterator that have been transformed by a function.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { doubleBoth := func(n, m int) (int, int) { return n * 2, m * 2 } for left, right := range iter.Map2(iter.Zip(slices.Values([]int{1, 2, 3}), slices.Values([]int{2, 3, 4})), doubleBoth) { fmt.Println(left, right) } }
Output: 2 4 4 6 6 8
func Reduce ¶
Reduce consumes an iterator and applies a function to each value yielded, accumulating a single result.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" "github.com/BooleanCat/go-functional/v2/iter/op" ) func main() { fmt.Println(iter.Reduce(slices.Values([]int{1, 2, 3}), op.Add, 0)) }
Output: 6
func Reduce2 ¶
Reduce2 consumes an iterator and applies a function to each pair of values, accumulating a single result.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { fmt.Println(iter.Reduce2(iter.Enumerate[int](slices.Values([]int{1, 2, 3})), func(i, a, b int) int { return i + 1 }, 0)) }
Output: 3
func Take ¶
Take yields the first `limit` values from a delegate Iterator.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { for number := range iter.Take(slices.Values([]int{1, 2, 3, 4, 5}), 3) { fmt.Println(number) } }
Output: 1 2 3
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { for number := range iter.Iterator[int](slices.Values([]int{1, 2, 3, 4, 5})).Take(3) { fmt.Println(number) } }
Output: 1 2 3
func Take2 ¶
Take2 yields the first `limit` pairs of values from a delegate Iterator2.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/maps" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { numbers := maps.Collect(iter.Take2(maps.All(map[int]string{1: "one", 2: "two", 3: "three"}), 2)) fmt.Println(len(numbers)) }
Output: 2
Example (Method) ¶
package main import ( "fmt" it "iter" "github.com/BooleanCat/go-functional/v2/future/maps" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { numbers := maps.Collect(it.Seq2[int, string](iter.Iterator2[int, string](maps.All(map[int]string{1: "one", 2: "two", 3: "three"})).Take(2))) fmt.Println(len(numbers)) }
Output: 2
func Unzip ¶
Unzip returns two [Iterator]s from a single Iterator2.
Each returned Iterator yields the left and right values from the original Iterator2, respectively.
It is safe to concurrently pull from the returned [Iterator]s.
Both returned [Iterator]s must be stopped, the underlying Iterator2 is stopped when both are stopped. It is safe to stop one of the returned [Iterator]s immediately and continue pulling from the other.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/maps" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { keys, values := iter.Unzip(maps.All(map[int]string{1: "one", 2: "two"})) for key := range keys { fmt.Println(key) } for value := range values { fmt.Println(value) } }
Output:
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/maps" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { keys, values := iter.Iterator2[int, string](maps.All(map[int]string{1: "one", 2: "two"})).Unzip() for key := range keys { fmt.Println(key) } for value := range values { fmt.Println(value) } }
Output:
func Zip ¶
Zip yields pairs of values from two iterators.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/v2/future/slices" "github.com/BooleanCat/go-functional/v2/iter" ) func main() { for left, right := range iter.Zip(slices.Values([]int{1, 2, 3}), slices.Values([]string{"one", "two", "three"})) { fmt.Println(left, right) } }
Output: 1 one 2 two 3 three
Types ¶
type Iterator ¶
Iterator is a wrapper around iter.Seq that allows for method chaining of most iterators found in this package.
func (Iterator[V]) Collect ¶
func (iterator Iterator[V]) Collect() []V
Collect is a convenience method for chaining [Collect] on [Iterator]s.
func (Iterator[V]) Enumerate ¶
Enumerate is a convenience method for chaining Enumerate on [Iterator]s.
type Iterator2 ¶
Iterator is a wrapper around iter.Seq2 that allows for method chaining of most iterators found in this package.
func (Iterator2[V, W]) Drop ¶
func (iterator Iterator2[V, W]) Drop(count int) Iterator2[V, W]
Drop is a convenience method for chaining Drop on [Iterator2]s.
func (Iterator2[V, W]) Exclude ¶
func (iterator Iterator2[V, W]) Exclude(predicate func(V, W) bool) Iterator2[V, W]
Exclude is a convenience method for chaining Exclude on [Iterator2]s.
func (Iterator2[V, W]) Filter ¶
func (iterator Iterator2[V, W]) Filter(predicate func(V, W) bool) Iterator2[V, W]
Filter is a convenience method for chaining Filter on [Iterator2]s.
func (Iterator2[V, W]) ForEach ¶
func (iterator Iterator2[V, W]) ForEach(fn func(V, W))
ForEach is a convenience method for chaining ForEach on [Iterator2]s.