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

stream

package module

Go to main page

Versions in this module

v0

v0.2.0

Sep 8, 2026

Changes in this version

+ func Summary[N Number](s *Stream[N]) collector.SummaryStats[N]

+ type NumberStream struct

+ func AsNumber[N Number](s *Stream[N]) *NumberStream[N]

+ func FromNumberSlice[N Number](s []N) *NumberStream[N]

+ func OfNumber[N Number](xs ...N) *NumberStream[N]

+ func RangeClosed[I Integer](start, stop I) *NumberStream[I]

+ func (s *NumberStream[N]) AsStream() *Stream[N]

+ func (s *NumberStream[N]) Avg() N

+ func (s *NumberStream[N]) Contains(target N) bool

+ func (s *NumberStream[N]) Distinct() *NumberStream[N]

+ func (s *NumberStream[N]) DropWhile(p func(N) bool) *NumberStream[N]

+ func (s *NumberStream[N]) Filter(p func(N) bool) *NumberStream[N]

+ func (s *NumberStream[N]) Limit(n int64) *NumberStream[N]

+ func (s *NumberStream[N]) Max() (N, bool)

+ func (s *NumberStream[N]) Min() (N, bool)

+ func (s *NumberStream[N]) OnClose(f func() error) *NumberStream[N]

+ func (s *NumberStream[N]) Parallel(n int) *NumberStream[N]

+ func (s *NumberStream[N]) Peek(f func(N)) *NumberStream[N]

+ func (s *NumberStream[N]) Reverse() *NumberStream[N]

+ func (s *NumberStream[N]) Sequential() *NumberStream[N]

+ func (s *NumberStream[N]) Skip(n int64) *NumberStream[N]

+ func (s *NumberStream[N]) Sorted() *NumberStream[N]

+ func (s *NumberStream[N]) StableSorted() *NumberStream[N]

+ func (s *NumberStream[N]) Sum() N

+ func (s *NumberStream[N]) TakeWhile(p func(N) bool) *NumberStream[N]

+ func (s *NumberStream[N]) Unordered() *NumberStream[N]

type Stream

+ func OfNonZero[T comparable](xs ...T) *Stream[T]

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

+ func (s *Stream[T]) MapToNumber[N Number](f func(T) N) *NumberStream[N]

+ func (s *Stream[T]) StableSorted(cmp func(a, b T) int) *Stream[T]

+ func (s *Stream[T]) ToSeq() iter.Seq[T]

v0.1.0

Sep 3, 2026

Changes in this version

+ func Avg[N Number](s *Stream[N]) N

+ func Cache[T any](s *Stream[T]) func() *Stream[T]

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

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

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

+ func Sum[N Number](s *Stream[N]) N

+ func Summing[N Number]() collector.Collector[N, *N, N]

+ type Characteristics uint16

+ const SpDistinct

+ const SpOrdered

+ const SpSized

+ const SpSorted

+ const SpSubSized

+ type Float interface

+ type Integer interface

+ type KV struct

+ Key K

+ Value V

+ type Number interface

+ type Sink interface

+ Accept func(t T) bool

+ Begin func(size int64)

+ End func()

+ type Splitterator interface

+ Characteristics func() Characteristics

+ EstimateSize func() int64

+ ForEachRemaining func(f func(T) bool)

+ TryAdvance func(f func(T) bool) bool

+ TrySplit func() Splitterator[T]

+ type Stream struct

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

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

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

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

+ func Enumerate[T any](s *Stream[T]) *Stream[KV[int, T]]

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

+ func FromFunc[T any](next func() (T, bool, error)) *Stream[T]

+ func FromMap[K comparable, V any](m map[K]V) *Stream[KV[K, V]]

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

+ func FromSlice[T any](s []T) *Stream[T]

+ func Generate[T any](f func() T) *Stream[T]

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

+ func Of[T any](xs ...T) *Stream[T]

+ func Range[I Integer](start, stop I) *Stream[I]

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

+ func (s *Stream[T]) AllMatch(p func(T) bool) bool

+ func (s *Stream[T]) AnyMatch(p func(T) bool) bool

+ func (s *Stream[T]) Close() error

+ func (s *Stream[T]) Collect[A, R any](c collector.Collector[T, A, R]) R

+ func (s *Stream[T]) Count() int64

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

+ func (s *Stream[T]) DropWhile(p func(T) bool) *Stream[T]

+ func (s *Stream[T]) Err() error

+ func (s *Stream[T]) Filter(p func(T) bool) *Stream[T]

+ func (s *Stream[T]) FilterErr(p func(T) (bool, error)) *Stream[T]

+ func (s *Stream[T]) FindAny(p func(T) bool) (T, bool)

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

+ func (s *Stream[T]) FlatMapErr[U any](f func(T) ([]U, error)) *Stream[U]

+ func (s *Stream[T]) FlatMapSeq[U any](f func(T) iter.Seq[U]) *Stream[U]

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

+ func (s *Stream[T]) ForEach(f func(T))

+ func (s *Stream[T]) ForEachUntil(f func(T) bool)

+ func (s *Stream[T]) Limit(n int64) *Stream[T]

+ func (s *Stream[T]) MapErr[U any](f func(T) (U, error)) *Stream[U]

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

+ func (s *Stream[T]) Max(cmp func(a, b T) int) (T, bool)

+ func (s *Stream[T]) Min(cmp func(a, b T) int) (T, bool)

+ func (s *Stream[T]) NoneMatch(p func(T) bool) bool

+ func (s *Stream[T]) OnClose(f func() error) *Stream[T]

+ func (s *Stream[T]) Parallel(n int) *Stream[T]

+ func (s *Stream[T]) Peek(f func(T)) *Stream[T]

+ func (s *Stream[T]) PeekErr(f func(T) error) *Stream[T]

+ func (s *Stream[T]) Reduce(identity T, op func(T, T) T) T

+ func (s *Stream[T]) ReduceOpt(op func(T, T) T) (T, bool)

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

+ func (s *Stream[T]) Scan[U any](seed U, f func(U, T) U) *Stream[U]

+ func (s *Stream[T]) Sequential() *Stream[T]

+ func (s *Stream[T]) Skip(n int64) *Stream[T]

+ func (s *Stream[T]) Sorted(cmp func(a, b T) int) *Stream[T]

+ func (s *Stream[T]) TakeWhile(p func(T) bool) *Stream[T]

+ func (s *Stream[T]) ToSlice() []T

+ func (s *Stream[T]) Unordered() *Stream[T]

+ func (s *Stream[T]) Zip[U, R any](other *Stream[U], f func(T, U) R) *Stream[R]