Documentation
¶
Overview ¶
Package seq provides helpful iterator functions.
Index ¶
- func BatchSlice[T any](items []T, eqFunc func(a, b T) bool, maxSize int) iter.Seq[[]T]
- func BatchSliceFast[T any](items []T, eqFunc func(items []T, i, j int) bool, maxSize int) iter.Seq[[]T]
- func CollectCap[T any](src iter.Seq[T], cap int) []T
- func Map[T any, S any](src iter.Seq[S], fn func(S) T) iter.Seq[T]
- func None[T any]() iter.Seq[T]
- func Range(from, to int) iter.Seq[int]
- func Reduce[T any, S any](src iter.Seq[S], initialValue T, fn func(accum T, valye S) T) T
- func Select[T any](src iter.Seq[T], pred func(T) bool) iter.Seq[T]
- func Sum[T constr.Numeric](src iter.Seq[T]) T
- func Times(count int) iter.Seq[int]
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func BatchSlice ¶
BatchSlice groups the elements of the source sequence into batches with the same key, as determined by the key function. In order for this function to work best, it is assumed that items are already sorted acoording to the key function.
The maxSize parameter can be used to limit the size of the batches. If the maxSize is 0 or negative, then the batches will be of max possible size.
Example ¶
package main
import (
"fmt"
"github.com/perfecthill/gog/seq"
)
func main() {
source := []string{
"1Hello", "1World",
"2This", "2Is", "2Longer",
"3Yes",
}
eqFn := func(a, b string) bool {
return a[0] == b[0]
}
for batch := range seq.BatchSlice(source, eqFn, 0) {
fmt.Printf("%#v\n", batch)
}
}
Output: []string{"1Hello", "1World"} []string{"2This", "2Is", "2Longer"} []string{"3Yes"}
func BatchSliceFast ¶
func BatchSliceFast[T any](items []T, eqFunc func(items []T, i, j int) bool, maxSize int) iter.Seq[[]T]
BatchSliceFast is the same as BatchSlice, but it uses a much more performant equality function, which allows one to work with references to items in the slice instead of copies. This can have a huge impact when the items are large.
func CollectCap ¶
CollectCap collects values from src into a new slice with the given capacity preallocated and returns it.
Example ¶
package main
import (
"fmt"
"github.com/perfecthill/gog/seq"
)
func main() {
source := seq.Times(4)
target := seq.CollectCap(source, 12)
for _, v := range target {
fmt.Println(v)
}
fmt.Println()
fmt.Println(cap(target))
}
Output: 0 1 2 3 12
func Map ¶
Map applies the given transformation function to each element of the source sequence and returns a new sequence with the results.
Example ¶
package main
import (
"fmt"
"github.com/perfecthill/gog/seq"
)
func main() {
source := seq.Times(4)
target := seq.Map(source, func(v int) string {
return fmt.Sprintf("item %d", v)
})
for v := range target {
fmt.Println(v)
}
}
Output: item 0 item 1 item 2 item 3
func Range ¶
Range returns a sequence of integers from from (inclusive) to to (inclusive).
If from is greater than to, the sequence will be in descending order.
Example ¶
package main
import (
"fmt"
"github.com/perfecthill/gog/seq"
)
func main() {
for v := range seq.Range(1, 3) {
fmt.Println(v)
}
}
Output: 1 2 3
func Reduce ¶
Reduce compacts a sequence into a single value. The provided function is used to perform the reduction starting with the initialValue.
Example ¶
package main
import (
"fmt"
"slices"
"github.com/perfecthill/gog/seq"
)
func main() {
source := slices.Values([]int{1, 2, 3})
result := seq.Reduce(source, 10, func(acc, v int) int {
return acc + v
})
fmt.Println(result)
}
Output: 16
func Select ¶
Select applies the given predicate function to each element of the source sequence and returns a new sequence with the elements for which the predicate returned true.
Example ¶
package main
import (
"fmt"
"slices"
"github.com/perfecthill/gog/seq"
)
func main() {
source := slices.Values([]int{1, 2, 3, 4, 5})
target := seq.Select(source, func(v int) bool {
return v%2 == 0
})
for v := range target {
fmt.Println(v)
}
}
Output: 2 4
func Sum ¶
Sum is a convenience function that calculates the sum of all elements in the source sequence.
The same can normally be achieved with the Reduce function, but this function is simpler to use and faster.
Example ¶
package main
import (
"fmt"
"slices"
"github.com/perfecthill/gog/seq"
)
func main() {
source := slices.Values([]int{1, 2, 3})
result := seq.Sum(source)
fmt.Println(result)
}
Output: 6
Types ¶
This section is empty.
Source Files