iterkit

package

Go to main page

Versions in this module

v0

v0.301.0

Aug 1, 2025

v0.300.2

Jul 3, 2025

v0.300.1

Jun 29, 2025

v0.300.0

Jun 29, 2025

Changes in this version

+ type EagerSeq = iter.Seq[T]

+ type EagerSeq2 = iter.Seq2[K, V]

+ func Reverse2[K, V any](i iter.Seq2[K, V]) EagerSeq2[K, V]

+ type EagerSeqE = SeqE[T]

+ func ReverseE[T any](i SeqE[T]) EagerSeqE[T]

v0.299.1

Jun 11, 2025

v0.299.0

Jun 10, 2025

v0.298.2

Jun 10, 2025

v0.298.1

Jun 10, 2025

v0.298.0

Jun 9, 2025

v0.297.0

Jun 1, 2025

Changes in this version

+ func CollectEPull[T any](next func() (T, error, bool), stops ...func()) ([]T, error)

+ func CollectE[T any](i iter.Seq2[T, error]) ([]T, error)

+ func CountE[T any](i SeqE[T]) (int, error)

+ func FirstE[T any](i SeqE[T]) (T, bool, error)

+ func LastE[T any](i SeqE[T]) (T, bool, error)

+ func Limit2[K, V any](i iter.Seq2[K, V], n int) iter.Seq2[K, V]

+ func Of2[K, V any](k K, v V) iter.Seq2[K, V]

+ func Of[T any](v T) iter.Seq[T]

+ func Offset2[K, V any](i iter.Seq2[K, V], offset int) iter.Seq2[K, V]

+ func Reduce1[R, T any](i iter.Seq[T], initial R, fn func(R, T) R) R

+ func Reduce2[R, T any](i iter.Seq[T], initial R, fn func(R, T) R) R

+ func ReduceEErr[R, T any](i SeqE[T], initial R, fn func(R, T) (R, error)) (result R, rErr error)

+ func ReduceE[R, T any](i SeqE[T], initial R, fn func(R, T) R) (R, error)

+ func Slice1[T any](vs []T) iter.Seq[T]

+ func SplitSeqE[T any](i SeqE[T]) (iter.Seq[T], func() error)

+ func TakeAll2[KV any, K, V any](next func() (K, V, bool), m kvMapFunc[KV, K, V]) []KV

+ func TakeAllE[T any](next func() (T, error, bool)) ([]T, error)

+ func TakeE[T any](next func() (T, error, bool), n int) ([]T, error)

type KV

+ func Collect2KV[K, V any](i iter.Seq2[K, V]) []KV[K, V]

type NoMore

+ func (NoMore) Error() string

+ type SeqE = iter.Seq2[T, error]

+ func BatchE[T any](i SeqE[T], opts ...BatchOption) SeqE[[]T]

+ func ChanE[T any](ch <-chan T) SeqE[T]

+ func CharRangeE(begin, end rune) SeqE[rune]

+ func EmptyE[T any]() SeqE[T]

+ func FromPullE[T any](next func() (T, error, bool), stops ...func()) SeqE[T]

+ func From[T any](fn func(yield func(T) bool) error) SeqE[T]

+ func HeadE[T any](i SeqE[T], n int) SeqE[T]

+ func IntRangeE(begin, end int) SeqE[int]

+ func LimitE[T any](i SeqE[T], n int) SeqE[T]

+ func MapE[To any, From any, Iter i1[From]](i Iter, transform func(From) (To, error)) SeqE[To]

+ func MergeE[T any](is ...SeqE[T]) SeqE[T]

+ func OfE[T any](v T) SeqE[T]

+ func OffsetE[T any](i SeqE[T], offset int) SeqE[T]

+ func OnSeqEValue[To any, From any](itr SeqE[From], pipeline func(itr iter.Seq[From]) iter.Seq[To]) SeqE[To]

+ func SliceE[T any](vs []T) SeqE[T]

+ func ToSeqE[T any](i iter.Seq[T], errFuncs ...func() error) SeqE[T]

+ type SingleUseSeqE = SeqE[T]

+ func OnceE[T any](i SeqE[T]) SingleUseSeqE[T]

+ func SyncE[T any](i SeqE[T]) (SingleUseSeqE[T], func())

v0.296.0

Apr 9, 2025

v0.295.2

Apr 2, 2025

v0.295.1

Apr 2, 2025

v0.295.0

Mar 29, 2025

Changes in this version

+ const NoMore

+ func FromKV[K, V any](kvs []KV[K, V]) iter.Seq2[K, V]

+ func Take2All[KV any, K, V any](next func() (K, V, bool), m KVMapFunc[KV, K, V]) []KV

+ func Take2[KV any, K, V any](next func() (K, V, bool), n int, m KVMapFunc[KV, K, V]) []KV

+ type BatchConfig struct

+ Size int

+ WaitLimit time.Duration

+ func (c BatchConfig) Configure(t *BatchConfig)

+ type BatchOption option.Option[BatchConfig]

+ func BatchSize(n int) BatchOption

+ func BatchWaitLimit(d time.Duration) BatchOption

type ErrFunc

+ func SplitErrSeq[T any](i ErrSeq[T]) (iter.Seq[T], ErrFunc)

+ type ErrSeq = iter.Seq2[T, error]

+ func FromPages[T any](next func(offset int) (values []T, _ error)) ErrSeq[T]

+ func OnErrSeqValue[To any, From any](itr ErrSeq[From], pipeline func(itr iter.Seq[From]) iter.Seq[To]) ErrSeq[To]

+ func ToErrSeq[T any](i iter.Seq[T], errFuncs ...ErrFunc) ErrSeq[T]

+ type I1 interface

+ type KVMapFunc func(K, V) KV

+ type SingleUseErrSeq = ErrSeq[T]

v0.294.0

Mar 27, 2025

Changes in this version

+ func Collect2Map[K comparable, V any](i iter.Seq2[K, V]) map[K]V

+ func Head2[K, V any](i iter.Seq2[K, V], n int) iter.Seq2[K, V]

+ func Map2[OKey, OVal, IKey, IVal any](i iter.Seq2[IKey, IVal], transform func(IKey, IVal) (OKey, OVal)) iter.Seq2[OKey, OVal]

v0.293.0

Mar 27, 2025

Changes in this version

+ func Filter2[K, V any](i iter.Seq2[K, V], filter func(k K, v V) bool) iter.Seq2[K, V]

v0.292.1

Mar 21, 2025

v0.292.0

Mar 20, 2025

v0.291.0

Mar 19, 2025

v0.290.0

Mar 18, 2025

v0.289.0

Mar 11, 2025

v0.288.0

Mar 11, 2025

v0.287.2

Mar 10, 2025

v0.287.1

Mar 10, 2025

v0.287.0

Mar 9, 2025

Changes in this version

+ func Last2[K, V any](i iter.Seq2[K, V]) (K, V, bool)

+ type SingleUseSeq = iter.Seq[T]

+ type SingleUseSeq2 = iter.Seq2[K, V]

v0.286.0

Mar 8, 2025

Changes in this version

+ func Sync2[K, V any](i iter.Seq2[K, V]) (iter.Seq2[K, V], func())

+ func Sync[T any](i iter.Seq[T]) (iter.Seq[T], func())

v0.285.0

Mar 8, 2025

Changes in this version

+ const Break

+ func BatchWithWaitLimit[T any](i iter.Seq[T], size int, waitLimit time.Duration) iter.Seq[[]T]

+ func Batch[T any](i iter.Seq[T], size int) iter.Seq[[]T]

+ func Chan[T any](ch <-chan T) iter.Seq[T]

+ func CharRange(begin, end rune) iter.Seq[rune]

+ func Collect2[K, V, KV any](i iter.Seq2[K, V], m func(K, V) KV) []KV

+ func CollectErrIter[T any](i iter.Seq2[T, error]) ([]T, error)

+ func CollectErr[T any](i iter.Seq[T], e ErrFunc) ([]T, error)

+ func CollectPullIter[T any](itr PullIter[T]) ([]T, error)

+ func CollectPull[T any](next func() (T, bool), stops ...func()) []T

+ func Collect[T any](i iter.Seq[T]) []T

+ func Count2[K, V any](i iter.Seq2[K, V]) int

+ func Count[T any](i iter.Seq[T]) int

+ func Empty2[T1, T2 any]() iter.Seq2[T1, T2]

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

+ func Filter[T any](i iter.Seq[T], filter func(T) bool) iter.Seq[T]

+ func First2[K, V any](i iter.Seq2[K, V]) (K, V, bool)

+ func First[T any](i iter.Seq[T]) (T, bool)

+ func ForEach[T any](i iter.Seq[T], fn func(T) error, errFuncs ...ErrFunc) (rErr error)

+ func FromPull2[K, V any](next func() (K, V, bool), stops ...func()) iter.Seq2[K, V]

+ func FromPull[T any](next func() (T, bool), stops ...func()) iter.Seq[T]

+ func Head[T any](i iter.Seq[T], n int) iter.Seq[T]

+ func IntRange(begin, end int) iter.Seq[int]

+ func Last[T any](i iter.Seq[T]) (T, bool)

+ func Limit[V any](i iter.Seq[V], n int) iter.Seq[V]

+ func Map[To any, From any](i iter.Seq[From], transform func(From) To) iter.Seq[To]

+ func Merge2[K, V any](is ...iter.Seq2[K, V]) iter.Seq2[K, V]

+ func Merge[T any](is ...iter.Seq[T]) iter.Seq[T]

+ func Offset[V any](i iter.Seq[V], offset int) iter.Seq[V]

+ func Once2[K, V any](i iter.Seq2[K, V]) iter.Seq2[K, V]

+ func Once[T any](i iter.Seq[T]) iter.Seq[T]

+ func ReduceErr[R, T any](i iter.Seq[T], initial R, fn func(R, T) (R, error)) (result R, rErr error)

+ func Reduce[R, T any](i iter.Seq[T], initial R, fn func(R, T) R) R

+ func Reverse[T any](i iter.Seq[T]) iter.Seq[T]

+ func SingleValue[T any](v T) iter.Seq[T]

+ func Slice[T any](slice []T) iter.Seq[T]

+ func TakeAll[T any](next func() (T, bool)) []T

+ func Take[T any](next func() (T, bool), n int) []T

+ func ToChan[T any](itr iter.Seq[T]) (_ <-chan T, cancel func())

+ func WithConcurrentAccess[T any](i iter.Seq[T]) (iter.Seq[T], func())

+ type ErrFunc = errorkit.ErrFunc

+ func BufioScanner[T string | []byte](s *bufio.Scanner, closer io.Closer, errFuncs ...ErrFunc) (iter.Seq[T], ErrFunc)

+ func FromErrIter[T any](i ErrIter[T]) (iter.Seq[T], ErrFunc)

+ func MapErr[To any, From any](i iter.Seq[From], transform func(From) (To, error), errs ...ErrFunc) (iter.Seq[To], ErrFunc)

+ func Paginate[T any](ctx context.Context, ...) (iter.Seq[T], ErrFunc)

+ type ErrIter = iter.Seq2[T, error]

+ func ErrorF[T any](format string, a ...any) ErrIter[T]

+ func Error[T any](err error) ErrIter[T]

+ func FromPullIter[T any](itr PullIter[T]) ErrIter[T]

+ func OnErrIterValue[To any, From any](itr ErrIter[From], pipeline func(itr iter.Seq[From]) iter.Seq[To]) ErrIter[To]

+ func ToErrIter[T any](i iter.Seq[T], errFuncs ...ErrFunc) ErrIter[T]

+ type KV struct

+ K K

+ V V

+ func CollectKV[K, V any](i iter.Seq2[K, V]) []KV[K, V]

+ type PullIter interface

+ Err func() error

+ Next func() bool

+ Value func() V

+ func ToPullIter[T any](itr ErrIter[T]) PullIter[T]

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL