lo

Mar 2, 2026

Changes in this version

+ var MustChecker = func(err any, messageArgs ...any)

+ func Clone[T any, Slice ~[]T](collection Slice) Slice

+ func Concat[T any, Slice ~[]T](collections ...Slice) Slice

+ func CountByErr[T any](collection []T, predicate func(item T) (bool, error)) (int, error)

+ func CrossJoinByErr2[A, B, Out any](listA []A, listB []B, transform func(a A, b B) (Out, error)) ([]Out, error)

+ func CrossJoinByErr3[A, B, C, Out any](listA []A, listB []B, listC []C, transform func(a A, b B, c C) (Out, error)) ([]Out, error)

+ func CrossJoinByErr4[A, B, C, D, Out any](listA []A, listB []B, listC []C, listD []D, ...) ([]Out, error)

+ func CrossJoinByErr5[A, B, C, D, E, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, ...) ([]Out, error)

+ func CrossJoinByErr6[A, B, C, D, E, F, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, ...) ([]Out, error)

+ func CrossJoinByErr7[A, B, C, D, E, F, G, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, ...) ([]Out, error)

+ func CrossJoinByErr8[A, B, C, D, E, F, G, H, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, ...) ([]Out, error)

+ func CrossJoinByErr9[A, B, C, D, E, F, G, H, I, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, ...) ([]Out, error)

+ func EarliestByErr[T any](collection []T, iteratee func(item T) (time.Time, error)) (T, error)

+ func FilterErr[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) (bool, error)) (Slice, error)

+ func FilterKeysErr[K comparable, V any](in map[K]V, predicate func(key K, value V) (bool, error)) ([]K, error)

+ func FilterMapToSliceErr[K comparable, V, R any](in map[K]V, iteratee func(key K, value V) (R, bool, error)) ([]R, error)

+ func FilterValuesErr[K comparable, V any](in map[K]V, predicate func(key K, value V) (bool, error)) ([]V, error)

+ func FindDuplicatesByErr[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) (U, error)) (Slice, error)

+ func FindErr[T any](collection []T, predicate func(item T) (bool, error)) (T, error)

+ func FlatMapErr[T, R any](collection []T, transform func(item T, index int) ([]R, error)) ([]R, error)

+ func GroupByErr[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) (U, error)) (map[U]Slice, error)

+ func GroupByMapErr[T any, K comparable, V any](collection []T, transform func(item T) (K, V, error)) (map[K][]V, error)

+ func IntersectBy[T any, K comparable, Slice ~[]T](transform func(T) K, lists ...Slice) Slice

+ func IsSortedBy[T any, K constraints.Ordered](collection []T, iteratee func(item T) K) bool

+ func KeyByErr[K comparable, V any](collection []V, iteratee func(item V) (K, error)) (map[K]V, error)

+ func LatestByErr[T any](collection []T, iteratee func(item T) (time.Time, error)) (T, error)

+ func MapEntriesErr[K1 comparable, V1 any, K2 comparable, V2 any](in map[K1]V1, iteratee func(key K1, value V1) (K2, V2, error)) (map[K2]V2, error)

+ func MapErr[T, R any](collection []T, transform func(item T, index int) (R, error)) ([]R, error)

+ func MapKeysErr[K comparable, V any, R comparable](in map[K]V, iteratee func(value V, key K) (R, error)) (map[R]V, error)

+ func MapToSliceErr[K comparable, V, R any](in map[K]V, iteratee func(key K, value V) (R, error)) ([]R, error)

+ func MapValuesErr[K comparable, V, R any](in map[K]V, iteratee func(value V, key K) (R, error)) (map[K]R, error)

+ func MaxByErr[T any](collection []T, greater func(a, b T) (bool, error)) (T, error)

+ func MaxIndexByErr[T any](collection []T, greater func(a, b T) (bool, error)) (T, int, error)

+ func MeanByErr[T any, R constraints.Float | constraints.Integer](collection []T, iteratee func(item T) (R, error)) (R, error)

+ func MinByErr[T any](collection []T, less func(a, b T) (bool, error)) (T, error)

+ func MinIndexByErr[T any](collection []T, less func(a, b T) (bool, error)) (T, int, error)

+ func OmitByErr[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) (bool, error)) (Map, error)

+ func PartitionByErr[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) (K, error)) ([]Slice, error)

+ func PickByErr[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) (bool, error)) (Map, error)

+ func ProductByErr[T any, R constraints.Float | constraints.Integer | constraints.Complex](collection []T, iteratee func(item T) (R, error)) (R, error)

+ func ReduceErr[T, R any](collection []T, accumulator func(agg R, item T, index int) (R, error), ...) (R, error)

+ func ReduceRightErr[T, R any](collection []T, accumulator func(agg R, item T, index int) (R, error), ...) (R, error)

+ func RejectErr[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) (bool, error)) (Slice, error)

+ func RepeatByErr[T any](count int, callback func(index int) (T, error)) ([]T, error)

+ func Sliding[T any, Slice ~[]T](collection Slice, size, step int) []Slice

+ func SumByErr[T any, R constraints.Float | constraints.Integer | constraints.Complex](collection []T, iteratee func(item T) (R, error)) (R, error)

+ func TakeFilter[T any, Slice ~[]T](collection Slice, n int, predicate func(item T, index int) bool) Slice

+ func TakeWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice

+ func Take[T any, Slice ~[]T](collection Slice, n int) Slice

+ func UniqByErr[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) (U, error)) (Slice, error)

+ func UnzipByErr2[In, A, B any](items []In, iteratee func(In) (a A, b B, err error)) ([]A, []B, error)

+ func UnzipByErr3[In, A, B, C any](items []In, iteratee func(In) (a A, b B, c C, err error)) ([]A, []B, []C, error)

+ func UnzipByErr4[In, A, B, C, D any](items []In, iteratee func(In) (a A, b B, c C, d D, err error)) ([]A, []B, []C, []D, error)

+ func UnzipByErr5[In, A, B, C, D, E any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, err error)) ([]A, []B, []C, []D, []E, error)

+ func UnzipByErr6[In, A, B, C, D, E, F any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, err error)) ([]A, []B, []C, []D, []E, []F, error)

+ func UnzipByErr7[In, A, B, C, D, E, F, G any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G, err error)) ([]A, []B, []C, []D, []E, []F, []G, error)

+ func UnzipByErr8[In, A, B, C, D, E, F, G, H any](items []In, ...) ([]A, []B, []C, []D, []E, []F, []G, []H, error)

+ func UnzipByErr9[In, A, B, C, D, E, F, G, H, I any](items []In, ...) ([]A, []B, []C, []D, []E, []F, []G, []H, []I, error)

+ func Window[T any, Slice ~[]T](collection Slice, size int) []Slice

+ func WithoutByErr[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) (K, error), exclude ...K) (Slice, error)

+ func ZipByErr2[A, B, Out any](a []A, b []B, iteratee func(a A, b B) (Out, error)) ([]Out, error)

+ func ZipByErr3[A, B, C, Out any](a []A, b []B, c []C, iteratee func(a A, b B, c C) (Out, error)) ([]Out, error)

+ func ZipByErr4[A, B, C, D, Out any](a []A, b []B, c []C, d []D, iteratee func(a A, b B, c C, d D) (Out, error)) ([]Out, error)

+ func ZipByErr5[A, B, C, D, E, Out any](a []A, b []B, c []C, d []D, e []E, ...) ([]Out, error)

+ func ZipByErr6[A, B, C, D, E, F, Out any](a []A, b []B, c []C, d []D, e []E, f []F, ...) ([]Out, error)

+ func ZipByErr7[A, B, C, D, E, F, G, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, ...) ([]Out, error)

+ func ZipByErr8[A, B, C, D, E, F, G, H, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, ...) ([]Out, error)

+ func ZipByErr9[A, B, C, D, E, F, G, H, I, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I, ...) ([]Out, error)

Oct 8, 2025

Changes in this version

+ func AssociateI[T any, K comparable, V any](collection []T, transform func(item T, index int) (K, V)) map[K]V

+ func CutPrefix[T comparable, Slice ~[]T](collection, separator Slice) (after Slice, found bool)

+ func CutSuffix[T comparable, Slice ~[]T](collection, separator Slice) (before Slice, found bool)

+ func Cut[T comparable, Slice ~[]T](collection, separator Slice) (before, after Slice, found bool)

+ func FilterKeys[K comparable, V any](in map[K]V, predicate func(key K, value V) bool) []K

+ func FilterSliceToMapI[T any, K comparable, V any](collection []T, transform func(item T, index int) (K, V, bool)) map[K]V

+ func FilterValues[K comparable, V any](in map[K]V, predicate func(key K, value V) bool) []V

+ func HasPrefix[T comparable](collection, prefix []T) bool

+ func HasSuffix[T comparable](collection, suffix []T) bool

+ func Mode[T constraints.Integer | constraints.Float](collection []T) []T

+ func SliceToMapI[T any, K comparable, V any](collection []T, transform func(item T, index int) (K, V)) map[K]V

+ func TrimLeft[T comparable, Slice ~[]T](collection, cutset Slice) Slice

+ func TrimPrefix[T comparable, Slice ~[]T](collection, prefix Slice) Slice

+ func TrimRight[T comparable, Slice ~[]T](collection, cutset Slice) Slice

+ func TrimSuffix[T comparable, Slice ~[]T](collection, suffix Slice) Slice

+ func Trim[T comparable, Slice ~[]T](collection, cutset Slice) Slice

Jun 11, 2025

Changes in this version

+ func Assert(condition bool, message ...string)

+ func Assertf(condition bool, format string, args ...any)

Apr 26, 2025

Changes in this version

+ func ElementsMatchBy[T any, K comparable](list1 []T, list2 []T, iteratee func(item T) K) bool

+ func ElementsMatch[T comparable, Slice ~[]T](list1 Slice, list2 Slice) bool

+ func FilterMapToSlice[K comparable, V any, R any](in map[K]V, iteratee func(key K, value V) (R, bool)) []R

+ func GroupByMap[T any, K comparable, V any](collection []T, iteratee func(item T) (K, V)) map[K][]V

+ func NthOrEmpty[T any, N constraints.Integer](collection []T, nth N) T

+ func NthOr[T any, N constraints.Integer](collection []T, nth N, fallback T) T

Jan 27, 2025

Changes in this version

+ func ChunkEntries[K comparable, V any](m map[K]V, size int) []map[K]V

+ func FilterSliceToMap[T any, K comparable, V any](collection []T, transform func(item T) (K, V, bool)) map[K]V

+ func IsNotNil(x any) bool

+ func NewThrottle(interval time.Duration, f ...func()) (throttle func(), reset func())

+ func NewThrottleByWithCount[T comparable](interval time.Duration, count int, f ...func(key T)) (throttle func(key T), reset func())

+ func NewThrottleBy[T comparable](interval time.Duration, f ...func(key T)) (throttle func(key T), reset func())

+ func NewThrottleWithCount(interval time.Duration, count int, f ...func()) (throttle func(), reset func())

+ func ProductBy[T any, R constraints.Float | constraints.Integer | constraints.Complex](collection []T, iteratee func(item T) R) R

+ func Product[T constraints.Float | constraints.Integer | constraints.Complex](collection []T) T

+ func SampleBy[T any](collection []T, randomIntGenerator randomIntGenerator) T

+ func SamplesBy[T any, Slice ~[]T](collection Slice, count int, randomIntGenerator randomIntGenerator) Slice

Jan 25, 2025

Changes in this version

+ func BufferWithContext[T any](ctx context.Context, ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)

+ func CoalesceMapOrEmpty[K comparable, V any](v ...map[K]V) map[K]V

+ func CoalesceMap[K comparable, V any](v ...map[K]V) (map[K]V, bool)

+ func CoalesceSliceOrEmpty[T any](v ...[]T) []T

+ func CoalesceSlice[T any](v ...[]T) ([]T, bool)

+ func CrossJoinBy2[A, B, Out any](listA []A, listB []B, project func(a A, b B) Out) []Out

+ func CrossJoinBy3[A, B, C, Out any](listA []A, listB []B, listC []C, project func(a A, b B, c C) Out) []Out

+ func CrossJoinBy4[A, B, C, D, Out any](listA []A, listB []B, listC []C, listD []D, ...) []Out

+ func CrossJoinBy5[A, B, C, D, E, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, ...) []Out

+ func CrossJoinBy6[A, B, C, D, E, F, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, ...) []Out

+ func CrossJoinBy7[A, B, C, D, E, F, G, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, ...) []Out

+ func CrossJoinBy8[A, B, C, D, E, F, G, H, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, ...) []Out

+ func CrossJoinBy9[A, B, C, D, E, F, G, H, I, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, ...) []Out

+ func Ellipsis(str string, length int) string

+ func Keyify[T comparable, Slice ~[]T](collection Slice) map[T]struct

+ func MaxIndexBy[T any](collection []T, comparison func(a T, b T) bool) (T, int)

+ func MaxIndex[T constraints.Ordered](collection []T) (T, int)

+ func MinIndexBy[T any](collection []T, comparison func(a T, b T) bool) (T, int)

+ func MinIndex[T constraints.Ordered](collection []T) (T, int)

+ func UniqMap[T any, R comparable](collection []T, iteratee func(item T, index int) R) []R

+ func WithoutBy[T any, K comparable](collection []T, iteratee func(item T) K, exclude ...K) []T

+ func WithoutNth[T comparable, Slice ~[]T](collection Slice, nths ...int) Slice

type Tuple2

+ func CrossJoin2[A, B any](listA []A, listB []B) []Tuple2[A, B]

type Tuple3

+ func CrossJoin3[A, B, C any](listA []A, listB []B, listC []C) []Tuple3[A, B, C]

type Tuple4

+ func CrossJoin4[A, B, C, D any](listA []A, listB []B, listC []C, listD []D) []Tuple4[A, B, C, D]

type Tuple5

+ func CrossJoin5[A, B, C, D, E any](listA []A, listB []B, listC []C, listD []D, listE []E) []Tuple5[A, B, C, D, E]

type Tuple6

+ func CrossJoin6[A, B, C, D, E, F any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F) []Tuple6[A, B, C, D, E, F]

type Tuple7

+ func CrossJoin7[A, B, C, D, E, F, G any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G) []Tuple7[A, B, C, D, E, F, G]

type Tuple8

+ func CrossJoin8[A, B, C, D, E, F, G, H any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, ...) []Tuple8[A, B, C, D, E, F, G, H]

type Tuple9

+ func CrossJoin9[A, B, C, D, E, F, G, H, I any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, ...) []Tuple9[A, B, C, D, E, F, G, H, I]

Aug 13, 2024

Changes in this version

+ func FromSlicePtrOr[T any](collection []*T, fallback T) []T

+ func FromSlicePtr[T any](collection []*T) []T

+ func UniqKeys[K comparable, V any](in ...map[K]V) []K

+ func UniqValues[K comparable, V comparable](in ...map[K]V) []V

Jul 15, 2024

Changes in this version

+ func ForEachWhile[T any](collection []T, iteratee func(item T, index int) (goon bool))

+ func WaitForWithContext(ctx context.Context, ...) (totalIterations int, elapsed time.Duration, conditionFound bool)

Jul 13, 2024

Changes in this version

+ func EarliestBy[T any](collection []T, iteratee func(item T) time.Time) T

+ func LatestBy[T any](collection []T, iteratee func(item T) time.Time) T

Jun 30, 2024

Changes in this version

+ func DropByIndex[T any](collection []T, indexes ...int) []T

+ func Splice[T any, Slice ~[]T](collection Slice, i int, elements ...T) Slice

Jun 28, 2024

Changes in this version

+ func HasKey[K comparable, V any](in map[K]V, key K) bool

+ func WaitFor(condition func(i int) bool, maxDuration time.Duration, tick time.Duration) (int, time.Duration, bool)

Jun 27, 2024

Changes in this version

+ func FirstOrEmpty[T any](collection []T) T

+ func FirstOr[T any](collection []T, fallback T) T

+ func First[T any](collection []T) (T, bool)

+ func LastOrEmpty[T any](collection []T) T

+ func LastOr[T any](collection []T, fallback T) T

+ func Nil[T any]() *T

Jun 27, 2024

Changes in this version

+ func CoalesceOrEmpty[T comparable](v ...T) T

+ func Duration(cb func()) time.Duration

+ func Duration0(cb func()) time.Duration

+ func Duration10[A, B, C, D, E, F, G, H, I, J any](cb func() (A, B, C, D, E, F, G, H, I, J)) (A, B, C, D, E, F, G, H, I, J, time.Duration)

+ func Duration1[A any](cb func() A) (A, time.Duration)

+ func Duration2[A, B any](cb func() (A, B)) (A, B, time.Duration)

+ func Duration3[A, B, C any](cb func() (A, B, C)) (A, B, C, time.Duration)

+ func Duration4[A, B, C, D any](cb func() (A, B, C, D)) (A, B, C, D, time.Duration)

+ func Duration5[A, B, C, D, E any](cb func() (A, B, C, D, E)) (A, B, C, D, E, time.Duration)

+ func Duration6[A, B, C, D, E, F any](cb func() (A, B, C, D, E, F)) (A, B, C, D, E, F, time.Duration)

+ func Duration7[A, B, C, D, E, F, G any](cb func() (A, B, C, D, E, F, G)) (A, B, C, D, E, F, G, time.Duration)

+ func Duration8[A, B, C, D, E, F, G, H any](cb func() (A, B, C, D, E, F, G, H)) (A, B, C, D, E, F, G, H, time.Duration)

+ func Duration9[A, B, C, D, E, F, G, H, I any](cb func() (A, B, C, D, E, F, G, H, I)) (A, B, C, D, E, F, G, H, I, time.Duration)

+ func Earliest(times ...time.Time) time.Time

+ func Elipse(str string, length int) string

+ func FilterReject[V any](collection []V, predicate func(V, int) bool) (kept []V, rejected []V)

+ func Latest(times ...time.Time) time.Time

+ func RejectMap[T any, R any](collection []T, callback func(item T, index int) (R, bool)) []R

Jun 27, 2024

Changes in this version

+ func CamelCase(str string) string

+ func Capitalize(str string) string

+ func KebabCase(str string) string

+ func MeanBy[T any, R constraints.Float | constraints.Integer](collection []T, iteratee func(item T) R) R

+ func Mean[T constraints.Float | constraints.Integer](collection []T) T

+ func PascalCase(str string) string

+ func SnakeCase(str string) string

+ func UnzipBy2[In any, A any, B any](items []In, iteratee func(In) (a A, b B)) ([]A, []B)

+ func UnzipBy3[In any, A any, B any, C any](items []In, iteratee func(In) (a A, b B, c C)) ([]A, []B, []C)

+ func UnzipBy4[In any, A any, B any, C any, D any](items []In, iteratee func(In) (a A, b B, c C, d D)) ([]A, []B, []C, []D)

+ func UnzipBy5[In any, A any, B any, C any, D any, E any](items []In, iteratee func(In) (a A, b B, c C, d D, e E)) ([]A, []B, []C, []D, []E)

+ func UnzipBy6[In any, A any, B any, C any, D any, E any, F any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F)) ([]A, []B, []C, []D, []E, []F)

+ func UnzipBy7[In any, A any, B any, C any, D any, E any, F any, G any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G)) ([]A, []B, []C, []D, []E, []F, []G)

+ func UnzipBy8[In any, A any, B any, C any, D any, E any, F any, G any, H any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G, h H)) ([]A, []B, []C, []D, []E, []F, []G, []H)

+ func UnzipBy9[In any, A any, B any, C any, D any, E any, F any, G any, H any, I any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G, h H, i I)) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)

+ func Words(str string) []string

+ func ZipBy2[A any, B any, Out any](a []A, b []B, iteratee func(a A, b B) Out) []Out

+ func ZipBy3[A any, B any, C any, Out any](a []A, b []B, c []C, iteratee func(a A, b B, c C) Out) []Out

+ func ZipBy4[A any, B any, C any, D any, Out any](a []A, b []B, c []C, d []D, iteratee func(a A, b B, c C, d D) Out) []Out

+ func ZipBy5[A any, B any, C any, D any, E any, Out any](a []A, b []B, c []C, d []D, e []E, iteratee func(a A, b B, c C, d D, e E) Out) []Out

+ func ZipBy6[A any, B any, C any, D any, E any, F any, Out any](a []A, b []B, c []C, d []D, e []E, f []F, ...) []Out

+ func ZipBy7[A any, B any, C any, D any, E any, F any, G any, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, ...) []Out

+ func ZipBy8[A any, B any, C any, D any, E any, F any, G any, H any, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, ...) []Out

+ func ZipBy9[A any, B any, C any, D any, E any, F any, G any, H any, I any, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I, ...) []Out

Dec 2, 2023

Changes in this version

+ func IsNil(x any) bool

Mar 20, 2023

Changes in this version

+ func EmptyableToPtr(x T) *T

+ func NewDebounceBy(duration time.Duration, f ...func(key T, count int)) (func(key T), func(key T))

+ func ValueOr(in map[K]V, key K, fallback V) V

Dec 15, 2022

Changes in this version

+ func Partial1(f func(T1, T2) R, arg1 T1) func(T2) R

+ func Partial2(f func(T1, T2, T3) R, arg1 T1) func(T2, T3) R

+ func Partial3(f func(T1, T2, T3, T4) R, arg1 T1) func(T2, T3, T4) R

+ func Partial4(f func(T1, T2, T3, T4, T5) R, arg1 T1) func(T2, T3, T4, T5) R

+ func Partial5(f func(T1, T2, T3, T4, T5, T6) R, arg1 T1) func(T2, T3, T4, T5, T6) R

+ type Transaction struct

+ func NewTransaction() *Transaction[T]

+ func (t *Transaction[T]) Process(state T) (T, error)

+ func (t *Transaction[T]) Then(exec func(T) (T, error), onRollback func(T) T) *Transaction[T]

Nov 28, 2022

Changes in this version

+ func AttemptWhile(maxIteration int, f func(int) (error, bool)) (int, error)

+ func AttemptWhileWithDelay(maxIteration int, delay time.Duration, ...) (int, time.Duration, error)

Nov 15, 2022

Changes in this version

+ var AllCharset = append(AlphanumericCharset, SpecialCharset)

+ var AlphanumericCharset = append(LettersCharset, NumbersCharset)

+ var LettersCharset = append(LowerCaseLettersCharset, UpperCaseLettersCharset)

+ var LowerCaseLettersCharset = []rune("abcdefghijklmnopqrstuvwxyz")

+ var NumbersCharset = []rune("0123456789")

+ var SpecialCharset = []rune("!@#$%^&*()_+-=[]{}|;':\",./<>?")

+ var UpperCaseLettersCharset = []rune("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

+ func Buffer(ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)

+ func BufferWithTimeout(ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool)

+ func RandomString(size int, charset []rune) string

Nov 11, 2022

Changes in this version

+ func FanIn(channelBufferCap int, upstreams ...<-chan T) <-chan T

+ func FanOut(count int, channelsBufferCap int, upstream <-chan T) []<-chan T

Oct 14, 2022

Changes in this version

+ func ChannelMerge(channelBufferCap int, upstreams ...<-chan T) <-chan T

Oct 10, 2022

Changes in this version

+ func ChannelToSlice(ch <-chan T) []T

+ func CountValues(collection []T) map[T]int

+ func CountValuesBy(collection []T, mapper func(T) U) map[U]int

+ func Interleave(collections ...[]T) []T

+ func MapEntries(in map[K1]V1, iteratee func(K1, V1) (K2, V2)) map[K2]V2

+ func Sum(collection []T) T

type Tuple2

+ func (t Tuple2[A, B]) Unpack() (A, B)

type Tuple3

+ func (t Tuple3[A, B, C]) Unpack() (A, B, C)

type Tuple4

+ func (t Tuple4[A, B, C, D]) Unpack() (A, B, C, D)

type Tuple5

+ func (t Tuple5[A, B, C, D, E]) Unpack() (A, B, C, D, E)

type Tuple6

+ func (t Tuple6[A, B, C, D, E, F]) Unpack() (A, B, C, D, E, F)

type Tuple7

+ func (t Tuple7[A, B, C, D, E, F, G]) Unpack() (A, B, C, D, E, F, G)

type Tuple8

+ func (t Tuple8[A, B, C, D, E, F, G, H]) Unpack() (A, B, C, D, E, F, G, H)

type Tuple9

+ func (t Tuple9[A, B, C, D, E, F, G, H, I]) Unpack() (A, B, C, D, E, F, G, H, I)

Oct 6, 2022

Changes in this version

+ func Batch(ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)

+ func BatchWithTimeout(ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool)

+ func Generator(bufferSize int, generator func(yield func(T))) <-chan T

+ func SliceToChannel(bufferSize int, collection []T) <-chan T

Oct 4, 2022

Changes in this version

+ func TernaryF(condition bool, ifFunc func() T, elseFunc func() T) T

+ func Validate(ok bool, format string, args ...any) error

Oct 2, 2022

Changes in this version

+ func ErrorsAs(err error) (T, bool)

+ func TryOr(callback func() (A, error), fallbackA A) (A, bool)

+ func TryOr1(callback func() (A, error), fallbackA A) (A, bool)

+ func TryOr2(callback func() (A, B, error), fallbackA A, fallbackB B) (A, B, bool)

+ func TryOr3(callback func() (A, B, C, error), fallbackA A, fallbackB B, fallbackC C) (A, B, C, bool)

+ func TryOr4(callback func() (A, B, C, D, error), fallbackA A, fallbackB B, fallbackC C, ...) (A, B, C, D, bool)

+ func TryOr5(callback func() (A, B, C, D, E, error), fallbackA A, fallbackB B, fallbackC C, ...) (A, B, C, D, E, bool)

+ func TryOr6(callback func() (A, B, C, D, E, F, error), fallbackA A, fallbackB B, ...) (A, B, C, D, E, F, bool)

Sep 5, 2022

Changes in this version

+ func ChannelDispatcher(stream <-chan T, count int, channelBufferCap int, ...) []<-chan T

+ func DispatchingStrategyFirst(msg T, index uint64, channels []<-chan T) int

+ func DispatchingStrategyLeast(msg T, index uint64, channels []<-chan T) int

+ func DispatchingStrategyMost(msg T, index uint64, channels []<-chan T) int

+ func DispatchingStrategyRandom(msg T, index uint64, channels []<-chan T) int

+ func DispatchingStrategyRoundRobin(msg T, index uint64, channels []<-chan T) int

+ type DispatchingStrategy func(msg T, index uint64, channels []<-chan T) int

+ func DispatchingStrategyWeightedRandom(weigths []int) DispatchingStrategy[T]

Jul 29, 2022

Changes in this version

+ func ChunkString(str T, size int) []T

+ func SliceToMap(collection []T, transform func(T) (K, V)) map[K]V

Jul 24, 2022

Changes in this version

+ func Associate(collection []T, transform func(T) (K, V)) map[K]V

+ func FromPtrOr(x *T, fallback T) T

+ func IsSorted(collection []T) bool

+ func IsSortedByKey(collection []T, iteratee func(T) K) bool

+ func MapToSlice(in map[K]V, iteratee func(V, K) R) []R

+ func ReduceRight(collection []T, accumulator func(R, T, int) R, initial R) R

Jul 4, 2022

Changes in this version

+ func FindDuplicates(collection []T) []T

+ func FindDuplicatesBy(collection []T, iteratee func(T) U) []T

+ func FindUniques(collection []T) []T

+ func FindUniquesBy(collection []T, iteratee func(T) U) []T

+ func IsNotEmpty(v T) bool

Jul 4, 2022

Changes in this version

+ func Without(collection []T, exclude ...T) []T

+ func WithoutEmpty(collection []T) []T

Jul 3, 2022

Changes in this version

+ func FindKey(object map[K]V, value V) (K, bool)

+ func FindKeyBy(object map[K]V, predicate func(K, V) bool) (K, bool)

Jul 3, 2022

Changes in this version

+ func Compact(collection []T) []T

+ func FromPairs(entries []Entry[K, V]) map[K]V

+ func FromPtr(x *T) T

+ func IsEmpty(v T) bool

+ func Partial(f func(T1, T2) R, arg1 T1) func(T2) R

+ func Slice(collection []T, start int, end int) []T

type Entry

+ func ToPairs(in map[K]V) []Entry[K, V]

May 10, 2022

Changes in this version

+ func FromAnySlice(in []any) (out []T, ok bool)

+ func ToAnySlice(collection []T) []any

May 2, 2022

Changes in this version

+ func SumBy(collection []T, iteratee func(T) R) R

+ func Synchronize(opt ...sync.Locker) *synchronize

Apr 30, 2022

Changes in this version

+ func RepeatBy(count int, predicate func(int) T) []T

+ func Replace(collection []T, old T, new T, n int) []T

+ func ReplaceAll(collection []T, old T, new T) []T

+ func RuneLength(str string) int

+ func Subset(collection []T, offset int, length uint) []T

+ func Substring(str T, offset int, length uint) T

Apr 28, 2022

Changes in this version

+ func EveryBy(collection []V, predicate func(V) bool) bool

+ func None(collection []V, subset []V) bool

+ func NoneBy(collection []V, predicate func(V) bool) bool

+ func SomeBy(collection []V, predicate func(V) bool) bool

Apr 27, 2022

Changes in this version

+ func Async0(f func()) chan struct

+ func Async1(f func() A) chan A

+ func Async2(f func() (A, B)) chan Tuple2[A, B]

+ func Async3(f func() (A, B, C)) chan Tuple3[A, B, C]

+ func Async4(f func() (A, B, C, D)) chan Tuple4[A, B, C, D]

+ func Async5(f func() (A, B, C, D, E)) chan Tuple5[A, B, C, D, E]

+ func Async6(f func() (A, B, C, D, E, F)) chan Tuple6[A, B, C, D, E, F]

+ func Unpack2(tuple Tuple2[A, B]) (A, B)

+ func Unpack3(tuple Tuple3[A, B, C]) (A, B, C)

+ func Unpack4(tuple Tuple4[A, B, C, D]) (A, B, C, D)

+ func Unpack5(tuple Tuple5[A, B, C, D, E]) (A, B, C, D, E)

+ func Unpack6(tuple Tuple6[A, B, C, D, E, F]) (A, B, C, D, E, F)

+ func Unpack7(tuple Tuple7[A, B, C, D, E, F, G]) (A, B, C, D, E, F, G)

+ func Unpack8(tuple Tuple8[A, B, C, D, E, F, G, H]) (A, B, C, D, E, F, G, H)

+ func Unpack9(tuple Tuple9[A, B, C, D, E, F, G, H, I]) (A, B, C, D, E, F, G, H, I)

Apr 26, 2022

Changes in this version

+ func AttemptWithDelay(maxIteration int, delay time.Duration, f func(int, time.Duration) error) (int, time.Duration, error)

Apr 21, 2022

Changes in this version

+ func Coalesce(v ...T) (result T, ok bool)

Apr 14, 2022

Changes in this version

+ func Clamp(value T, min T, max T) T

+ func IfF(condition bool, resultF func() T) *ifElse[T]

+ func Invert(in map[K]V) map[V]K

+ func MapKeys(in map[K]V, iteratee func(V, K) R) map[R]V

+ func OmitBy(in map[K]V, predicate func(K, V) bool) map[K]V

+ func OmitByKeys(in map[K]V, keys []K) map[K]V

+ func OmitByValues(in map[K]V, values []V) map[K]V

+ func PickBy(in map[K]V, predicate func(K, V) bool) map[K]V

+ func PickByKeys(in map[K]V, keys []K) map[K]V

+ func PickByValues(in map[K]V, values []V) map[K]V

type Tuple2

+ func T2(a A, b B) Tuple2[A, B]

type Tuple3

+ func T3(a A, b B, c C) Tuple3[A, B, C]

type Tuple4

+ func T4(a A, b B, c C, d D) Tuple4[A, B, C, D]

type Tuple5

+ func T5(a A, b B, c C, d D, e E) Tuple5[A, B, C, D, E]

type Tuple6

+ func T6(a A, b B, c C, d D, e E, f F) Tuple6[A, B, C, D, E, F]

type Tuple7

+ func T7(a A, b B, c C, d D, e E, f F, g G) Tuple7[A, B, C, D, E, F, G]

type Tuple8

+ func T8(a A, b B, c C, d D, e E, f F, g G, h H) Tuple8[A, B, C, D, E, F, G, H]

type Tuple9

+ func T9(a A, b B, c C, d D, e E, f F, g G, h H, i I) Tuple9[A, B, C, D, E, F, G, H, I]

Apr 11, 2022

Changes in this version

+ func Async(f func() T) chan T

+ func Count(collection []T, value T) (count int)

+ func CountBy(collection []T, predicate func(T) bool) (count int)

+ func FilterMap(collection []T, callback func(T, int) (R, bool)) []R

+ func FindIndexOf(collection []T, predicate func(T) bool) (T, int, bool)

+ func FindLastIndexOf(collection []T, predicate func(T) bool) (T, int, bool)

+ func FindOrElse(collection []T, fallback T, predicate func(T) bool) T

+ func MaxBy(collection []T, comparison func(T, T) bool) T

+ func MinBy(collection []T, comparison func(T, T) bool) T

+ func Must(val T, err error) T

+ func Must0(err error)

+ func Must1(val T, err error) T

+ func Must2(val1 T1, val2 T2, err error) (T1, T2)

+ func Must3(val1 T1, val2 T2, val3 T3, err error) (T1, T2, T3)

+ func Must4(val1 T1, val2 T2, val3 T3, val4 T4, err error) (T1, T2, T3, T4)

+ func Must5(val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err error) (T1, T2, T3, T4, T5)

+ func Must6(val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, val6 T6, err error) (T1, T2, T3, T4, T5, T6)

Mar 20, 2022

Changes in this version

+ func NewDebounce(duration time.Duration, f ...func()) (func(), func())

+ func Reject(collection []V, predicate func(V, int) bool) []V

+ func Try(callback func() error) (ok bool)

+ func Try0(callback func()) bool

+ func Try1(callback func() error) bool

+ func Try2(callback func() (T, error)) bool

+ func Try3(callback func() (T, R, error)) bool

+ func Try4(callback func() (T, R, S, error)) bool

+ func Try5(callback func() (T, R, S, Q, error)) bool

+ func Try6(callback func() (T, R, S, Q, U, error)) bool

+ func TryCatch(callback func() error, catch func())

+ func TryCatchWithErrorValue(callback func() error, catch func(any))

+ func TryWithErrorValue(callback func() error) (errorValue any, ok bool)

Mar 12, 2022

Changes in this version

+ func KeyBy(collection []V, iteratee func(V) K) map[K]V

Mar 10, 2022

Changes in this version

+ func Range(elementNum int) []int

+ func RangeFrom(start T, elementNum int) []T

+ func RangeWithSteps(start, end, step T) []T

Mar 10, 2022

Changes in this version

+ func Drop(collection []T, n int) []T

+ func DropRight(collection []T, n int) []T

+ func DropRightWhile(collection []T, predicate func(T) bool) []T

+ func DropWhile(collection []T, predicate func(T) bool) []T

Mar 10, 2022

Changes in this version

+ func Union(list1 []T, list2 []T) []T

Mar 8, 2022

Changes in this version

+ func ContainsBy(collection []T, predicate func(T) bool) bool

+ func FlatMap(collection []T, iteratee func(T, int) []R) []R

+ func MapValues(in map[K]V, iteratee func(V, K) R) map[K]R

Mar 5, 2022

Changes in this version

+ func Empty() T

+ func Sample(collection []T) T

+ func Samples(collection []T, count int) []T

Mar 5, 2022

Changes in this version

+ func Attempt(maxIteration int, f func(int) error) (int, error)

+ func Repeat(count int, initial T) []T

+ func Times(count int, iteratee func(int) T) []T

Mar 5, 2022

Changes in this version

+ func PartitionBy(collection []T, iteratee func(x T) K) [][]T

+ func Unzip2(tuples []Tuple2[A, B]) ([]A, []B)

+ func Unzip3(tuples []Tuple3[A, B, C]) ([]A, []B, []C)

+ func Unzip4(tuples []Tuple4[A, B, C, D]) ([]A, []B, []C, []D)

+ func Unzip5(tuples []Tuple5[A, B, C, D, E]) ([]A, []B, []C, []D, []E)

+ func Unzip6(tuples []Tuple6[A, B, C, D, E, F]) ([]A, []B, []C, []D, []E, []F)

+ func Unzip7(tuples []Tuple7[A, B, C, D, E, F, G]) ([]A, []B, []C, []D, []E, []F, []G)

+ func Unzip8(tuples []Tuple8[A, B, C, D, E, F, G, H]) ([]A, []B, []C, []D, []E, []F, []G, []H)

+ func Unzip9(tuples []Tuple9[A, B, C, D, E, F, G, H, I]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)

+ type Tuple2 struct

+ A A

+ B B

+ func Zip2(a []A, b []B) []Tuple2[A, B]

+ type Tuple3 struct

+ A A

+ B B

+ C C

+ func Zip3(a []A, b []B, c []C) []Tuple3[A, B, C]

+ type Tuple4 struct

+ A A

+ B B

+ C C

+ D D

+ func Zip4(a []A, b []B, c []C, d []D) []Tuple4[A, B, C, D]

+ type Tuple5 struct

+ A A

+ B B

+ C C

+ D D

+ E E

+ func Zip5(a []A, b []B, c []C, d []D, e []E) []Tuple5[A, B, C, D, E]

+ type Tuple6 struct

+ A A

+ B B

+ C C

+ D D

+ E E

+ F F

+ func Zip6(a []A, b []B, c []C, d []D, e []E, f []F) []Tuple6[A, B, C, D, E, F]

+ type Tuple7 struct

+ A A

+ B B

+ C C

+ D D

+ E E

+ F F

+ G G

+ func Zip7(a []A, b []B, c []C, d []D, e []E, f []F, g []G) []Tuple7[A, B, C, D, E, F, G]

+ type Tuple8 struct

+ A A

+ B B

+ C C

+ D D

+ E E

+ F F

+ G G

+ H H

+ func Zip8(a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H) []Tuple8[A, B, C, D, E, F, G, H]

+ type Tuple9 struct

+ A A

+ B B

+ C C

+ D D

+ E E

+ F F

+ G G

+ H H

+ I I

+ func Zip9(a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I) []Tuple9[A, B, C, D, E, F, G, H, I]

Mar 2, 2022

Changes in this version

+ func Assign(maps ...map[K]V) map[K]V

+ func Chunk(collection []T, size int) [][]T

+ func Contains(collection []T, element T) bool

+ func Difference(list1 []T, list2 []T) ([]T, []T)

+ func Every(collection []T, subset []T) bool

+ func Fill(collection []T, initial T) []T

+ func Filter(collection []V, predicate func(V) bool) []V

+ func Find(collection []T, predicate func(T) bool) (T, bool)

+ func Flatten(collection [][]T) []T

+ func ForEach(collection []T, iteratee func(T))

+ func FromEntries(entries []Entry[K, V]) map[K]V

+ func GroupBy(collection []T, iteratee func(T) U) map[U][]T

+ func If(condition bool, result T) *ifElse[T]

+ func IndexOf(collection []T, element T) int

+ func Intersect(list1 []T, list2 []T) []T

+ func Keys(in map[K]V) []K

+ func Last(collection []T) T

+ func LastIndexOf(collection []T, element T) int

+ func Map(collection []T, iteratee func(T) R) []R

+ func Max(collection []T) T

+ func Min(collection []T) T

+ func Nth(collection []T, nth int) T

+ func Reduce(collection []T, accumulator func(R, T) R, initial R) R

+ func Reverse(collection []T) []T

+ func Shuffle(collection []T) []T

+ func Some(collection []T, subset []T) bool

+ func Switch(predicate T) *switchCase[T, R]

+ func Ternary(condition bool, ifOutput T, elseOutput T) T

+ func ToMap(collection []V, iteratee func(V) K) map[K]V

+ func ToPtr(x T) *T

+ func ToSlicePtr(collection []T) []*T

+ func Uniq(collection []T) []T

+ func UniqBy(collection []T, iteratee func(T) U) []T

+ func Values(in map[K]V) []V

+ type Clonable interface

+ Clone func() T

+ type Entry struct

+ Key K

+ Value V

+ func Entries(in map[K]V) []Entry[K, V]

+ type Ordered interface