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
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

Go to main page

Versions in this module

v0

v0.6.0

Jan 3, 2024

Changes in this version

+ func CollectFunc[E any](s Seq[E], collect func(E) bool)

+ func ContainsFunc[E any](s Seq[E], f func(e E) bool) bool

+ func Contains[E comparable](s Seq[E], x E) bool

+ func First[E any](s Seq[E], f func(E) bool) (result E, ok bool)

+ func Last[E any](s Seq[E], f func(E) bool) (m E, ok bool)

type Seq

+ func Append[E any](s Seq[E], elems ...E) Seq[E]

+ func DedupFunc[E any](s Seq[E], f func(E, E) bool) Seq[E]

+ func Dedup[E comparable](s Seq[E]) Seq[E]

+ func FilterZero[E comparable](s Seq[E]) Seq[E]

+ func Inspect[E any](s Seq[E], f func(E)) Seq[E]

+ func Intersperse[E any](s Seq[E], sep E) Seq[E]

+ func Scan[E, A any](s Seq[E], init A, f func(state A, elem E) A) Seq[A]

+ func SkipWhile[E any](s Seq[E], f func(E) bool) Seq[E]

+ func TakeWhile[E any](s Seq[E], f func(E) bool) Seq[E]

v0.5.0

Dec 2, 2023

Changes in this version

+ func All[E any](s Seq[E], f func(E) bool) bool

+ func Any[E any](s Seq[E], f func(E) bool) bool

+ func CountFunc[E any](s Seq[E], f func(E) bool) int

+ func Find[E any](s Seq[E], f func(E) bool) (result E, ok bool)

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

+ func Index[E any](s Seq[E], f func(E) bool) (int, bool)

+ func IsSortedFunc[E any](s Seq[E], f func(E, E) int) bool

+ func MaxFunc[E any](s Seq[E], f func(E, E) int) (m E, hasElem bool)

+ func MinFunc[E any](s Seq[E], f func(E, E) int) (m E, hasElem bool)

+ func Reduce[E any](s Seq[E], f func(E, E) E) (result E, hasElem bool)

+ func Size[E any](s Seq[E]) int

+ func TryFold[E, A any](s Seq[E], init A, f func(A, E) (A, error)) (res A, err error)

+ func TryForEach[E any](s Seq[E], f func(E) error) (err error)

+ type Seq func(yield func(E) bool)

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

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

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

+ type Tuple struct

+ Left A

+ Right B

v0.4.2

Aug 14, 2023

v0.4.1

Aug 14, 2023

v0.4.0

Jul 6, 2023

Changes in this version

+ func AllOf(iter Iter[T], predicate func(T) bool) bool

+ func AnyOf(iter Iter[T], predicate func(T) bool) bool

+ func Cmp(iter Iter[T], other Iter[T]) int

+ func CmpBy(iter Iter[T], other Iter[U], cmp func(T, U) int) int

+ func CmpByKey(iter Iter[T], other Iter[T], keyFn func(T) K) int

+ func CollectInto(iter Iter[T], collection E) E

+ func CollectToSlice(iter Iter[T]) []T

+ func Count(iter Iter[T]) int

+ func CountBy(iter Iter[T], predicate func(T) bool) int

+ func Equal(iter Iter[T], other Iter[T]) bool

+ func EqualBy(iter Iter[T], other Iter[U], eq func(T, U) bool) bool

+ func EqualByKey(iter Iter[T], other Iter[T], keyFn func(T) K) bool

+ func FindLeft(iter Iter[T], f func(T) bool) optional.Optional[T]

+ func FindMap(iter Iter[T], f func(T) optional.Optional[U]) optional.Optional[U]

+ func FindRight(iter PrevIter[T], f func(T) bool) optional.Optional[T]

+ func FoldLeft(iter Iter[T], init A, f func(A, T) A) A

+ func FoldRight(iter PrevIter[T], init A, f func(A, T) A) A

+ func ForEach(iter Iter[T], f func(T))

+ func IsSorted(iter Iter[T]) bool

+ func IsSortedBy(iter Iter[T], cmp func(T, T) int) bool

+ func IsSortedByKey(iter Iter[T], keyFn func(T) K) bool

+ func Max(iter Iter[T]) optional.Optional[T]

+ func MaxBy(iter Iter[T], cmp func(T, T) int) optional.Optional[T]

+ func MaxByKey(iter Iter[T], keyFn func(T) K) optional.Optional[T]

+ func Min(iter Iter[T]) optional.Optional[T]

+ func MinBy(iter Iter[T], cmp func(T, T) int) optional.Optional[T]

+ func MinByKey(iter Iter[T], keyFn func(T) K) optional.Optional[T]

+ func MinMax(iter Iter[T]) optional.Optional[tuple.Pair[T, T]]

+ func MinMaxBy(iter Iter[T], cmp func(T, T) int) optional.Optional[tuple.Pair[T, T]]

+ func MinMaxByKey(iter Iter[T], keyFn func(T) K) optional.Optional[tuple.Pair[T, T]]

+ func NoneOf(iter Iter[T], predicate func(T) bool) bool

+ func Nth(iter Iter[T], n int) optional.Optional[T]

+ func Partition(iter Iter[T], partition func(T) bool) (Iter[T], Iter[T])

+ func PositionLeft(iter Iter[T], f func(T) bool) optional.Optional[int]

+ func ReduceLeft(iter Iter[T], f func(T, T) T) optional.Optional[T]

+ func ReduceRight(iter PrevIter[T], f func(T, T) T) optional.Optional[T]

+ func ToString(iter Iter[T], sep string) string

+ func ToStringBy(iter Iter[T], sep string, f func(T) string) string

+ func UnzipBy(iter Iter[A], unzip func(A) (B, C)) (Iter[B], Iter[C])

+ type AllOfIter interface

+ AllOf func(predicate func(T) bool) bool

+ type AnyOfIter interface

+ AnyOf func(predicate func(T) bool) bool

+ type CmpByIter interface

+ CmpBy func(other Iter[U], cmp func(T, U) int) int

+ type CmpByKeyIter interface

+ CmpByKey func(other Iter[T], keyFn func(T) K) int

+ type CmpIter interface

+ Cmp func(other Iter[T]) int

+ type CountByIter interface

+ CountBy func(predicate func(T) bool) int

+ type CountIter interface

+ Count func() int

+ type EnumerateIter interface

+ Enumerate func() Iter[tuple.Pair[int, T]]

+ type EqualByIter interface

+ EqualBy func(other Iter[U], eq func(T, U) bool) bool

+ type EqualByKeyIter interface

+ EqualByKey func(other Iter[T], keyFn func(T) K) bool

+ type EqualIter interface

+ Equal func(other Iter[T]) bool

+ type Extend interface

+ Extend func(iter Iter[T])

+ type FilterIter interface

+ Filter func(f func(T) bool) Iter[T]

+ type FilterMapIter interface

+ FilterMap func(f func(T) optional.Optional[U]) Iter[U]

+ type FindLeftIter interface

+ FindLeft func(f func(T) bool) optional.Optional[T]

+ type FindMapIter interface

+ FindMap func(f func(T) optional.Optional[U]) optional.Optional[U]

+ type FindRightIter interface

+ FindRight func(f func(T) bool) optional.Optional[T]

+ type FoldLeftIter interface

+ FoldLeft func(init A, f func(A, T) A) A

+ type FoldRightIter interface

+ FoldRight func(init A, f func(A, T) A) A

+ type ForEachIter interface

+ ForEach func(f func(T))

+ type IsSortedByIter interface

+ IsSortedBy func(cmp func(T, T) int) bool

+ type IsSortedByKeyIter interface

+ IsSortedByKey func(keyFn func(T) K) bool

+ type IsSortedIter interface

+ IsSorted func() bool

+ type Iter interface

+ Next func() optional.Optional[T]

+ func Chain(iter Iter[T], other Iter[T]) Iter[T]

+ func Counter() Iter[int]

+ func Empty() Iter[T]

+ func Enumerate(iter Iter[T]) Iter[tuple.Pair[int, T]]

+ func Filter(iter Iter[T], f func(T) bool) Iter[T]

+ func FilterMap(iter Iter[T], f func(T) optional.Optional[U]) Iter[U]

+ func Map(iter Iter[T], f func(T) U) Iter[U]

+ func MapWhile(iter Iter[T], f func(T) optional.Optional[U]) Iter[U]

+ func OfChan(ch <-chan T) Iter[T]

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

+ func Repeat(v T) Iter[T]

+ func Rev(iter PrevIter[T]) Iter[T]

+ func Skip(iter Iter[T], n int) Iter[T]

+ func StepBy(iter Iter[T], step int) Iter[T]

+ func Successor(init T, successor func(T) optional.Optional[T]) Iter[T]

+ func Take(iter Iter[T], n int) Iter[T]

+ func Zip(iter Iter[A], other Iter[B]) Iter[tuple.Pair[A, B]]

+ func ZipBy(iter Iter[A], other Iter[B], f func(A, B) C) Iter[C]

+ type IterFunc func() optional.Optional[T]

+ func (fn IterFunc[T]) Next() optional.Optional[T]

+ type Iterable interface

+ Iter func() Iter[T]

+ type MapIter interface

+ Map func(f func(T) U) Iter[U]

+ type MapWhileIter interface

+ MapWhile func(f func(T) optional.Optional[U]) Iter[U]

+ type MaxByIter interface

+ MaxBy func(cmp func(T, T) int) optional.Optional[T]

+ type MaxByKeyIter interface

+ MaxByKey func(keyFn func(T) K) optional.Optional[T]

+ type MaxIter interface

+ Max func() optional.Optional[T]

+ type MinByIter interface

+ MinBy func(cmp func(T, T) int) optional.Optional[T]

+ type MinByKeyIter interface

+ MinByKey func(keyFn func(T) K) optional.Optional[T]

+ type MinIter interface

+ Min func() optional.Optional[T]

+ type MinMaxByIter interface

+ MinMaxBy func(cmp func(T, T) int) optional.Optional[tuple.Pair[T, T]]

+ type MinMaxByKeyIter interface

+ MinMaxByKey func(keyFn func(T) K) optional.Optional[tuple.Pair[T, T]]

+ type MinMaxIter interface

+ MinMax func() optional.Optional[tuple.Pair[T, T]]

+ type NoneOfIter interface

+ NoneOf func(predicate func(T) bool) bool

+ type PartitionIter interface

+ Partition func(partition func(T) bool) (Iter[T], Iter[T])

+ type PositionLeftIter interface

+ PositionLeft func(f func(T) bool) optional.Optional[int]

+ type PrevIter interface

+ Prev func() optional.Optional[T]

+ func OfSlice(slice []T) PrevIter[T]

+ func OfSliceVariadic(elems ...T) PrevIter[T]

+ type PrevIterable interface

+ PrevIter func() PrevIter[T]

+ type SkipIter interface

+ Skip func(n int) Iter[T]

+ type SkipWhileIter interface

+ SkipWhile func(skip func(T) bool) Iter[T]

+ type StepByIter interface

+ StepBy func(step int) Iter[T]

+ type TailIter interface

+ Tail func() Iter[T]

+ type TakeIter interface

+ Take func(n int) Iter[T]

+ type TakeWhileIter interface

+ TakeWhile func(take func(T) bool) Iter[T]

+ type ToStringByIter interface

+ ToStringBy func(sep string, f func(T) string) string

+ type ToStringIter interface

+ ToString func(sep string) string

+ type UnzipByIter interface

+ UnzipBy func(unzip func(A) (B, C)) (Iter[B], Iter[C])

+ type ZipByIter interface

+ ZipBy func(other Iter[B], f func(A, B) C) Iter[C]