slice

Mar 15, 2026

Changes in this version

+ func Associate[T any, K comparable, V any](ts []T, fn func(T) (K, V)) map[K]V

+ func FanOutAll[T, R any](ctx context.Context, n int, ts []T, fn func(context.Context, T) (R, error)) ([]R, error)

+ func FanOutEachWeighted[T any](ctx context.Context, capacity int, ts []T, cost func(T) int, ...) []error

+ func FanOutEach[T any](ctx context.Context, n int, ts []T, fn func(context.Context, T) error) []error

+ func FanOutWeightedAll[T, R any](ctx context.Context, capacity int, ts []T, cost func(T) int, ...) ([]R, error)

+ func IndexOf[T comparable](ts []T, target T) option.Option[int]

+ func IsSortedBy[T any, K cmp.Ordered](ts []T, fn func(T) K) bool

+ func LastIndexOf[T comparable](ts []T, target T) option.Option[int]

+ func MaxBy[T any, K cmp.Ordered](ts []T, key func(T) K) (_ option.Option[T])

+ func MinBy[T any, K cmp.Ordered](ts []T, key func(T) K) (_ option.Option[T])

+ func Reduce[T any](ts []T, fn func(T, T) T) (_ option.Option[T])

+ func Window[T any](ts []T, size int) [][]T

type Group

+ func (g Group[K, T]) GetItems() []T

+ func (g Group[K, T]) GetKey() K

+ func (g Group[K, T]) Len() int

type Int

+ func Range(end int) Int

+ func RangeFrom(start, end int) Int

+ func RangeStep(start, end, step int) Int

type Mapper

+ func Difference[T comparable](a, b []T) Mapper[T]

+ func Enumerate[T any](ts []T) Mapper[pair.Pair[int, T]]

+ func FanOutWeighted[T, R any](ctx context.Context, capacity int, ts []T, cost func(T) int, ...) Mapper[rslt.Result[R]]

+ func FanOut[T, R any](ctx context.Context, n int, ts []T, fn func(context.Context, T) (R, error)) Mapper[rslt.Result[R]]

+ func FilterMap[T, R any](ts []T, fn func(T) (R, bool)) Mapper[R]

+ func FlatMap[T, R any](ts []T, fn func(T) []R) Mapper[R]

+ func Flatten[T any](tss [][]T) Mapper[T]

+ func GroupSame[T comparable](ts []T) Mapper[Group[T, T]]

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

+ func NonEmpty(ts []string) Mapper[string]

+ func NonZero[T comparable](ts []T) Mapper[T]

+ func PFlatMap[T, R any](ts []T, workers int, fn func(T) []R) Mapper[R]

+ func PMap[T, R any](ts []T, workers int, fn func(T) R) Mapper[R]

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

+ func Scan[T, R any](ts []T, initial R, fn func(R, T) R) Mapper[R]

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

+ func Unique[T comparable](ts []T) Mapper[T]

+ func ZipWith[A, B, R any](as []A, bs []B, fn func(A, B) R) Mapper[R]

+ func Zip[A, B any](as []A, bs []B) Mapper[pair.Pair[A, B]]

Mar 6, 2026

Changes in this version

+ func KeyBy[T any, K comparable](ts []T, fn func(T) K) map[K]T

Mar 6, 2026

Changes in this version

+ func Partition[T any](ts []T, fn func(T) bool) (Mapper[T], Mapper[T])

Mar 6, 2026

Changes in this version

+ func Asc[T any, S cmp.Ordered](key func(T) S) func(T, T) int

+ func Desc[T any, S cmp.Ordered](key func(T) S) func(T, T) int

+ type Entries = base.Entries[K, V]

+ type Group struct

+ Items []T

+ Key K

Mar 5, 2026

Changes in this version

+ func GroupBy[T any, K comparable](ts []T, fn func(T) K) map[K][]T

type Mapper

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

+ func FromSet[T comparable](m map[T]bool) Mapper[T]

+ func Map[T, R any](ts []T, fn func(T) R) Mapper[R]

Mar 3, 2026

Changes in this version

+ func Chunk[T any](ts []T, size int) [][]T

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

+ func ToSetBy[T any, K comparable](ts []T, fn func(T) K) map[K]bool

type Mapper

+ func Compact[T comparable](ts []T) Mapper[T]

+ func UniqueBy[T any, K comparable](ts []T, fn func(T) K) Mapper[T]

+ func (ts Mapper[T]) Every(fn func(T) bool) bool

+ func (ts Mapper[T]) None(fn func(T) bool) bool

+ func (ts Mapper[T]) Reverse() Mapper[T]

+ func (ts Mapper[T]) Take(n int) Mapper[T]

+ func (ts Mapper[T]) TakeLast(n int) Mapper[T]

type MapperTo

+ func (ts MapperTo[R, T]) Reverse() MapperTo[R, T]

+ func (ts MapperTo[R, T]) Take(n int) MapperTo[R, T]

+ func (ts MapperTo[R, T]) TakeLast(n int) MapperTo[R, T]

Mar 1, 2026

Changes in this version

type Mapper

+ func (ts Mapper[T]) FlatMap(fn func(T) []T) Mapper[T]

type MapperTo

+ func (ts MapperTo[R, T]) FlatMap(fn func(T) []R) Mapper[R]

Mar 1, 2026

Changes in this version

type Mapper

+ func MapAccum[T, R, S any](ts []T, init S, fn func(S, T) (S, R)) (S, Mapper[R])

Feb 28, 2026

Changes in this version

+ func ToSet[T comparable](ts []T) map[T]bool

type Float64

+ func (fs Float64) Max() option.Basic[float64]

+ func (fs Float64) Min() option.Basic[float64]

type Int

+ func (is Int) Max() option.Basic[int]

+ func (is Int) Min() option.Basic[int]

+ func (is Int) Sum() int

type Mapper

+ func ParallelMap[T, R any](m Mapper[T], workers int, fn func(T) R) Mapper[R]

+ func SortByDesc[T any, K cmp.Ordered](ts []T, fn func(T) K) Mapper[T]

+ func SortBy[T any, K cmp.Ordered](ts []T, fn func(T) K) Mapper[T]

+ func (m Mapper[T]) ParallelEach(workers int, fn func(T))

+ func (m Mapper[T]) ParallelKeepIf(workers int, fn func(T) bool) Mapper[T]

+ func (ts Mapper[T]) Any(fn func(T) bool) bool

+ func (ts Mapper[T]) Clone() Mapper[T]

+ func (ts Mapper[T]) IndexWhere(fn func(T) bool) option.Basic[int]

+ func (ts Mapper[T]) Single() either.Either[int, T]

type MapperTo

+ func (ts MapperTo[R, T]) Clone() MapperTo[R, T]

+ func (ts MapperTo[R, T]) ParallelEach(workers int, fn func(T))

+ func (ts MapperTo[R, T]) ParallelKeepIf(workers int, fn func(T) bool) MapperTo[R, T]

+ func (ts MapperTo[R, T]) ParallelMap(workers int, fn func(T) R) Mapper[R]

+ func (ts MapperTo[R, T]) Single() either.Either[int, T]

type String

+ func (ss String) Contains(target string) bool

+ func (ss String) ContainsAny(targets []string) bool

+ func (ss String) Each(fn func(string))

+ func (ss String) Len() int

+ func (ss String) Matches(filter []string) bool

+ func (ss String) ToSet() map[string]bool

+ func (ss String) Unique() String

Feb 15, 2026

Changes in this version

+ func FindAs[R, T any](ts []T) option.Basic[R]

Feb 15, 2026

Changes in this version

type Mapper

+ func (ts Mapper[T]) First() option.Basic[T]

type MapperTo

+ func (ts MapperTo[R, T]) First() option.Basic[T]

Feb 15, 2026

Changes in this version

type Float64

+ func (fs Float64) Sum() float64

Feb 13, 2026

Changes in this version

type Mapper

+ func (ts Mapper[T]) Find(fn func(T) bool) option.Basic[T]

Feb 13, 2026

Changes in this version

+ func Find[T any](ts []T, fn func(T) bool) option.Basic[T]

Jan 24, 2026

Changes in this version

type MapperTo

+ func (ts MapperTo[R, T]) Map(fn func(T) R) Mapper[R]

Jan 21, 2026

Changes in this version

type Mapper

+ func (ts Mapper[T]) ToInt32(fn func(T) int32) Mapper[int32]

+ func (ts Mapper[T]) ToInt64(fn func(T) int64) Mapper[int64]

type MapperTo

+ func (ts MapperTo[R, T]) ToInt32(fn func(T) int32) MapperTo[R, int32]

+ func (ts MapperTo[R, T]) ToInt64(fn func(T) int64) MapperTo[R, int64]

Jan 3, 2026

Changes in this version

+ func Fold[T, R any](ts []T, initial R, fn func(R, T) R) R

+ func Unzip2[T, A, B any](ts []T, fa func(T) A, fb func(T) B) (Mapper[A], Mapper[B])

+ func Unzip3[T, A, B, C any](ts []T, fa func(T) A, fb func(T) B, fc func(T) C) (Mapper[A], Mapper[B], Mapper[C])

+ func Unzip4[T, A, B, C, D any](ts []T, fa func(T) A, fb func(T) B, fc func(T) C, fd func(T) D) (Mapper[A], Mapper[B], Mapper[C], Mapper[D])

Jan 3, 2026

Changes in this version

+ type Any = Mapper[any]

+ type Bool = Mapper[bool]

+ type Byte = Mapper[byte]

+ type Error = Mapper[error]

+ type Float32 = Mapper[float32]

+ type Float64 = Mapper[float64]

+ type Int = Mapper[int]

+ type Mapper []T

+ func From[T any](ts []T) Mapper[T]

+ func (ts Mapper[T]) Convert(fn func(T) T) Mapper[T]

+ func (ts Mapper[T]) Each(fn func(T))

+ func (ts Mapper[T]) KeepIf(fn func(T) bool) Mapper[T]

+ func (ts Mapper[T]) Len() int

+ func (ts Mapper[T]) RemoveIf(fn func(T) bool) Mapper[T]

+ func (ts Mapper[T]) TakeFirst(n int) Mapper[T]

+ func (ts Mapper[T]) ToAny(fn func(T) any) Mapper[any]

+ func (ts Mapper[T]) ToBool(fn func(T) bool) Mapper[bool]

+ func (ts Mapper[T]) ToByte(fn func(T) byte) Mapper[byte]

+ func (ts Mapper[T]) ToError(fn func(T) error) Mapper[error]

+ func (ts Mapper[T]) ToFloat32(fn func(T) float32) Mapper[float32]

+ func (ts Mapper[T]) ToFloat64(fn func(T) float64) Mapper[float64]

+ func (ts Mapper[T]) ToInt(fn func(T) int) Mapper[int]

+ func (ts Mapper[T]) ToRune(fn func(T) rune) Mapper[rune]

+ func (ts Mapper[T]) ToString(fn func(T) string) Mapper[string]

+ type MapperTo []T

+ func MapTo[R, T any](ts []T) MapperTo[R, T]

+ func (ts MapperTo[R, T]) Convert(fn func(T) T) MapperTo[R, T]

+ func (ts MapperTo[R, T]) Each(fn func(T))

+ func (ts MapperTo[R, T]) KeepIf(fn func(T) bool) MapperTo[R, T]

+ func (ts MapperTo[R, T]) RemoveIf(fn func(T) bool) MapperTo[R, T]

+ func (ts MapperTo[R, T]) TakeFirst(n int) MapperTo[R, T]

+ func (ts MapperTo[R, T]) To(fn func(T) R) Mapper[R]

+ func (ts MapperTo[R, T]) ToAny(fn func(T) any) MapperTo[R, any]

+ func (ts MapperTo[R, T]) ToBool(fn func(T) bool) MapperTo[R, bool]

+ func (ts MapperTo[R, T]) ToByte(fn func(T) byte) MapperTo[R, byte]

+ func (ts MapperTo[R, T]) ToError(fn func(T) error) MapperTo[R, error]

+ func (ts MapperTo[R, T]) ToFloat32(fn func(T) float32) MapperTo[R, float32]

+ func (ts MapperTo[R, T]) ToFloat64(fn func(T) float64) MapperTo[R, float64]

+ func (ts MapperTo[R, T]) ToInt(fn func(T) int) MapperTo[R, int]

+ func (ts MapperTo[R, T]) ToRune(fn func(T) rune) MapperTo[R, rune]

+ func (ts MapperTo[R, T]) ToString(fn func(T) string) MapperTo[R, string]

+ func (ts MapperTo[T, R]) Len() int

+ type Rune = Mapper[rune]

+ type String = Mapper[string]