Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
- API
  
  Reference documentation for the pkg.go.dev API
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

iter

package module

Go to main page

Versions in this module

v0

v0.2.2

Sep 2, 2026

v0.2.1

Sep 2, 2026

v0.2.0

Sep 2, 2026

Changes in this version

+ type KeyValue struct

+ K K

+ V V

type Seq

+ func (s Seq[T]) ForEach(f func(T))

+ func (s Seq[T]) GroupBy[K comparable](f func(T) K) map[K][]T

+ func (s Seq[T]) KeyBy[K comparable](key func(T) K) map[K]T

+ func (s Seq[T]) MaxBy[K cmp.Ordered](key func(T) K) (T, bool)

+ func (s Seq[T]) MinBy[K cmp.Ordered](key func(T) K) (T, bool)

+ func (s Seq[T]) SumBy[K Number](key func(T) K) K

+ func (s Seq[T]) UniqBy[K comparable](key func(T) K) Seq[T]

type Seq2

+ func (s Seq2[K, V]) Collect() []KeyValue[K, V]

+ func (s Seq2[K, V]) Drop(n int) Seq2[K, V]

+ func (s Seq2[K, V]) DropWhile(pred func(K, V) bool) Seq2[K, V]

+ func (s Seq2[K, V]) Filter(f func(K, V) bool) Seq2[K, V]

+ func (s Seq2[K, V]) Take(n int) Seq2[K, V]

+ func (s Seq2[K, V]) TakeWhile(pred func(K, V) bool) Seq2[K, V]

v0.1.0

Sep 1, 2026

Changes in this version

+ func Contains[T comparable](s Seq[T], v T) bool

+ func Max[T cmp.Ordered](s Seq[T]) (T, bool)

+ func Min[T cmp.Ordered](s Seq[T]) (T, bool)

+ func Sum[T Number](s Seq[T]) T

+ func ToMap[K comparable, V any](s Seq2[K, V]) map[K]V

+ type Number interface

+ type Result struct

+ func FromResult[V any](seq stditer.Seq2[V, error]) Result[V]

+ func (s Result[V]) CollectErr() ([]V, error)

+ func (s Result[V]) Count() int

+ func (s Result[V]) Errors() Seq[error]

+ func (s Result[V]) Filter(f func(V, error) bool) Result[V]

+ func (s Result[V]) IgnoreErr() Seq[V]

+ func (s Result[V]) Seq() stditer.Seq2[V, error]

+ func (s Result[V]) Take(n int) Result[V]

+ func (s Result[V]) Tap(f func(V, error)) Result[V]

+ type Seq struct

+ func Chunk[T any](s Seq[T], n int) Seq[[]T]

+ func Concat[T any](seqs ...Seq[T]) Seq[T]

+ func FromKeys[K comparable, V any](m map[K]V) Seq[K]

+ func FromValues[K comparable, V any](m map[K]V) Seq[V]

+ func From[T any](seq stditer.Seq[T]) Seq[T]

+ func Of[T any](vals ...T) Seq[T]

+ func Range(from, to int) Seq[int]

+ func RepeatBy[T any](n int, f func(int) T) Seq[T]

+ func Repeat[T any](n int, v T) Seq[T]

+ func Uniq[T comparable](s Seq[T]) Seq[T]

+ func (s Seq[T]) Collect() []T

+ func (s Seq[T]) Count() int

+ func (s Seq[T]) CountBy(pred func(T) bool) int

+ func (s Seq[T]) Drop(n int) Seq[T]

+ func (s Seq[T]) DropWhile(pred func(T) bool) Seq[T]

+ func (s Seq[T]) Each(f func(T))

+ func (s Seq[T]) Enumerate() Seq2[int, T]

+ func (s Seq[T]) Every(pred func(T) bool) bool

+ func (s Seq[T]) Filter(f func(T) bool) Seq[T]

+ func (s Seq[T]) Find(pred func(T) bool) (T, bool)

+ func (s Seq[T]) First() (T, bool)

+ func (s Seq[T]) FlatMapErr[U any](f func(T) (Seq[U], error)) Result[U]

+ func (s Seq[T]) FlatMap[U any](f func(T) Seq[U]) Seq[U]

+ func (s Seq[T]) GroupByFunc[K comparable](f func(T) K) map[K][]T

+ func (s Seq[T]) KeyByFunc[K comparable](key func(T) K) map[K]T

+ func (s Seq[T]) Last() (T, bool)

+ func (s Seq[T]) MapErr[U any](f func(T) (U, error)) Result[U]

+ func (s Seq[T]) Map[U any](f func(T) U) Seq[U]

+ func (s Seq[T]) MaxByFunc[K cmp.Ordered](key func(T) K) (T, bool)

+ func (s Seq[T]) MinByFunc[K cmp.Ordered](key func(T) K) (T, bool)

+ func (s Seq[T]) None(pred func(T) bool) bool

+ func (s Seq[T]) ReduceErr[U any](init U, f func(U, T) (U, error)) (U, error)

+ func (s Seq[T]) Reduce[U any](init U, f func(U, T) U) U

+ func (s Seq[T]) Seq() stditer.Seq[T]

+ func (s Seq[T]) SkipErr(check func(T) error) Seq[T]

+ func (s Seq[T]) Some(pred func(T) bool) bool

+ func (s Seq[T]) SumByFunc[K Number](key func(T) K) K

+ func (s Seq[T]) Take(n int) Seq[T]

+ func (s Seq[T]) TakeWhile(pred func(T) bool) Seq[T]

+ func (s Seq[T]) Tap(f func(T)) Seq[T]

+ func (s Seq[T]) UniqByFunc[K comparable](key func(T) K) Seq[T]

+ func (s Seq[T]) Zip[U any](o Seq[U]) Seq2[T, U]

+ type Seq2 struct

+ func From2[K, V any](seq stditer.Seq2[K, V]) Seq2[K, V]

+ func FromMap[K comparable, V any](m map[K]V) Seq2[K, V]

+ func (s Seq2[K, V]) Count() int

+ func (s Seq2[K, V]) Keys() Seq[K]

+ func (s Seq2[K, V]) Seq() stditer.Seq2[K, V]

+ func (s Seq2[K, V]) Tap(f func(K, V)) Seq2[K, V]

+ func (s Seq2[K, V]) Values() Seq[V]