README
¶
lazyiterate
A Go package providing generic, lazy if possible iterator utility functions for functional-style programming. For full documentation, see the GoDoc.
Features
- All / Any: Test if all or any elements (or key-value pairs) satisfy a predicate.
- Count: Count elements or key-value pairs in a sequence.
- Find: Find the first element or key-value pair matching a predicate.
- Filter: Lazily filter elements or key-value pairs.
- Map: Lazily transform elements or key-value pairs.
- Reduce: Accumulate elements or key-value pairs into a single value.
- Reverse: Iterate elements or key-value pairs in reverse order.
- Skip / Take: Skip or take a fixed number of elements or key-value pairs.
- Zip: Combine two sequences into pairs.
All functions are generic and work with the iter package's Seq and Seq2 types.
Example Usage
import (
"slices"
"github.com/longlodw/lazyiterate"
)
int main() {
seq := slices.Values([]int{1, 2, 3, 4, 5})
even := lazyiterate.Filter(seq, func(x int) bool { return x%2 == 0 })
doubled := lazyiterate.Map(even, func(x int) int { return x * 2 })
count := lazyiterate.Count(doubled)
}
Requirements
- Go 1.23+ (for iterator)
- iter package
License
MIT
Documentation
¶
Index ¶
- func All[T any](it iter.Seq[T], pred func(T) bool) bool
- func All2[K any, V any](it iter.Seq2[K, V], pred func(K, V) bool) bool
- func Any[T any](it iter.Seq[T], pred func(T) bool) bool
- func Any2[K any, V any](it iter.Seq2[K, V], pred func(K, V) bool) bool
- func Count[T any](it iter.Seq[T]) int
- func Count2[K any, V any](it iter.Seq2[K, V]) int
- func Filter[T any](it iter.Seq[T], pred func(T) bool) iter.Seq[T]
- func Filter2[K any, V any](it iter.Seq2[K, V], pred func(K, V) bool) iter.Seq2[K, V]
- func Find[T any](it iter.Seq[T], pred func(T) bool) (T, error)
- func Find2[K any, V any](it iter.Seq2[K, V], pred func(K, V) bool) (K, V, error)
- func Map[T, R any](it iter.Seq[T], fn func(T) R) iter.Seq[R]
- func Map2[K, V, R any](it iter.Seq2[K, V], fn func(K, V) R) iter.Seq[R]
- func Reduce[A any, T any](it iter.Seq[T], fn func(A, T) A, init A) A
- func Reduce2[A any, K any, V any](it iter.Seq2[K, V], fn func(A, K, V) A, init A) A
- func Reverse[T any](it iter.Seq[T]) iter.Seq[T]
- func Reverse2[K any, V any](it iter.Seq2[K, V]) iter.Seq2[K, V]
- func Skip[T any](it iter.Seq[T], n int) iter.Seq[T]
- func Skip2[K any, V any](it iter.Seq2[K, V], n int) iter.Seq2[K, V]
- func Take[T any](it iter.Seq[T], n int) iter.Seq[T]
- func Take2[K any, V any](it iter.Seq2[K, V], n int) iter.Seq2[K, V]
- func Zip[T1, T2 any](it1 iter.Seq[T1], it2 iter.Seq[T2]) iter.Seq2[T1, T2]
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Filter ¶
Filter returns a new sequence containing only the elements that satisfy the predicate.
func Filter2 ¶
Filter2 returns a new sequence containing only the key-value pairs that satisfy the predicate.
func Map ¶
Map returns a new sequence containing the results of applying the function to each element.
func Map2 ¶
Map2 returns a new sequence containing the results of applying the function to each key-value pair.
func Reduce ¶
Reduce applies a function cumulatively to the elements of the sequence, reducing it to a single value.
func Reduce2 ¶
Reduce2 applies a function cumulatively to the key-value pairs of the sequence, reducing it to a single value.
Types ¶
This section is empty.
Source Files