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

streams

package module

Go to main page

Versions in this module

v2

v2.3.0

Aug 26, 2026

v2.2.0

Aug 25, 2026

Changes in this version

type Stream2

+ func (s Stream2[K, V]) All(pred func(K, V) bool) bool

+ func (s Stream2[K, V]) Any(pred func(K, V) bool) bool

+ func (s Stream2[K, V]) Find(pred func(K, V) bool) (K, V, bool)

+ func (s Stream2[K, V]) First() (K, V, bool)

+ func (s Stream2[K, V]) Last() (K, V, bool)

v2.1.0

Aug 25, 2026

Changes in this version

+ func CollectMap[K comparable, V any](s Stream2[K, V]) map[K]V

type Stream2

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

v2.0.2

Aug 25, 2026

v2.0.1

Aug 24, 2026

v2.0.0

Aug 24, 2026

Changes in this version

+ func Average[T Numeric](s Stream[T]) (float64, bool)

+ func Contains[T comparable](s Stream[T], target T) bool

+ func Frequency[T comparable](s Stream[T]) map[T]int

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

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

+ func Product[T Numeric](s Stream[T]) T

+ func Sum[T Numeric](s Stream[T]) T

+ func TryMap[T, R any](s Stream[T], fn func(T) (R, error)) iter.Seq2[R, error]

+ func Try[T any](seq iter.Seq2[T, error]) ([]T, error)

+ type Numeric interface

+ type ParallelOption func(*parallelConfig)

+ func Unordered() ParallelOption

+ func WithConcurrency(n int) ParallelOption

+ type Stream iter.Seq[T]

+ func ChanContext[T any](ctx context.Context, ch <-chan T) Stream[T]

+ func Chan[T any](ch <-chan T) Stream[T]

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

+ func Compact[T comparable](s Stream[T]) Stream[T]

+ func Concat[T any](ss ...Stream[T]) Stream[T]

+ func Cycle[T any](s Stream[T]) Stream[T]

+ func Distinct[T comparable](s Stream[T]) Stream[T]

+ func Empty[T any]() Stream[T]

+ func Flatten[T any](s Stream[Stream[T]]) Stream[T]

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

+ func Generate[T any](fn func() T) Stream[T]

+ func Interleave[T any](a, b Stream[T]) Stream[T]

+ func Iterate[T any](seed T, next func(T) T) Stream[T]

+ func Merge[T any](compare func(a, b T) int, ss ...Stream[T]) Stream[T]

+ func Of[T any](values ...T) Stream[T]

+ func Ok[T any](seq iter.Seq2[T, error]) (Stream[T], func() error)

+ func Range(start, end int) Stream[int]

+ func Repeat[T any](value T, n int) Stream[T]

+ func Sort[T cmp.Ordered](s Stream[T]) Stream[T]

+ func Window[T any](s Stream[T], n int) Stream[[]T]

+ func (s Stream[T]) All(pred func(T) bool) bool

+ func (s Stream[T]) Any(pred func(T) bool) bool

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

+ func (s Stream[T]) CompactFunc(eq func(a, b T) bool) Stream[T]

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

+ func (s Stream[T]) DistinctBy[K comparable](key func(T) K) Stream[T]

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

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

+ func (s Stream[T]) Enumerate() Stream2[int, T]

+ func (s Stream[T]) Filter(keep func(T) bool) Stream[T]

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

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

+ func (s Stream[T]) FlatMap[R any](fn func(T) Stream[R]) Stream[R]

+ func (s Stream[T]) Fold[A any](init A, fn func(A, T) A) A

+ func (s Stream[T]) ForEach(fn func(T))

+ func (s Stream[T]) GroupBy[K comparable](key func(T) K) map[K][]T

+ func (s Stream[T]) IndexBy[K comparable](key func(T) K) map[K]T

+ func (s Stream[T]) KeyBy[K any](key func(T) K) Stream2[K, T]

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

+ func (s Stream[T]) Map[R any](fn func(T) R) Stream[R]

+ func (s Stream[T]) MaxFunc(compare func(a, b T) int) (T, bool)

+ func (s Stream[T]) MinFunc(compare func(a, b T) int) (T, bool)

+ func (s Stream[T]) ParallelFilter(pred func(T) bool, opts ...ParallelOption) Stream[T]

+ func (s Stream[T]) ParallelForEach(fn func(T), opts ...ParallelOption)

+ func (s Stream[T]) ParallelMap[R any](fn func(T) R, opts ...ParallelOption) Stream[R]

+ func (s Stream[T]) Partition(pred func(T) bool) (yes, no []T)

+ func (s Stream[T]) Peek(fn func(T)) Stream[T]

+ func (s Stream[T]) Reduce(fn func(a, b T) T) (T, bool)

+ func (s Stream[T]) Reverse() Stream[T]

+ func (s Stream[T]) Scan[A any](init A, fn func(A, T) A) Stream[A]

+ func (s Stream[T]) SortFunc(compare func(a, b T) int) Stream[T]

+ func (s Stream[T]) SortStableFunc(compare func(a, b T) int) Stream[T]

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

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

+ func (s Stream[T]) ToMap[K comparable, V any](fn func(T) (K, V)) map[K]V

+ func (s Stream[T]) ZipWith[U, R any](o Stream[U], fn func(T, U) R) Stream[R]

+ func (s Stream[T]) Zip[U any](o Stream[U]) Stream2[T, U]

+ type Stream2 iter.Seq2[K, V]

+ func Empty2[K, V any]() Stream2[K, V]

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

+ func Pairs[M ~map[K]V, K comparable, V any](m M) Stream2[K, V]

+ func (s Stream2[K, V]) Collapse[R any](fn func(K, V) R) Stream[R]

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

+ func (s Stream2[K, V]) Filter(keep func(K, V) bool) Stream2[K, V]

+ func (s Stream2[K, V]) Fold[A any](init A, fn func(A, K, V) A) A

+ func (s Stream2[K, V]) ForEach(fn func(K, V))

+ func (s Stream2[K, V]) Keys() Stream[K]

+ func (s Stream2[K, V]) MapKeys[J any](fn func(K) J) Stream2[J, V]

+ func (s Stream2[K, V]) MapValues[W any](fn func(V) W) Stream2[K, W]

+ func (s Stream2[K, V]) Swap() Stream2[V, K]

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

+ func (s Stream2[K, V]) Values() Stream[V]

Other modules containing this package

github.com/coldsmirk/go-streams