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

catena

package module

Go to main page

Versions in this module

v1

v1.4.0

Aug 31, 2026

v1.3.0

Aug 31, 2026

v1.2.0

Aug 31, 2026

Changes in this version

+ func BottomN[T cmp.Ordered](s Seq[T], n int) []T

v1.1.0

Aug 31, 2026

Changes in this version

+ func ToKeySet[T comparable](s Seq[T]) map[T]struct

v1.0.0

Aug 31, 2026

retracted

Changes in this version

+ const Version

+ func AssociateWith[T comparable, V any](s Seq[T], f func(T) V) map[T]V

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

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

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

+ func Equal[T comparable](a, b Seq[T]) bool

+ func IndexOf[T comparable](s Seq[T], v T) int

+ func Join(s Seq[string], sep string) string

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

+ func MinMax[T cmp.Ordered](s Seq[T]) (min, max T, ok bool)

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

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

+ func Self[T any](v T) T

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

+ func Tally[T comparable](s Seq[T]) map[T]int

+ func ToSet[T comparable](s Seq[T]) map[T]struct

+ func TopN[T cmp.Ordered](s Seq[T], n int) []T

+ func Unzip[K, V any](s Seq2[K, V]) ([]K, []V)

+ type Integer interface

+ type List []T

+ func (l List[T]) All(pred func(T) bool) bool

+ func (l List[T]) Any(pred func(T) bool) bool

+ func (l List[T]) Append(vals ...T) List[T]

+ func (l List[T]) AsSeq() Seq[T]

+ func (l List[T]) Associate[K comparable, V any](f func(T) (K, V)) map[K]V

+ func (l List[T]) At(i int) T

+ func (l List[T]) AverageOf[N Numeric](sel func(T) N) (float64, bool)

+ func (l List[T]) BottomNBy[K cmp.Ordered](n int, sel func(T) K) []T

+ func (l List[T]) Clone() List[T]

+ func (l List[T]) Collect() []T

+ func (l List[T]) Concat(others ...Seq[T]) List[T]

+ func (l List[T]) Count() int

+ func (l List[T]) CountWhere(pred func(T) bool) int

+ func (l List[T]) DedupeBy[K comparable](sel func(T) K) List[T]

+ func (l List[T]) DistinctBy[K comparable](sel func(T) K) List[T]

+ func (l List[T]) DistinctWith(eq func(a, b T) bool) List[T]

+ func (l List[T]) Drain()

+ func (l List[T]) Drop(n int) List[T]

+ func (l List[T]) DropLast(n int) List[T]

+ func (l List[T]) DropWhile(pred func(T) bool) List[T]

+ func (l List[T]) ElementAt(i int) (T, bool)

+ func (l List[T]) Filter(pred func(T) bool) List[T]

+ func (l List[T]) FilterErr(pred func(T) (bool, error)) Try[T]

+ func (l List[T]) FilterIndexed(pred func(int, T) bool) List[T]

+ func (l List[T]) FilterMap[U any](f func(T) (U, bool)) List[U]

+ func (l List[T]) FilterNot(pred func(T) bool) List[T]

+ func (l List[T]) Find(pred func(T) bool) (T, bool)

+ func (l List[T]) FindIndex(pred func(T) bool) int

+ func (l List[T]) FindLast(pred func(T) bool) (T, bool)

+ func (l List[T]) FindMap[U any](f func(T) (U, bool)) (U, bool)

+ func (l List[T]) First() (T, bool)

+ func (l List[T]) FlatMapSlice[U any](f func(T) []U) List[U]

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

+ func (l List[T]) FoldBy[K comparable, A any](key func(T) K, init func(K) A, f func(A, T) A) map[K]A

+ func (l List[T]) FoldErr[A any](init A, f func(A, T) (A, error)) (A, error)

+ func (l List[T]) FoldIndexed[A any](init A, f func(int, A, T) A) A

+ func (l List[T]) FoldRight[A any](init A, f func(T, A) A) A

+ func (l List[T]) FoldWhile[A any](init A, f func(A, T) (A, bool)) A

+ func (l List[T]) Fold[A any](init A, f func(A, T) A) A

+ func (l List[T]) ForEach(f func(T))

+ func (l List[T]) ForEachErr(f func(T) error) error

+ func (l List[T]) ForEachIndexed(f func(int, T))

+ func (l List[T]) Get(i int) (T, bool)

+ func (l List[T]) GroupBy[K comparable](sel func(T) K) map[K][]T

+ func (l List[T]) IfEmpty(defaults ...T) List[T]

+ func (l List[T]) IndexBy[K comparable](sel func(T) K) map[K]T

+ func (l List[T]) Intersperse(sep T) List[T]

+ func (l List[T]) IsEmpty() bool

+ func (l List[T]) JoinBy[U any, K comparable, R any](other Seq[U], leftKey func(T) K, rightKey func(U) K, combine func(T, U) R) List[R]

+ func (l List[T]) JoinToString(sep string, sel func(T) string) string

+ func (l List[T]) Last() (T, bool)

+ func (l List[T]) Len() int

+ func (l List[T]) MapErr[U any](f func(T) (U, error)) Try[U]

+ func (l List[T]) MapIndexed[U any](f func(int, T) U) List[U]

+ func (l List[T]) Map[U any](f func(T) U) List[U]

+ func (l List[T]) MaxBy[K cmp.Ordered](sel func(T) K) (T, bool)

+ func (l List[T]) MaxOf[K cmp.Ordered](sel func(T) K) (K, bool)

+ func (l List[T]) MaxWith(cmp func(a, b T) int) (T, bool)

+ func (l List[T]) MinBy[K cmp.Ordered](sel func(T) K) (T, bool)

+ func (l List[T]) MinMaxOf[K cmp.Ordered](sel func(T) K) (min, max K, ok bool)

+ func (l List[T]) MinOf[K cmp.Ordered](sel func(T) K) (K, bool)

+ func (l List[T]) MinWith(cmp func(a, b T) int) (T, bool)

+ func (l List[T]) None(pred func(T) bool) bool

+ func (l List[T]) OnEach(f func(T)) List[T]

+ func (l List[T]) Partition(pred func(T) bool) (yes, no []T)

+ func (l List[T]) Prepend(vals ...T) List[T]

+ func (l List[T]) ProductOf[N Numeric](sel func(T) N) N

+ func (l List[T]) Reduce(f func(T, T) T) (T, bool)

+ func (l List[T]) Reversed() List[T]

+ func (l List[T]) Scan[A any](init A, f func(A, T) A) List[A]

+ func (l List[T]) Single() (T, bool)

+ func (l List[T]) Slice(i, j int) List[T]

+ func (l List[T]) SortedByDesc[K cmp.Ordered](sel func(T) K) List[T]

+ func (l List[T]) SortedBy[K cmp.Ordered](sel func(T) K) List[T]

+ func (l List[T]) SortedWith(cmp func(a, b T) int) List[T]

+ func (l List[T]) Step(n int) List[T]

+ func (l List[T]) SumOf[N Numeric](sel func(T) N) N

+ func (l List[T]) Take(n int) List[T]

+ func (l List[T]) TakeLast(n int) List[T]

+ func (l List[T]) TakeWhile(pred func(T) bool) List[T]

+ func (l List[T]) TallyBy[K comparable](sel func(T) K) map[K]int

+ func (l List[T]) ToList() List[T]

+ func (l List[T]) TopNBy[K cmp.Ordered](n int, sel func(T) K) []T

+ func (l List[T]) WithIndex() Seq2[int, T]

+ func (l List[T]) ZipWithNext() Seq2[T, T]

+ type Numeric interface

+ type Seq iter.Seq[T]

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

+ func ChunkedBy[T any, K comparable](s Seq[T], sel func(T) K) Seq[[]T]

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

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

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

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

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

+ func Except[T comparable](a, b Seq[T]) Seq[T]

+ func FlattenSlices[T any](s Seq[[]T]) Seq[T]

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

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

+ func FromSlice[T any](s []T) Seq[T]

+ func From[T any](seq func(func(T) bool)) Seq[T]

+ func GenerateWhile[T any](seed T, next func(T) (T, bool)) Seq[T]

+ func Generate[T any](seed T, next func(T) T) Seq[T]

+ func Intersect[T comparable](a, b Seq[T]) Seq[T]

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

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

+ func Once1[T any](v T) Seq[T]

+ func Range[I Integer](start, stop, step I) Seq[I]

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

+ func Repeat[T any](v T) Seq[T]

+ func SortedDesc[T cmp.Ordered](s Seq[T]) Seq[T]

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

+ func Union[T comparable](a, b Seq[T]) Seq[T]

+ func Windowed[T any](s Seq[T], size, step int) Seq[[]T]

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

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

+ func (s Seq[T]) Append(vals ...T) Seq[T]

+ func (s Seq[T]) Associate[K comparable, V any](f func(T) (K, V)) map[K]V

+ func (s Seq[T]) AverageOf[N Numeric](sel func(T) N) (float64, bool)

+ func (s Seq[T]) BottomNBy[K cmp.Ordered](n int, sel func(T) K) []T

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

+ func (s Seq[T]) Concat(others ...Seq[T]) Seq[T]

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

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

+ func (s Seq[T]) DedupeBy[K comparable](sel func(T) K) Seq[T]

+ func (s Seq[T]) DistinctBy[K comparable](sel func(T) K) Seq[T]

+ func (s Seq[T]) DistinctWith(eq func(a, b T) bool) Seq[T]

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

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

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

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

+ func (s Seq[T]) ElementAt(i int) (T, bool)

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

+ func (s Seq[T]) FilterErr(pred func(T) (bool, error)) Try[T]

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

+ func (s Seq[T]) FilterMap[U any](f func(T) (U, bool)) Seq[U]

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

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

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

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

+ func (s Seq[T]) FindMap[U any](f func(T) (U, bool)) (U, bool)

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

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

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

+ func (s Seq[T]) FoldBy[K comparable, A any](key func(T) K, init func(K) A, f func(A, T) A) map[K]A

+ func (s Seq[T]) FoldErr[A any](init A, f func(A, T) (A, error)) (A, error)

+ func (s Seq[T]) FoldIndexed[A any](init A, f func(int, A, T) A) A

+ func (s Seq[T]) FoldWhile[A any](init A, f func(A, T) (A, bool)) A

+ func (s Seq[T]) Fold[A any](init A, f func(A, T) A) A

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

+ func (s Seq[T]) ForEachErr(f func(T) error) error

+ func (s Seq[T]) ForEachIndexed(f func(int, T))

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

+ func (s Seq[T]) IfEmpty(defaults ...T) Seq[T]

+ func (s Seq[T]) IndexBy[K comparable](sel func(T) K) map[K]T

+ func (s Seq[T]) Intersperse(sep T) Seq[T]

+ func (s Seq[T]) IsEmpty() bool

+ func (s Seq[T]) JoinBy[U any, K comparable, R any](other Seq[U], leftKey func(T) K, rightKey func(U) K, combine func(T, U) R) Seq[R]

+ func (s Seq[T]) JoinToString(sep string, sel func(T) string) string

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

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

+ func (s Seq[T]) MapIndexed[U any](f func(int, T) U) Seq[U]

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

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

+ func (s Seq[T]) MaxOf[K cmp.Ordered](sel func(T) K) (K, bool)

+ func (s Seq[T]) MaxWith(cmp func(a, b T) int) (T, bool)

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

+ func (s Seq[T]) MinMaxOf[K cmp.Ordered](sel func(T) K) (min, max K, ok bool)

+ func (s Seq[T]) MinOf[K cmp.Ordered](sel func(T) K) (K, bool)

+ func (s Seq[T]) MinWith(cmp func(a, b T) int) (T, bool)

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

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

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

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

+ func (s Seq[T]) Prepend(vals ...T) Seq[T]

+ func (s Seq[T]) ProductOf[N Numeric](sel func(T) N) N

+ func (s Seq[T]) Pull() (next func() (T, bool), stop func())

+ func (s Seq[T]) Reduce(f func(T, T) T) (T, bool)

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

+ func (s Seq[T]) Scan[A any](init A, f func(A, T) A) Seq[A]

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

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

+ func (s Seq[T]) SortedByDesc[K cmp.Ordered](sel func(T) K) Seq[T]

+ func (s Seq[T]) SortedBy[K cmp.Ordered](sel func(T) K) Seq[T]

+ func (s Seq[T]) SortedWith(cmp func(a, b T) int) Seq[T]

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

+ func (s Seq[T]) SumOf[N Numeric](sel func(T) N) N

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

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

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

+ func (s Seq[T]) TallyBy[K comparable](sel func(T) K) map[K]int

+ func (s Seq[T]) ToChan(ctx context.Context) <-chan T

+ func (s Seq[T]) ToList() List[T]

+ func (s Seq[T]) TopNBy[K cmp.Ordered](n int, sel func(T) K) []T

+ func (s Seq[T]) UntilDone(ctx context.Context) Try[T]

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

+ func (s Seq[T]) ZipWithNext() Seq2[T, T]

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

+ type Seq2 iter.Seq2[K, V]

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

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

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

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

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

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

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

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

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

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

+ func (s Seq2[K, V]) Fold[A any](init A, f func(A, K, V) A) A

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

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

+ func (s Seq2[K, V]) MapTo[U any](f func(K, V) U) Seq[U]

+ func (s Seq2[K, V]) MapValues[V2 any](f func(K, V) V2) Seq2[K, V2]

+ func (s Seq2[K, V]) Map[K2, V2 any](f func(K, V) (K2, V2)) Seq2[K2, V2]

+ func (s Seq2[K, V]) Pull() (next func() (K, V, bool), stop func())

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

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

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

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

+ type Try iter.Seq2[T, error]

+ func EmptyTry[T any]() Try[T]

+ func FromErrs[T any](seq func(func(T, error) bool)) Try[T]

+ func (t Try[T]) Collect() ([]T, error)

+ func (t Try[T]) CollectAll() ([]T, []error)

+ func (t Try[T]) Count() (int, error)

+ func (t Try[T]) Drop(n int) Try[T]

+ func (t Try[T]) Err() error

+ func (t Try[T]) Errs() Seq[error]

+ func (t Try[T]) Filter(pred func(T) bool) Try[T]

+ func (t Try[T]) FilterErr(pred func(T) (bool, error)) Try[T]

+ func (t Try[T]) FlatMap[U any](f func(T) Try[U]) Try[U]

+ func (t Try[T]) Fold[A any](init A, f func(A, T) A) (A, error)

+ func (t Try[T]) ForEach(f func(T) error) error

+ func (t Try[T]) Ignore() Seq[T]

+ func (t Try[T]) MapErr[U any](f func(T) (U, error)) Try[U]

+ func (t Try[T]) Map[U any](f func(T) U) Try[U]

+ func (t Try[T]) Must() Seq[T]

+ func (t Try[T]) OnEach(f func(T)) Try[T]

+ func (t Try[T]) OnError(f func(error)) Try[T]

+ func (t Try[T]) Pull() (next func() (T, error, bool), stop func())

+ func (t Try[T]) Recover(f func(error) (T, bool)) Try[T]

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

+ func (t Try[T]) Take(n int) Try[T]

+ func (t Try[T]) TakeWhile(pred func(T) bool) Try[T]

+ func (t Try[T]) UntilDone(ctx context.Context) Try[T]

+ func (t Try[T]) WrapErr(f func(error) error) Try[T]