Documentation
¶
Overview ¶
Package xiter provides a set of iterator helpers.
Example (Single_and_empty) ¶
package main
import (
"fmt"
"github.com/siderolabs/gen/xiter"
)
func main() {
it := xiter.Single(42)
fmt.Println("Found 42 in seq:")
fmt.Println(xiter.Find(func(v int) bool { return v == 42 }, it))
fmt.Println("Found 43 in seq:")
fmt.Println(xiter.Find(func(v int) bool { return v == 43 }, it))
it = xiter.Empty
fmt.Println("Found 42 in seq:")
fmt.Println(xiter.Find(func(v int) bool { return v == 42 }, it))
it2 := xiter.Single2(42, 2012)
fmt.Println("Found 42 and 2012 in seq2:")
fmt.Println(xiter.Find2(func(k, v int) bool { return k == 42 && v == 2012 }, it2))
fmt.Println("Found 43 and 2012 in seq2:")
fmt.Println(xiter.Find2(func(k, v int) bool { return k == 43 && v == 2012 }, it2))
it2 = xiter.Empty2
fmt.Println("Found 42 and 2012 in seq2:")
fmt.Println(xiter.Find2(func(k, v int) bool { return k == 42 && v == 2012 }, it2))
}
Output: Found 42 in seq: 42 true Found 43 in seq: 0 false Found 42 in seq: 0 false Found 42 and 2012 in seq2: 42 2012 true Found 43 and 2012 in seq2: 0 0 false Found 42 and 2012 in seq2: 0 0 false
Example (With_numbers) ¶
package main
import (
"fmt"
"slices"
"strconv"
"github.com/siderolabs/gen/xiter"
)
func main() {
numbers := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
oddNumbers := xiter.Filter(func(n int) bool { return n%2 == 1 }, xiter.Values(slices.All(numbers)))
evenNumbers := xiter.Filter(func(n int) bool { return n%2 == 0 }, xiter.Values(slices.All(numbers)))
fmt.Println("Odd numbers:", xiter.Reduce(func(acc, _ int) int { acc++; return acc }, 0, oddNumbers))
fmt.Println("Even numbers:", xiter.Reduce(func(acc, _ int) int { acc++; return acc }, 0, evenNumbers))
// Print all odd numbers followed by all even numbers
for v := range xiter.Concat(oddNumbers, evenNumbers) {
fmt.Print(v, ",")
}
fmt.Println()
// Print all odd numbers followed by all even numbers but with text this time
for v := range xiter.Map(
func(v int) string { return m[v] },
xiter.Concat(oddNumbers, evenNumbers),
) {
fmt.Print(v, ",")
}
fmt.Println()
// Convert strings to integers, preserve erros
slc := []string{"1", "2", "3", "NaN"}
for val, err := range xiter.ToSeq2(strconv.Atoi, xiter.Values(slices.All(slc))) {
if err != nil {
fmt.Print(err)
continue
}
fmt.Print(val, ",")
}
fmt.Println()
// Print the positions of prime numbers
primeNumbers := xiter.Filter2(func(_, n int) bool { return isPrime(n) }, slices.All(numbers))
fmt.Print("Prime number positions:")
for pos := range xiter.Keys(primeNumbers) {
fmt.Print(pos, ",")
}
// Check if two slices are equal using various methods
reverseNumbers := []int{10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
fmt.Println("\nnumbers and rev(reverseNumbers) are equal:", xiter.Equal(
xiter.Values(slices.All(numbers)),
xiter.Values(slices.Backward(reverseNumbers)),
))
fmt.Println("numbers and rev(reverseNumbers) with pos are not equal:", !xiter.Equal2(
slices.All(numbers),
slices.Backward(reverseNumbers),
))
fmt.Println("numbers and numbers with pos should be equal:", xiter.Equal2(
slices.All(numbers),
slices.All(numbers),
))
fmt.Println("numbers and reverseNumbers are not equal:", !xiter.Equal(
xiter.Values(slices.All(numbers)),
xiter.Values(slices.All(reverseNumbers)),
))
fmt.Println("numbers and rev(reverseNumbers) are equal:", xiter.EqualFunc(
func(a, b int) bool { return a == b },
xiter.ToSeq(func(_, v int) int { return v }, slices.All(numbers)),
xiter.ToSeq(func(_, v int) int { return v }, slices.Backward(reverseNumbers)),
))
fmt.Println("numbers and rev(reverseNumbers) with pos dropped are equal:", xiter.EqualFunc2(
func(_, a, _, b int) bool { return a == b },
slices.All(numbers),
slices.Backward(reverseNumbers),
))
fmt.Println("numbers and reverseNumbers are not equal:", !xiter.EqualFunc(
func(a, b int) bool { return a == b },
xiter.Values(slices.All(numbers)),
xiter.Values(slices.All(reverseNumbers)),
))
}
var m = map[int]string{
0: "zero",
1: "one",
2: "two",
3: "three",
4: "four",
5: "five",
6: "six",
7: "seven",
8: "eight",
9: "nine",
10: "ten",
}
func isPrime(n int) bool {
if n < 2 {
return false
}
for i := 2; i*i <= n; i++ {
if n%i == 0 {
return false
}
}
return true
}
Output: Odd numbers: 5 Even numbers: 6 1,3,5,7,9,0,2,4,6,8,10, one,three,five,seven,nine,zero,two,four,six,eight,ten, 1,2,3,strconv.Atoi: parsing "NaN": invalid syntax Prime number positions:2,3,5,7, numbers and rev(reverseNumbers) are equal: true numbers and rev(reverseNumbers) with pos are not equal: true numbers and numbers with pos should be equal: true numbers and reverseNumbers are not equal: true numbers and rev(reverseNumbers) are equal: true numbers and rev(reverseNumbers) with pos dropped are equal: true numbers and reverseNumbers are not equal: true
Index ¶
- func Concat[V any](seqs ...iter.Seq[V]) iter.Seq[V]
- func Concat2[K, V any](seqs ...iter.Seq2[K, V]) iter.Seq2[K, V]
- func Empty[V any](func(V) bool)
- func Empty2[V, V2 any](func(V, V2) bool)
- func Equal[V comparable](x, y iter.Seq[V]) bool
- func Equal2[K, V comparable](x, y iter.Seq2[K, V]) bool
- func EqualFunc[V1, V2 any](f func(V1, V2) bool, x iter.Seq[V1], y iter.Seq[V2]) bool
- func EqualFunc2[K1, V1, K2, V2 any](f func(K1, V1, K2, V2) bool, x iter.Seq2[K1, V1], y iter.Seq2[K2, V2]) bool
- func Filter[V any](f func(V) bool, seq iter.Seq[V]) iter.Seq[V]
- func Filter2[K, V any](f func(K, V) bool, seq iter.Seq2[K, V]) iter.Seq2[K, V]
- func Find[V any](f func(V) bool, seq iter.Seq[V]) (V, bool)
- func Find2[K, V any](f func(K, V) bool, seq iter.Seq2[K, V]) (K, V, bool)
- func Keys[K, V any](seq iter.Seq2[K, V]) iter.Seq[K]
- func Map[In, Out any](f func(In) Out, seq iter.Seq[In]) iter.Seq[Out]
- func Map2[KIn, VIn, KOut, VOut any](f func(KIn, VIn) (KOut, VOut), seq iter.Seq2[KIn, VIn]) iter.Seq2[KOut, VOut]
- func Reduce[V, R any](f func(R, V) R, sum R, seq iter.Seq[V]) R
- func Reduce2[K, V, R any](f func(R, K, V) R, sum R, seq iter.Seq2[K, V]) R
- func Single[V any](v V) iter.Seq[V]
- func Single2[K, V any](k K, v V) iter.Seq2[K, V]
- func ToSeq[K, V, R any](fn func(K, V) R, seq iter.Seq2[K, V]) iter.Seq[R]
- func ToSeq2[V1, R1, R2 any](fn func(V1) (R1, R2), seq iter.Seq[V1]) iter.Seq2[R1, R2]
- func Values[K, V any](seq iter.Seq2[K, V]) iter.Seq[V]
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Concat2 ¶
Concat2 returns an iterator over the concatenation of the sequences.
Example ¶
package main
import (
"fmt"
"maps"
"strconv"
"github.com/siderolabs/gen/xiter"
)
func main() {
result := xiter.Reduce2(
func(acc int, k int64, v error) int {
if v != nil {
fmt.Println("Error:", v)
return acc
}
return acc + int(k)
},
0,
xiter.Map2(
func(k, v string) (int64, error) {
if v == "number" {
return strconv.ParseInt(k, 10, 64)
}
return 0, nil
},
xiter.Concat2(maps.All(numbersAndLetters), maps.All(numbersAndLetters2)),
),
)
fmt.Println(result)
}
var (
numbersAndLetters = map[string]string{
"1": "number",
"2": "number",
"avx": "text",
"3": "number",
"4": "number",
"5": "number",
}
numbersAndLetters2 = map[string]string{
"6": "number",
"7": "number",
"vhx": "text",
"hhh": "text",
"dsss": "ddd",
}
)
Output: 28
func Equal ¶
func Equal[V comparable](x, y iter.Seq[V]) bool
Equal reports whether the two sequences are equal.
func Equal2 ¶
func Equal2[K, V comparable](x, y iter.Seq2[K, V]) bool
Equal2 reports whether the two sequences are equal.
func EqualFunc2 ¶
func EqualFunc2[K1, V1, K2, V2 any](f func(K1, V1, K2, V2) bool, x iter.Seq2[K1, V1], y iter.Seq2[K2, V2]) bool
EqualFunc2 reports whether the two sequences are equal according to the function f.
func Map2 ¶
func Map2[KIn, VIn, KOut, VOut any](f func(KIn, VIn) (KOut, VOut), seq iter.Seq2[KIn, VIn]) iter.Seq2[KOut, VOut]
Map2 returns an iterator over f applied to seq.
func Reduce ¶ added in v0.7.0
Reduce applies f to the elements in seq, starting with the initial value.
func Reduce2 ¶ added in v0.7.0
Reduce2 applies f to the elements in seq, starting with the initial value.
func ToSeq ¶
ToSeq returns an iterator where each element is the result of applying fn to the elements in seq.
Types ¶
This section is empty.
Source Files
Directories
¶
| Path | Synopsis |
|---|---|
|
Package xbytes provides additional iterator functions for working with bytes slices.
|
Package xbytes provides additional iterator functions for working with bytes slices. |
|
Package xstrings provides additional iterator functions for working with strings.
|
Package xstrings provides additional iterator functions for working with strings. |
Click to show internal directories.
Click to hide internal directories.