README
¶
wiz - Iterators optimizer for wizardry
Iterator-style library based on https://github.com/samber/lo.
Design goals:
- Adopt go iterators wherever possible
- Subset functionality from the original lib to reduce dependencies (namely,
x/text)
Documentation
¶
Overview ¶
Example (IfElse_Else) ¶
result1 := If(true, 1).
ElseIf(false, 2).
Else(3)
result2 := If(false, 1).
ElseIf(true, 2).
Else(3)
result3 := If(false, 1).
ElseIf(false, 2).
Else(3)
result4 := IfF(true, func() int { return 1 }).
ElseIfF(false, func() int { return 2 }).
ElseF(func() int { return 3 })
result5 := IfF(false, func() int { return 1 }).
ElseIfF(true, func() int { return 2 }).
ElseF(func() int { return 3 })
result6 := IfF(false, func() int { return 1 }).
ElseIfF(false, func() int { return 2 }).
ElseF(func() int { return 3 })
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
fmt.Printf("%v\n", result6)
Output: 1 2 3 1 2 3
Example (IfElse_ElseF) ¶
result1 := If(true, 1).
ElseIf(false, 2).
Else(3)
result2 := If(false, 1).
ElseIf(true, 2).
Else(3)
result3 := If(false, 1).
ElseIf(false, 2).
Else(3)
result4 := IfF(true, func() int { return 1 }).
ElseIfF(false, func() int { return 2 }).
ElseF(func() int { return 3 })
result5 := IfF(false, func() int { return 1 }).
ElseIfF(true, func() int { return 2 }).
ElseF(func() int { return 3 })
result6 := IfF(false, func() int { return 1 }).
ElseIfF(false, func() int { return 2 }).
ElseF(func() int { return 3 })
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
fmt.Printf("%v\n", result6)
Output: 1 2 3 1 2 3
Example (IfElse_ElseIf) ¶
result1 := If(true, 1).
ElseIf(false, 2).
Else(3)
result2 := If(false, 1).
ElseIf(true, 2).
Else(3)
result3 := If(false, 1).
ElseIf(false, 2).
Else(3)
result4 := IfF(true, func() int { return 1 }).
ElseIfF(false, func() int { return 2 }).
ElseF(func() int { return 3 })
result5 := IfF(false, func() int { return 1 }).
ElseIfF(true, func() int { return 2 }).
ElseF(func() int { return 3 })
result6 := IfF(false, func() int { return 1 }).
ElseIfF(false, func() int { return 2 }).
ElseF(func() int { return 3 })
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
fmt.Printf("%v\n", result6)
Output: 1 2 3 1 2 3
Example (IfElse_ElseIfF) ¶
result1 := If(true, 1).
ElseIf(false, 2).
Else(3)
result2 := If(false, 1).
ElseIf(true, 2).
Else(3)
result3 := If(false, 1).
ElseIf(false, 2).
Else(3)
result4 := IfF(true, func() int { return 1 }).
ElseIfF(false, func() int { return 2 }).
ElseF(func() int { return 3 })
result5 := IfF(false, func() int { return 1 }).
ElseIfF(true, func() int { return 2 }).
ElseF(func() int { return 3 })
result6 := IfF(false, func() int { return 1 }).
ElseIfF(false, func() int { return 2 }).
ElseF(func() int { return 3 })
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
fmt.Printf("%v\n", result6)
Output: 1 2 3 1 2 3
Example (SwitchCase_Case) ¶
result1 := Switch[int, string](1).
Case(1, "1").
Case(2, "2").
Default("3")
result2 := Switch[int, string](2).
Case(1, "1").
Case(2, "2").
Default("3")
result3 := Switch[int, string](42).
Case(1, "1").
Case(2, "2").
Default("3")
result4 := Switch[int, string](1).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
result5 := Switch[int, string](2).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
result6 := Switch[int, string](42).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
fmt.Printf("%v\n", result6)
Output: 1 2 3 1 2 3
Example (SwitchCase_CaseF) ¶
result1 := Switch[int, string](1).
Case(1, "1").
Case(2, "2").
Default("3")
result2 := Switch[int, string](2).
Case(1, "1").
Case(2, "2").
Default("3")
result3 := Switch[int, string](42).
Case(1, "1").
Case(2, "2").
Default("3")
result4 := Switch[int, string](1).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
result5 := Switch[int, string](2).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
result6 := Switch[int, string](42).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
fmt.Printf("%v\n", result6)
Output: 1 2 3 1 2 3
Example (SwitchCase_Default) ¶
result1 := Switch[int, string](1).
Case(1, "1").
Case(2, "2").
Default("3")
result2 := Switch[int, string](2).
Case(1, "1").
Case(2, "2").
Default("3")
result3 := Switch[int, string](42).
Case(1, "1").
Case(2, "2").
Default("3")
result4 := Switch[int, string](1).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
result5 := Switch[int, string](2).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
result6 := Switch[int, string](42).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
fmt.Printf("%v\n", result6)
Output: 1 2 3 1 2 3
Example (SwitchCase_DefaultF) ¶
result1 := Switch[int, string](1).
Case(1, "1").
Case(2, "2").
Default("3")
result2 := Switch[int, string](2).
Case(1, "1").
Case(2, "2").
Default("3")
result3 := Switch[int, string](42).
Case(1, "1").
Case(2, "2").
Default("3")
result4 := Switch[int, string](1).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
result5 := Switch[int, string](2).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
result6 := Switch[int, string](42).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
fmt.Printf("%v\n", result6)
Output: 1 2 3 1 2 3
Index ¶
- func Assign[K comparable, V any, Map ~map[K]V](maps ...Map) Map
- func Assoc[T any, K comparable, V any](collection []T, transform func(item T, idx int) (K, V)) map[K]V
- func Async[A any](f func() A) <-chan A
- func Async0(f func()) <-chan struct{}
- func Async1[A any](f func() A) <-chan A
- func Async2[A, B any](f func() (A, B)) <-chan Tuple2[A, B]
- func Async3[A, B, C any](f func() (A, B, C)) <-chan Tuple3[A, B, C]
- func Async4[A, B, C, D any](f func() (A, B, C, D)) <-chan Tuple4[A, B, C, D]
- func Async5[A, B, C, D, E any](f func() (A, B, C, D, E)) <-chan Tuple5[A, B, C, D, E]
- func Async6[A, B, C, D, E, F any](f func() (A, B, C, D, E, F)) <-chan Tuple6[A, B, C, D, E, F]
- func Attempt(maxIteration int, f func(index int) error) (int, error)
- func AttemptWhile(maxIteration int, f func(int) (error, bool)) (int, error)
- func AttemptWhileWithDelay(maxIteration int, delay time.Duration, ...) (int, time.Duration, error)
- func AttemptWithDelay(maxIteration int, delay time.Duration, ...) (int, time.Duration, error)
- func Batch[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)deprecated
- func BatchWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool)deprecated
- func Buffer[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)
- func BufferWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool)
- func Chain[V any](iters ...iter.Seq[V]) iter.Seq[V]
- func ChannelDispatcher[T any](stream <-chan T, count int, channelBufferCap int, ...) []<-chan T
- func ChannelMerge[T any](channelBufferCap int, upstreams ...<-chan T) <-chan Tdeprecated
- func ChannelToSlice[T any](ch <-chan T) []T
- func Chunk[T any, Slice ~[]T](collection Slice, size int) []Slice
- func Clamp[T cmp.Ordered](value T, min T, max T) T
- func Coalesce[T comparable](values ...T) (result T, ok bool)
- func CoalesceOrEmpty[T comparable](v ...T) T
- func Compact[T comparable, Slice ~[]T](collection Slice) Slice
- func Contains[T comparable](collection []T, element T) bool
- func ContainsBy[T any](collection []T, predicate func(item T) bool) bool
- func Count[T comparable](collection []T, value T) (count int)
- func CountBy[T any](collection []T, predicate func(item T) bool) (count int)
- func CountValues[T comparable](collection []T) map[T]int
- func CountValuesBy[T any, U comparable](collection []T, mapper func(item T) U) map[U]int
- func Difference[T comparable, Slice ~[]T](list1 Slice, list2 Slice) (Slice, Slice)
- func DispatchingStrategyFirst[T any](msg T, index uint64, channels []<-chan T) int
- func DispatchingStrategyLeast[T any](msg T, index uint64, channels []<-chan T) int
- func DispatchingStrategyMost[T any](msg T, index uint64, channels []<-chan T) int
- func DispatchingStrategyRandom[T any](gen *rand.Rand, msg T, index uint64, channels []<-chan T) int
- func DispatchingStrategyRoundRobin[T any](msg T, index uint64, channels []<-chan T) int
- func Drop[T any, Slice ~[]T](collection Slice, n int) Slice
- func DropByIndex[T any](collection []T, indexes ...int) []T
- func DropRight[T any, Slice ~[]T](collection Slice, n int) Slice
- func DropRightWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice
- func DropWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice
- func Duration(cb func()) time.Duration
- func Duration0(cb func()) time.Duration
- func Duration1[A any](cb func() A) (A, 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 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 EarliestBy[T any](collection []T, iteratee func(item T) time.Time) T
- func Empty[T any]() T
- func EmptyableToPtr[T any](x T) *T
- func ErrorsAs[T error](err error) (T, bool)
- func Every[T comparable](collection []T, subset []T) bool
- func EveryBy[T any](collection []T, predicate func(item T) bool) bool
- func FanIn[T any](channelBufferCap int, upstreams ...<-chan T) <-chan T
- func FanOut[T any](count int, channelsBufferCap int, upstream <-chan T) []<-chan T
- func Fill[T Clonable[T]](collection []T, initial T) []T
- func Filter[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) bool) Slice
- func FilterMap[T any, R any](collection []T, callback func(item T, index int) (R, bool)) []R
- func FilterReject[T any, Slice ~[]T](collection Slice, predicate func(T, int) bool) (kept Slice, rejected Slice)
- func Find[T any](collection []T, predicate func(item T) bool) (T, bool)
- func FindDuplicates[T comparable, Slice ~[]T](collection Slice) Slice
- func FindDuplicatesBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice
- func FindIndexOf[T any](collection []T, predicate func(item T) bool) (T, int, bool)
- func FindKey[K comparable, V comparable](object map[K]V, value V) (K, bool)
- func FindKeyBy[K comparable, V any](object map[K]V, predicate func(key K, value V) bool) (K, bool)
- func FindLastIndexOf[T any](collection []T, predicate func(item T) bool) (T, int, bool)
- func FindOrElse[T any](collection []T, fallback T, predicate func(item T) bool) T
- func FindUniques[T comparable, Slice ~[]T](collection Slice) Slice
- func FindUniquesBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice
- func First[T any](collection []T) (T, bool)
- func FirstOr[T any](collection []T, fallback T) T
- func FirstOrEmpty[T any](collection []T) T
- func FlatMap[T any, R any](collection []T, iteratee func(item T, index int) []R) []R
- func Flatten[T any, Slice ~[]T](collection []Slice) Slice
- func ForEach[T any](collection []T, iteratee func(item T, index int))
- func ForEachWhile[T any](collection []T, iteratee func(item T, index int) (goon bool))
- func FromAnySlice[T any](in []any) (out []T, ok bool)
- func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V
- func FromPairs[K comparable, V any](entries []Entry[K, V]) map[K]V
- func FromPtr[T any](x *T) T
- func FromPtrOr[T any](x *T, fallback T) T
- func FromSlicePtr[T any](collection []*T) []T
- func FromSlicePtrOr[T any](collection []*T, fallback T) []T
- func Generator[T any](bufferSize int, generator func(yield func(T))) <-chan T
- func GroupBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) map[U]Slice
- func HasKey[K comparable, V any](in map[K]V, key K) bool
- func IFilter[V any](i iter.Seq[V], f func(V) bool) iter.Seq[V]
- func IMap[V any, R any](i iter.Seq[V], f func(V) R) iter.Seq[R]
- func IReduce[V any, R any](i iter.Seq[V], f func(R, V) R, init R) R
- func If[T any](condition bool, result T) *ifElse[T]
- func IfF[T any](condition bool, resultF func() T) *ifElse[T]
- func IndexOf[T comparable](collection []T, element T) int
- func Interleave[T any, Slice ~[]T](collections ...Slice) Slice
- func Intersect[T comparable, Slice ~[]T](list1 Slice, list2 Slice) Slice
- func Invert[K comparable, V comparable](in map[K]V) map[V]K
- func IsEmpty[T comparable](v T) bool
- func IsNil(x any) bool
- func IsNotEmpty[T comparable](v T) bool
- func IsSorted[T cmp.Ordered](collection []T) bool
- func IsSortedByKey[T any, K cmp.Ordered](collection []T, iteratee func(item T) K) bool
- func KeyBy[K comparable, V any](collection []V, iteratee func(item V) K) map[K]V
- func Keys[K comparable, V any](in ...map[K]V) []K
- func Last[T any](collection []T) (T, bool)
- func LastIndexOf[T comparable](collection []T, element T) int
- func LastOr[T any](collection []T, fallback T) T
- func LastOrEmpty[T any](collection []T) T
- func Latest(times ...time.Time) time.Time
- func LatestBy[T any](collection []T, iteratee func(item T) time.Time) T
- func Map[T any, R any](collection []T, iteratee func(item T, index int) R) []R
- func MapEntries[K1 comparable, V1 any, K2 comparable, V2 any](in map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2
- func MapKeys[K comparable, V any, R comparable](in map[K]V, iteratee func(value V, key K) R) map[R]V
- func MapToSlice[K comparable, V any, R any](in map[K]V, iteratee func(key K, value V) R) []R
- func MapValues[K comparable, V any, R any](in map[K]V, iteratee func(value V, key K) R) map[K]R
- func Max[T cmp.Ordered](collection []T) T
- func MaxBy[T any](collection []T, comparison func(a T, b T) bool) T
- func Mean[T Float | Integer](collection []T) T
- func MeanBy[T any, R Float | Integer](collection []T, iteratee func(item T) R) R
- func Min[T cmp.Ordered](collection []T) T
- func MinBy[T any](collection []T, comparison func(a T, b T) bool) T
- func Must[T any](val T, err any, messageArgs ...any) T
- func Must0(err any, messageArgs ...any)
- func Must1[T any](val T, err any, messageArgs ...any) T
- func Must2[T1, T2 any](val1 T1, val2 T2, err any, messageArgs ...any) (T1, T2)
- func Must3[T1, T2, T3 any](val1 T1, val2 T2, val3 T3, err any, messageArgs ...any) (T1, T2, T3)
- func Must4[T1, T2, T3, T4 any](val1 T1, val2 T2, val3 T3, val4 T4, err any, messageArgs ...any) (T1, T2, T3, T4)
- func Must5[T1, T2, T3, T4, T5 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err any, messageArgs ...any) (T1, T2, T3, T4, T5)
- func Must6[T1, T2, T3, T4, T5, T6 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, val6 T6, err any, ...) (T1, T2, T3, T4, T5, T6)
- func NewDebounce(duration time.Duration, f ...func()) (func(), func())
- func NewDebounceBy[T comparable](duration time.Duration, f ...func(key T, count int)) (func(key T), func(key T))
- func Nil[T any]() *T
- func None[T comparable](collection []T, subset []T) bool
- func NoneBy[T any](collection []T, predicate func(item T) bool) bool
- func Nth[T any, N Integer](collection []T, nth N) (T, error)
- func OmitBy[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) bool) Map
- func OmitByKeys[K comparable, V any, Map ~map[K]V](in Map, keys []K) Map
- func OmitByValues[K comparable, V comparable, Map ~map[K]V](in Map, values []V) Map
- func Partial[T1, T2, R any](f func(a T1, b T2) R, arg1 T1) func(T2) R
- func Partial1[T1, T2, R any](f func(T1, T2) R, arg1 T1) func(T2) R
- func Partial2[T1, T2, T3, R any](f func(T1, T2, T3) R, arg1 T1) func(T2, T3) R
- func Partial3[T1, T2, T3, T4, R any](f func(T1, T2, T3, T4) R, arg1 T1) func(T2, T3, T4) R
- func Partial4[T1, T2, T3, T4, T5, R any](f func(T1, T2, T3, T4, T5) R, arg1 T1) func(T2, T3, T4, T5) R
- func Partial5[T1, T2, T3, T4, T5, T6, R any](f func(T1, T2, T3, T4, T5, T6) R, arg1 T1) func(T2, T3, T4, T5, T6) R
- func PartitionBy[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) K) []Slice
- func PickBy[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) bool) Map
- func PickByKeys[K comparable, V any, Map ~map[K]V](in Map, keys []K) Map
- func PickByValues[K comparable, V comparable, Map ~map[K]V](in Map, values []V) Map
- func Range(elementNum int) []int
- func RangeFrom[T Integer | Float](start T, elementNum int) []T
- func RangeWithSteps[T Integer | Float](start, end, step T) []T
- func Reduce[T any, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R
- func ReduceRight[T any, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R
- func Reject[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) bool) Slice
- func RejectMap[T any, R any](collection []T, callback func(item T, index int) (R, bool)) []R
- func Repeat[T Clonable[T]](count int, initial T) []T
- func RepeatBy[T any](count int, predicate func(index int) T) []T
- func Replace[T comparable, Slice ~[]T](collection Slice, old T, new T, n int) Slice
- func ReplaceAll[T comparable, Slice ~[]T](collection Slice, old T, new T) Slice
- func Reverse[T any, Slice ~[]T](collection Slice) Slice
- func Sample[T any](collection []T, gen *rand.Rand) T
- func Samples[T any, Slice ~[]T](collection Slice, count int, gen *rand.Rand) Slice
- func Shuffle[T any, Slice ~[]T](collection Slice, gen *rand.Rand) Slice
- func Slice[T any, Slice ~[]T](collection Slice, start int, end int) Slice
- func SliceToChannel[T any](bufferSize int, collection []T) <-chan T
- func Some[T comparable](collection []T, subset []T) bool
- func SomeBy[T any](collection []T, predicate func(item T) bool) bool
- func Splice[T any, Slice ~[]T](collection Slice, i int, elements ...T) Slice
- func Subset[T any, Slice ~[]T](collection Slice, offset int, length uint) Slice
- func Sum[T Float | Integer | Complex](collection []T) T
- func SumBy[T any, R Float | Integer | Complex](collection []T, iteratee func(item T) R) R
- func Switch[T comparable, R any](predicate T) *switchCase[T, R]
- func Synchronize(opt ...sync.Locker) *synchronize
- func Ternary[T any](condition bool, ifOutput T, elseOutput T) T
- func TernaryF[T any](condition bool, ifFunc func() T, elseFunc func() T) T
- func Times[T any](count int, iteratee func(index int) T) []T
- func ToAnySlice[T any](collection []T) []any
- func ToPtr[T any](x T) *T
- func ToSlicePtr[T any](collection []T) []*T
- func Try(callback func() error) (ok bool)
- func Try0(callback func()) bool
- func Try1(callback func() error) bool
- func Try2[T any](callback func() (T, error)) bool
- func Try3[T, R any](callback func() (T, R, error)) bool
- func Try4[T, R, S any](callback func() (T, R, S, error)) bool
- func Try5[T, R, S, Q any](callback func() (T, R, S, Q, error)) bool
- func Try6[T, R, S, Q, U any](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 TryOr[A any](callback func() (A, error), fallbackA A) (A, bool)
- func TryOr1[A any](callback func() (A, error), fallbackA A) (A, bool)
- func TryOr2[A, B any](callback func() (A, B, error), fallbackA A, fallbackB B) (A, B, bool)
- func TryOr3[A, B, C any](callback func() (A, B, C, error), fallbackA A, fallbackB B, fallbackC C) (A, B, C, bool)
- func TryOr4[A, B, C, D any](callback func() (A, B, C, D, error), fallbackA A, fallbackB B, fallbackC C, ...) (A, B, C, D, bool)
- func TryOr5[A, B, C, D, E any](callback func() (A, B, C, D, E, error), fallbackA A, fallbackB B, fallbackC C, ...) (A, B, C, D, E, bool)
- func TryOr6[A, B, C, D, E, F any](callback func() (A, B, C, D, E, F, error), fallbackA A, fallbackB B, ...) (A, B, C, D, E, F, bool)
- func TryWithErrorValue(callback func() error) (errorValue any, ok bool)
- func Union[T comparable, Slice ~[]T](lists ...Slice) Slice
- func Uniq[T comparable, Slice ~[]T](collection Slice) Slice
- func UniqBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice
- func UniqKeys[K comparable, V any](in ...map[K]V) []K
- func UniqValues[K comparable, V comparable](in ...map[K]V) []V
- func Unpack2[A, B any](tuple Tuple2[A, B]) (A, B)
- func Unpack3[A, B, C any](tuple Tuple3[A, B, C]) (A, B, C)
- func Unpack4[A, B, C, D any](tuple Tuple4[A, B, C, D]) (A, B, C, D)
- func Unpack5[A, B, C, D, E any](tuple Tuple5[A, B, C, D, E]) (A, B, C, D, E)
- func Unpack6[A, B, C, D, E, F any](tuple Tuple6[A, B, C, D, E, F]) (A, B, C, D, E, F)
- func Unpack7[A, B, C, D, E, F, G any](tuple Tuple7[A, B, C, D, E, F, G]) (A, B, C, D, E, F, G)
- func Unpack8[A, B, C, D, E, F, G, H any](tuple Tuple8[A, B, C, D, E, F, G, H]) (A, B, C, D, E, F, G, H)
- func Unpack9[A, B, C, D, E, F, G, H, I any](tuple Tuple9[A, B, C, D, E, F, G, H, I]) (A, B, C, D, E, F, G, H, I)
- func Unzip2[A, B any](tuples []Tuple2[A, B]) ([]A, []B)
- func Unzip3[A, B, C any](tuples []Tuple3[A, B, C]) ([]A, []B, []C)
- func Unzip4[A, B, C, D any](tuples []Tuple4[A, B, C, D]) ([]A, []B, []C, []D)
- func Unzip5[A, B, C, D, E any](tuples []Tuple5[A, B, C, D, E]) ([]A, []B, []C, []D, []E)
- func Unzip6[A, B, C, D, E, F any](tuples []Tuple6[A, B, C, D, E, F]) ([]A, []B, []C, []D, []E, []F)
- func Unzip7[A, B, C, D, E, F, G any](tuples []Tuple7[A, B, C, D, E, F, G]) ([]A, []B, []C, []D, []E, []F, []G)
- func Unzip8[A, B, C, D, E, F, G, H any](tuples []Tuple8[A, B, C, D, E, F, G, H]) ([]A, []B, []C, []D, []E, []F, []G, []H)
- func Unzip9[A, B, C, D, E, F, G, H, I any](tuples []Tuple9[A, B, C, D, E, F, G, H, I]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)
- 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 Validate(ok bool, format string, args ...any) error
- func ValueOr[K comparable, V any](in map[K]V, key K, fallback V) V
- func Values[K comparable, V any](in ...map[K]V) []V
- func WaitFor(condition func(i int) bool, timeout time.Duration, ...) (totalIterations int, elapsed time.Duration, conditionFound bool)
- func WaitForWithContext(ctx context.Context, ...) (totalIterations int, elapsed time.Duration, conditionFound bool)
- func Without[T comparable, Slice ~[]T](collection Slice, exclude ...T) Slice
- func WithoutEmpty[T comparable, Slice ~[]T](collection Slice) Slicedeprecated
- func Zip[K any, V any](ki []K, vi []V) iter.Seq2[K, V]
- 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
- type Clonable
- type Complex
- type DispatchingStrategy
- type Entry
- type Float
- type Integer
- type Signed
- type Transaction
- type Tuple2
- type Tuple3
- type Tuple4
- type Tuple5
- type Tuple6
- type Tuple7
- type Tuple8
- type Tuple9
- type Unsigned
Examples ¶
- Package (IfElse_Else)
- Package (IfElse_ElseF)
- Package (IfElse_ElseIf)
- Package (IfElse_ElseIfF)
- Package (SwitchCase_Case)
- Package (SwitchCase_CaseF)
- Package (SwitchCase_Default)
- Package (SwitchCase_DefaultF)
- Assign
- Assoc
- Attempt
- AttemptWithDelay
- Chunk
- Clamp
- Count
- CountBy
- CountValues
- CountValuesBy
- Drop
- DropByIndex
- DropRight
- DropRightWhile
- DropWhile
- Entries
- ErrorsAs
- Fill
- Filter
- FilterMap
- FlatMap
- Flatten
- ForEach
- ForEachWhile
- FromEntries
- GroupBy
- If
- IfF
- Interleave
- Invert
- IsSorted
- IsSortedByKey
- KeyBy
- Keys
- Map
- MapEntries
- MapKeys
- MapToSlice
- MapValues
- Mean
- MeanBy
- Must
- Must0
- Must1
- Must2
- Must3
- Must4
- Must5
- Must6
- NewDebounce
- NewDebounceBy
- OmitBy
- OmitByKeys
- OmitByValues
- PartitionBy
- PickBy
- PickByKeys
- PickByValues
- Range
- Reduce
- ReduceRight
- Reject
- Repeat
- RepeatBy
- Replace
- ReplaceAll
- Reverse
- Shuffle
- Slice
- Subset
- Sum
- SumBy
- Switch
- T2
- T3
- T4
- T5
- T6
- T7
- T8
- T9
- Ternary
- TernaryF
- Times
- Transaction
- Transaction (Error)
- Transaction (Ok)
- Try
- Try1
- Try2
- Try3
- Try4
- Try5
- Try6
- TryCatchWithErrorValue
- TryOr
- TryOr1
- TryOr2
- TryOr3
- TryOr4
- TryOr5
- TryOr6
- TryWithErrorValue
- Uniq
- UniqBy
- UniqKeys
- UniqValues
- Unpack2
- Unpack3
- Unpack4
- Unpack5
- Unpack6
- Unpack7
- Unpack8
- Unpack9
- Unzip2
- Unzip3
- Unzip4
- Unzip5
- Unzip6
- Unzip7
- Unzip8
- Unzip9
- Validate
- ValueOr
- Values
- Zip2
- Zip3
- Zip4
- Zip5
- Zip6
- Zip7
- Zip8
- Zip9
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Assign ¶
func Assign[K comparable, V any, Map ~map[K]V](maps ...Map) Map
Assign merges multiple maps from left to right. Play: https://go.dev/play/p/VhwfJOyxf5o
Example ¶
result := Assign(
map[string]int{"a": 1, "b": 2},
map[string]int{"b": 3, "c": 4},
)
fmt.Printf("%v %v %v %v", len(result), result["a"], result["b"], result["c"])
Output: 3 1 3 4
func Assoc ¶
func Assoc[T any, K comparable, V any](collection []T, transform func(item T, idx int) (K, V)) map[K]V
Assoc returns a map containing key-value pairs provided by transform function applied to elements of the given slice. If any of two pairs would have the same key the last one gets added to the map. The order of keys in returned map is not specified and is not guaranteed to be the same from the original array. Play: https://go.dev/play/p/WHa2CfMO3Lr
Example ¶
list := []string{"a", "aa", "aaa"}
result := Assoc(list, func(str string, _ int) (string, int) {
return str, len(str)
})
fmt.Printf("%v", result)
Output: map[a:1 aa:2 aaa:3]
func Async ¶
func Async[A any](f func() A) <-chan A
Async executes a function in a goroutine and returns the result in a channel.
func Async0 ¶
func Async0(f func()) <-chan struct{}
Async0 executes a function in a goroutine and returns a channel set once the function finishes.
func Async2 ¶
Async2 has the same behavior as Async, but returns the 2 results as a tuple inside the channel.
func Async3 ¶
Async3 has the same behavior as Async, but returns the 3 results as a tuple inside the channel.
func Async4 ¶
Async4 has the same behavior as Async, but returns the 4 results as a tuple inside the channel.
func Async5 ¶
Async5 has the same behavior as Async, but returns the 5 results as a tuple inside the channel.
func Async6 ¶
Async6 has the same behavior as Async, but returns the 6 results as a tuple inside the channel.
func Attempt ¶
Attempt invokes a function N times until it returns valid output. Returns either the caught error or nil. When the first argument is less than `1`, the function runs until a successful response is returned. Play: https://go.dev/play/p/3ggJZ2ZKcMj
Example ¶
count1, err1 := Attempt(2, func(i int) error {
if i == 0 {
return fmt.Errorf("error")
}
return nil
})
count2, err2 := Attempt(2, func(i int) error {
if i < 10 {
return fmt.Errorf("error")
}
return nil
})
fmt.Printf("%v %v\n", count1, err1)
fmt.Printf("%v %v\n", count2, err2)
Output: 2 <nil> 2 error
func AttemptWhile ¶
AttemptWhile invokes a function N times until it returns valid output. Returns either the caught error or nil, along with a bool value to determine whether the function should be invoked again. It will terminate the invoke immediately if the second return value is false. When the first argument is less than `1`, the function runs until a successful response is returned.
func AttemptWhileWithDelay ¶
func AttemptWhileWithDelay(maxIteration int, delay time.Duration, f func(int, time.Duration) (error, bool)) (int, time.Duration, error)
AttemptWhileWithDelay invokes a function N times until it returns valid output, with a pause between each call. Returns either the caught error or nil, along with a bool value to determine whether the function should be invoked again. It will terminate the invoke immediately if the second return value is false. When the first argument is less than `1`, the function runs until a successful response is returned.
func AttemptWithDelay ¶
func AttemptWithDelay(maxIteration int, delay time.Duration, f func(index int, duration time.Duration) error) (int, time.Duration, error)
AttemptWithDelay invokes a function N times until it returns valid output, with a pause between each call. Returns either the caught error or nil. When the first argument is less than `1`, the function runs until a successful response is returned. Play: https://go.dev/play/p/tVs6CygC7m1
Example ¶
count1, time1, err1 := AttemptWithDelay(2, time.Millisecond, func(i int, _ time.Duration) error {
if i == 0 {
return fmt.Errorf("error")
}
return nil
})
count2, time2, err2 := AttemptWithDelay(2, time.Millisecond, func(i int, _ time.Duration) error {
if i < 10 {
return fmt.Errorf("error")
}
return nil
})
fmt.Printf("%v %v %v\n", count1, time1.Truncate(time.Millisecond), err1)
fmt.Printf("%v %v %v\n", count2, time2.Truncate(time.Millisecond), err2)
Output: 2 1ms <nil> 2 1ms error
func BatchWithTimeout
deprecated
func Buffer ¶
func Buffer[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)
Buffer creates a slice of n elements from a channel. Returns the slice and the slice length. @TODO: we should probably provide an helper that reuse the same buffer.
func BufferWithTimeout ¶
func BufferWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool)
BufferWithTimeout creates a slice of n elements from a channel, with timeout. Returns the slice and the slice length. @TODO: we should probably provide an helper that reuse the same buffer.
func ChannelDispatcher ¶
func ChannelDispatcher[T any](stream <-chan T, count int, channelBufferCap int, strategy DispatchingStrategy[T]) []<-chan T
ChannelDispatcher distributes messages from input channels into N child channels. Close events are propagated to children. Underlying channels can have a fixed buffer capacity or be unbuffered when cap is 0.
func ChannelMerge
deprecated
func ChannelToSlice ¶
func ChannelToSlice[T any](ch <-chan T) []T
ChannelToSlice returns a slice built from channels items. Blocks until channel closes.
func Chunk ¶
Chunk returns an array of elements split into groups the length of size. If array can't be split evenly, the final chunk will be the remaining elements. Play: https://go.dev/play/p/EeKl0AuTehH
Example ¶
list := []int{0, 1, 2, 3, 4}
result := Chunk(list, 2)
for _, item := range result {
fmt.Printf("%v\n", item)
}
Output: [0 1] [2 3] [4]
func Clamp ¶
Clamp clamps number within the inclusive lower and upper bounds. Play: https://go.dev/play/p/RU4lJNC2hlI
Example ¶
result1 := Clamp(0, -10, 10)
result2 := Clamp(-42, -10, 10)
result3 := Clamp(42, -10, 10)
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
Output: 0 -10 10
func Coalesce ¶
func Coalesce[T comparable](values ...T) (result T, ok bool)
Coalesce returns the first non-empty arguments. Arguments must be comparable.
func CoalesceOrEmpty ¶
func CoalesceOrEmpty[T comparable](v ...T) T
CoalesceOrEmpty returns the first non-empty arguments. Arguments must be comparable.
func Compact ¶
func Compact[T comparable, Slice ~[]T](collection Slice) Slice
Compact returns a slice of all non-zero elements. Play: https://go.dev/play/p/tXiy-iK6PAc
func Contains ¶
func Contains[T comparable](collection []T, element T) bool
Contains returns true if an element is present in a collection.
func ContainsBy ¶
ContainsBy returns true if predicate function return true.
func Count ¶
func Count[T comparable](collection []T, value T) (count int)
Count counts the number of elements in the collection that compare equal to value. Play: https://go.dev/play/p/Y3FlK54yveC
Example ¶
list := []int{0, 1, 2, 3, 4, 5, 0, 1, 2, 3}
result := Count(list, 2)
fmt.Printf("%v", result)
Output: 2
func CountBy ¶
CountBy counts the number of elements in the collection for which predicate is true. Play: https://go.dev/play/p/ByQbNYQQi4X
Example ¶
list := []int{0, 1, 2, 3, 4, 5, 0, 1, 2, 3}
result := CountBy(list, func(i int) bool {
return i < 4
})
fmt.Printf("%v", result)
Output: 8
func CountValues ¶
func CountValues[T comparable](collection []T) map[T]int
CountValues counts the number of each element in the collection. Play: https://go.dev/play/p/-p-PyLT4dfy
Example ¶
result1 := CountValues([]int{})
result2 := CountValues([]int{1, 2})
result3 := CountValues([]int{1, 2, 2})
result4 := CountValues([]string{"foo", "bar", ""})
result5 := CountValues([]string{"foo", "bar", "bar"})
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
Output: map[] map[1:1 2:1] map[1:1 2:2] map[:1 bar:1 foo:1] map[bar:2 foo:1]
func CountValuesBy ¶
func CountValuesBy[T any, U comparable](collection []T, mapper func(item T) U) map[U]int
CountValuesBy counts the number of each element return from mapper function. Is equivalent to chaining wiz.Map and wiz.CountValues. Play: https://go.dev/play/p/2U0dG1SnOmS
Example ¶
isEven := func(v int) bool {
return v%2 == 0
}
result1 := CountValuesBy([]int{}, isEven)
result2 := CountValuesBy([]int{1, 2}, isEven)
result3 := CountValuesBy([]int{1, 2, 2}, isEven)
length := func(v string) int {
return len(v)
}
result4 := CountValuesBy([]string{"foo", "bar", ""}, length)
result5 := CountValuesBy([]string{"foo", "bar", "bar"}, length)
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
Output: map[] map[false:1 true:1] map[false:1 true:2] map[0:1 3:2] map[3:3]
func Difference ¶
func Difference[T comparable, Slice ~[]T](list1 Slice, list2 Slice) (Slice, Slice)
Difference returns the difference between two collections. The first value is the collection of element absent of list2. The second value is the collection of element absent of list1.
func DispatchingStrategyFirst ¶
DispatchingStrategyFirst distributes messages in the first non-full channel. If the capacity of the first channel is exceeded, the second channel will be selected and so on.
func DispatchingStrategyLeast ¶
DispatchingStrategyLeast distributes messages in the emptiest channel.
func DispatchingStrategyMost ¶
DispatchingStrategyMost distributes messages in the fullest channel. If the channel capacity is exceeded, the next channel will be selected and so on.
func DispatchingStrategyRandom ¶
DispatchingStrategyRandom distributes messages in a random manner. If the channel capacity is exceeded, another random channel will be selected and so on.
func DispatchingStrategyRoundRobin ¶
DispatchingStrategyRoundRobin distributes messages in a rotating sequential manner. If the channel capacity is exceeded, the next channel will be selected and so on.
func Drop ¶
Drop drops n elements from the beginning of a slice or array. Play: https://go.dev/play/p/JswS7vXRJP2
Example ¶
list := []int{0, 1, 2, 3, 4, 5}
result := Drop(list, 2)
fmt.Printf("%v", result)
Output: [2 3 4 5]
func DropByIndex ¶
DropByIndex drops elements from a slice or array by the index. A negative index will drop elements from the end of the slice. Play: https://go.dev/play/p/bPIH4npZRxS
Example ¶
list := []int{0, 1, 2, 3, 4, 5}
result := DropByIndex(list, 2)
fmt.Printf("%v", result)
Output: [0 1 3 4 5]
func DropRight ¶
DropRight drops n elements from the end of a slice or array. Play: https://go.dev/play/p/GG0nXkSJJa3
Example ¶
list := []int{0, 1, 2, 3, 4, 5}
result := DropRight(list, 2)
fmt.Printf("%v", result)
Output: [0 1 2 3]
func DropRightWhile ¶
DropRightWhile drops elements from the end of a slice or array while the predicate returns true. Play: https://go.dev/play/p/3-n71oEC0Hz
Example ¶
list := []int{0, 1, 2, 3, 4, 5}
result := DropRightWhile(list, func(val int) bool {
return val > 2
})
fmt.Printf("%v", result)
Output: [0 1 2]
func DropWhile ¶
DropWhile drops elements from the beginning of a slice or array while the predicate returns true. Play: https://go.dev/play/p/7gBPYw2IK16
Example ¶
list := []int{0, 1, 2, 3, 4, 5}
result := DropWhile(list, func(val int) bool {
return val < 2
})
fmt.Printf("%v", result)
Output: [2 3 4 5]
func Duration10 ¶
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)
Duration10 returns the time taken to execute a function.
func Duration6 ¶
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)
Duration6 returns the time taken to execute a function.
func Duration7 ¶
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)
Duration7 returns the time taken to execute a function.
func Duration8 ¶
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)
Duration8 returns the time taken to execute a function.
func Duration9 ¶
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)
Duration9 returns the time taken to execute a function.
func Earliest ¶
Earliest search the minimum time.Time of a collection. Returns zero value when the collection is empty.
func EarliestBy ¶
EarliestBy search the minimum time.Time of a collection using the given iteratee function. Returns zero value when the collection is empty.
func EmptyableToPtr ¶
func EmptyableToPtr[T any](x T) *T
EmptyableToPtr returns a pointer copy of value if it's nonzero. Otherwise, returns nil pointer.
func ErrorsAs ¶
ErrorsAs is a shortcut for errors.As(err, &&T). Play: https://go.dev/play/p/8wk5rH8UfrE
Example ¶
doSomething := func() error {
return &myError{}
}
err := doSomething()
if rateLimitErr, ok := ErrorsAs[*myError](err); ok {
fmt.Printf("is type myError, err: %s", rateLimitErr.Error())
} else {
fmt.Printf("is not type myError")
}
Output: is type myError, err: my error
func Every ¶
func Every[T comparable](collection []T, subset []T) bool
Every returns true if all elements of a subset are contained into a collection or if the subset is empty.
func EveryBy ¶
EveryBy returns true if the predicate returns true for all elements in the collection or if the collection is empty.
func FanIn ¶
FanIn collects messages from multiple input channels into a single buffered channel. Output messages has no priority. When all upstream channels reach EOF, downstream channel closes.
func FanOut ¶
FanOut broadcasts all the upstream messages to multiple downstream channels. When upstream channel reach EOF, downstream channels close. If any downstream channels is full, broadcasting is paused.
func Fill ¶
func Fill[T Clonable[T]](collection []T, initial T) []T
Fill fills elements of array with `initial` value. Play: https://go.dev/play/p/VwR34GzqEub
Example ¶
list := []foo{{"a"}, {"a"}}
result := Fill(list, foo{"b"})
fmt.Printf("%v", result)
Output: [{b} {b}]
func Filter ¶
Filter iterates over elements of collection, returning an array of all elements predicate returns truthy for. Play: https://go.dev/play/p/Apjg3WeSi7K
Example ¶
list := []int64{1, 2, 3, 4}
result := Filter(list, func(nbr int64, index int) bool {
return nbr%2 == 0
})
fmt.Printf("%v", result)
Output: [2 4]
func FilterMap ¶
FilterMap returns a slice which obtained after both filtering and mapping using the given callback function. The callback function should return two values:
- the result of the mapping operation and
- whether the result element should be included or not.
Play: https://go.dev/play/p/-AuYXfy7opz
Example ¶
list := []int64{1, 2, 3, 4}
result := FilterMap(list, func(nbr int64, index int) (string, bool) {
return strconv.FormatInt(nbr*2, 10), nbr%2 == 0
})
fmt.Printf("%v", result)
Output: [4 8]
func FilterReject ¶
func FilterReject[T any, Slice ~[]T](collection Slice, predicate func(T, int) bool) (kept Slice, rejected Slice)
FilterReject mixes Filter and Reject, this method returns two slices, one for the elements of collection that predicate returns truthy for and one for the elements that predicate does not return truthy for.
func Find ¶
Find search an element in a slice based on a predicate. It returns element and true if element was found.
func FindDuplicates ¶
func FindDuplicates[T comparable, Slice ~[]T](collection Slice) Slice
FindDuplicates returns a slice with the first occurrence of each duplicated elements of the collection. The order of result values is determined by the order they occur in the collection.
func FindDuplicatesBy ¶
func FindDuplicatesBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice
FindDuplicatesBy returns a slice with the first occurrence of each duplicated elements of the collection. The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is invoked for each element in array to generate the criterion by which uniqueness is computed.
func FindIndexOf ¶
FindIndexOf searches an element in a slice based on a predicate and returns the index and true. It returns -1 and false if the element is not found.
func FindKey ¶
func FindKey[K comparable, V comparable](object map[K]V, value V) (K, bool)
FindKey returns the key of the first value matching.
func FindKeyBy ¶
func FindKeyBy[K comparable, V any](object map[K]V, predicate func(key K, value V) bool) (K, bool)
FindKeyBy returns the key of the first element predicate returns truthy for.
func FindLastIndexOf ¶
FindLastIndexOf searches last element in a slice based on a predicate and returns the index and true. It returns -1 and false if the element is not found.
func FindOrElse ¶
FindOrElse search an element in a slice based on a predicate. It returns the element if found or a given fallback value otherwise.
func FindUniques ¶
func FindUniques[T comparable, Slice ~[]T](collection Slice) Slice
FindUniques returns a slice with all the unique elements of the collection. The order of result values is determined by the order they occur in the collection.
func FindUniquesBy ¶
func FindUniquesBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice
FindUniquesBy returns a slice with all the unique elements of the collection. The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is invoked for each element in array to generate the criterion by which uniqueness is computed.
func First ¶
First returns the first element of a collection and check for availability of the first element.
func FirstOr ¶
func FirstOr[T any](collection []T, fallback T) T
FirstOr returns the first element of a collection or the fallback value if empty.
func FirstOrEmpty ¶
func FirstOrEmpty[T any](collection []T) T
FirstOrEmpty returns the first element of a collection or zero value if empty.
func FlatMap ¶
FlatMap manipulates a slice and transforms and flattens it to a slice of another type. The transform function can either return a slice or a `nil`, and in the `nil` case no value is added to the final slice. Play: https://go.dev/play/p/YSoYmQTA8-U
Example ¶
list := []int64{1, 2, 3, 4}
result := FlatMap(list, func(nbr int64, index int) []string {
return []string{
strconv.FormatInt(nbr, 10), // base 10
strconv.FormatInt(nbr, 2), // base 2
}
})
fmt.Printf("%v", result)
Output: [1 1 2 10 3 11 4 100]
func Flatten ¶
func Flatten[T any, Slice ~[]T](collection []Slice) Slice
Flatten returns an array a single level deep. Play: https://go.dev/play/p/rbp9ORaMpjw
Example ¶
list := [][]int{{0, 1, 2}, {3, 4, 5}}
result := Flatten(list)
fmt.Printf("%v", result)
Output: [0 1 2 3 4 5]
func ForEach ¶
ForEach iterates over elements of collection and invokes iteratee for each element. Play: https://go.dev/play/p/oofyiUPRf8t
Example ¶
list := []int64{1, 2, 3, 4}
ForEach(list, func(x int64, _ int) {
fmt.Println(x)
})
Output: 1 2 3 4
func ForEachWhile ¶
ForEachWhile iterates over elements of collection and invokes iteratee for each element collection return value decide to continue or break, like do while(). Play: https://go.dev/play/p/QnLGt35tnow
Example ¶
list := []int64{1, 2, -math.MaxInt, 4}
ForEachWhile(list, func(x int64, _ int) bool {
if x < 0 {
return false
}
fmt.Println(x)
return true
})
Output: 1 2
func FromAnySlice ¶
FromAnySlice returns an `any` slice with all elements mapped to a type. Returns false in case of type conversion failure.
func FromEntries ¶
func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V
FromEntries transforms an array of key/value pairs into a map. Play: https://go.dev/play/p/oIr5KHFGCEN
Example ¶
result := FromEntries([]Entry[string, int]{
{
Key: "foo",
Value: 1,
},
{
Key: "bar",
Value: 2,
},
{
Key: "baz",
Value: 3,
},
})
fmt.Printf("%v %v %v %v", len(result), result["foo"], result["bar"], result["baz"])
Output: 3 1 2 3
func FromPairs ¶
func FromPairs[K comparable, V any](entries []Entry[K, V]) map[K]V
FromPairs transforms an array of key/value pairs into a map. Alias of FromEntries(). Play: https://go.dev/play/p/oIr5KHFGCEN
func FromPtrOr ¶
func FromPtrOr[T any](x *T, fallback T) T
FromPtrOr returns the pointer value or the fallback value.
func FromSlicePtr ¶
func FromSlicePtr[T any](collection []*T) []T
FromSlicePtr returns a slice with the pointer values. Returns a zero value in case of a nil pointer element.
func FromSlicePtrOr ¶
func FromSlicePtrOr[T any](collection []*T, fallback T) []T
FromSlicePtrOr returns a slice with the pointer values or the fallback value. Play: https://go.dev/play/p/lbunFvzlUDX
func GroupBy ¶
func GroupBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) map[U]Slice
GroupBy returns an object composed of keys generated from the results of running each element of collection through iteratee. Play: https://go.dev/play/p/XnQBd_v6brd
Example ¶
list := []int{0, 1, 2, 3, 4, 5}
result := GroupBy(list, func(i int) int {
return i % 3
})
fmt.Printf("%v\n", result[0])
fmt.Printf("%v\n", result[1])
fmt.Printf("%v\n", result[2])
Output: [0 3] [1 4] [2 5]
func HasKey ¶
func HasKey[K comparable, V any](in map[K]V, key K) bool
HasKey returns whether the given key exists. Play: https://go.dev/play/p/aVwubIvECqS
func If ¶
If. Play: https://go.dev/play/p/WSw3ApMxhyW
Example ¶
result1 := If(true, 1).
ElseIf(false, 2).
Else(3)
result2 := If(false, 1).
ElseIf(true, 2).
Else(3)
result3 := If(false, 1).
ElseIf(false, 2).
Else(3)
result4 := IfF(true, func() int { return 1 }).
ElseIfF(false, func() int { return 2 }).
ElseF(func() int { return 3 })
result5 := IfF(false, func() int { return 1 }).
ElseIfF(true, func() int { return 2 }).
ElseF(func() int { return 3 })
result6 := IfF(false, func() int { return 1 }).
ElseIfF(false, func() int { return 2 }).
ElseF(func() int { return 3 })
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
fmt.Printf("%v\n", result6)
Output: 1 2 3 1 2 3
func IfF ¶
IfF. Play: https://go.dev/play/p/WSw3ApMxhyW
Example ¶
result1 := If(true, 1).
ElseIf(false, 2).
Else(3)
result2 := If(false, 1).
ElseIf(true, 2).
Else(3)
result3 := If(false, 1).
ElseIf(false, 2).
Else(3)
result4 := IfF(true, func() int { return 1 }).
ElseIfF(false, func() int { return 2 }).
ElseF(func() int { return 3 })
result5 := IfF(false, func() int { return 1 }).
ElseIfF(true, func() int { return 2 }).
ElseF(func() int { return 3 })
result6 := IfF(false, func() int { return 1 }).
ElseIfF(false, func() int { return 2 }).
ElseF(func() int { return 3 })
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
fmt.Printf("%v\n", result6)
Output: 1 2 3 1 2 3
func IndexOf ¶
func IndexOf[T comparable](collection []T, element T) int
IndexOf returns the index at which the first occurrence of a value is found in an array or return -1 if the value cannot be found.
func Interleave ¶
func Interleave[T any, Slice ~[]T](collections ...Slice) Slice
Interleave round-robin alternating input slices and sequentially appending value at index into result Play: https://go.dev/play/p/-RJkTLQEDVt
Example ¶
list1 := [][]int{{1, 4, 7}, {2, 5, 8}, {3, 6, 9}}
list2 := [][]int{{1}, {2, 5, 8}, {3, 6}, {4, 7, 9, 10}}
result1 := Interleave(list1...)
result2 := Interleave(list2...)
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
Output: [1 2 3 4 5 6 7 8 9] [1 2 3 4 5 6 7 8 9 10]
func Intersect ¶
func Intersect[T comparable, Slice ~[]T](list1 Slice, list2 Slice) Slice
Intersect returns the intersection between two collections.
func Invert ¶
func Invert[K comparable, V comparable](in map[K]V) map[V]K
Invert creates a map composed of the inverted keys and values. If map contains duplicate values, subsequent values overwrite property assignments of previous values. Play: https://go.dev/play/p/rFQ4rak6iA1
Example ¶
kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}
result := Invert(kv)
fmt.Printf("%v %v %v %v", len(result), result[1], result[2], result[3])
Output: 3 foo bar baz
func IsEmpty ¶
func IsEmpty[T comparable](v T) bool
IsEmpty returns true if argument is a zero value.
func IsNil ¶
IsNil checks if a value is nil or if it's a reference type with a nil underlying value.
func IsNotEmpty ¶
func IsNotEmpty[T comparable](v T) bool
IsNotEmpty returns true if argument is not a zero value.
func IsSorted ¶
IsSorted checks if a slice is sorted. Play: https://go.dev/play/p/mc3qR-t4mcx
Example ¶
list := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
result := IsSorted(list)
fmt.Printf("%v", result)
Output: true
func IsSortedByKey ¶
IsSortedByKey checks if a slice is sorted by iteratee. Play: https://go.dev/play/p/wiG6XyBBu49
Example ¶
list := []string{"a", "bb", "ccc"}
result := IsSortedByKey(list, func(s string) int {
return len(s)
})
fmt.Printf("%v", result)
Output: true
func KeyBy ¶
func KeyBy[K comparable, V any](collection []V, iteratee func(item V) K) map[K]V
KeyBy transforms a slice or an array of structs to a map based on a pivot callback. Play: https://go.dev/play/p/mdaClUAT-zZ
Example ¶
list := []string{"a", "aa", "aaa"}
result := KeyBy(list, func(str string) int {
return len(str)
})
fmt.Printf("%v", result)
Output: map[1:a 2:aa 3:aaa]
func Keys ¶
func Keys[K comparable, V any](in ...map[K]V) []K
Keys creates an array of the map keys. Play: https://go.dev/play/p/Uu11fHASqrU
Example ¶
kv := map[string]int{"foo": 1, "bar": 2}
kv2 := map[string]int{"baz": 3}
result := Keys(kv, kv2)
sort.Strings(result)
fmt.Printf("%v", result)
Output: [bar baz foo]
func LastIndexOf ¶
func LastIndexOf[T comparable](collection []T, element T) int
LastIndexOf returns the index at which the last occurrence of a value is found in an array or return -1 if the value cannot be found.
func LastOr ¶
func LastOr[T any](collection []T, fallback T) T
LastOr returns the last element of a collection or the fallback value if empty.
func LastOrEmpty ¶
func LastOrEmpty[T any](collection []T) T
LastOrEmpty returns the last element of a collection or zero value if empty.
func Latest ¶
Latest search the maximum time.Time of a collection. Returns zero value when the collection is empty.
func LatestBy ¶
LatestBy search the maximum time.Time of a collection using the given iteratee function. Returns zero value when the collection is empty.
func Map ¶
Map manipulates a slice and transforms it to a slice of another type. Play: https://go.dev/play/p/OkPcYAhBo0D
Example ¶
list := []int64{1, 2, 3, 4}
result := Map(list, func(nbr int64, index int) string {
return strconv.FormatInt(nbr*2, 10)
})
fmt.Printf("%v", result)
Output: [2 4 6 8]
func MapEntries ¶
func MapEntries[K1 comparable, V1 any, K2 comparable, V2 any](in map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2
MapEntries manipulates a map entries and transforms it to a map of another type. Play: https://go.dev/play/p/VuvNQzxKimT
Example ¶
kv := map[string]int{"foo": 1, "bar": 2}
result := MapEntries(kv, func(k string, v int) (int, string) {
return v, k
})
fmt.Printf("%v\n", result)
Output: map[1:foo 2:bar]
func MapKeys ¶
func MapKeys[K comparable, V any, R comparable](in map[K]V, iteratee func(value V, key K) R) map[R]V
MapKeys manipulates a map keys and transforms it to a map of another type. Play: https://go.dev/play/p/9_4WPIqOetJ
Example ¶
kv := map[int]int{1: 1, 2: 2, 3: 3, 4: 4}
result := MapKeys(kv, func(_ int, k int) string {
return strconv.FormatInt(int64(k), 10)
})
fmt.Printf("%v %v %v %v %v", len(result), result["1"], result["2"], result["3"], result["4"])
Output: 4 1 2 3 4
func MapToSlice ¶
func MapToSlice[K comparable, V any, R any](in map[K]V, iteratee func(key K, value V) R) []R
MapToSlice transforms a map into a slice based on specific iteratee Play: https://go.dev/play/p/ZuiCZpDt6LD
Example ¶
kv := map[int]int64{1: 1, 2: 2, 3: 3, 4: 4}
result := MapToSlice(kv, func(k int, v int64) string {
return fmt.Sprintf("%d_%d", k, v)
})
sort.StringSlice(result).Sort()
fmt.Printf("%v", result)
Output: [1_1 2_2 3_3 4_4]
func MapValues ¶
func MapValues[K comparable, V any, R any](in map[K]V, iteratee func(value V, key K) R) map[K]R
MapValues manipulates a map values and transforms it to a map of another type. Play: https://go.dev/play/p/T_8xAfvcf0W
Example ¶
kv := map[int]int{1: 1, 2: 2, 3: 3, 4: 4}
result := MapValues(kv, func(v int, _ int) string {
return strconv.FormatInt(int64(v), 10)
})
fmt.Printf("%v %q %q %q %q", len(result), result[1], result[2], result[3], result[4])
Output: 4 "1" "2" "3" "4"
func Max ¶
Max searches the maximum value of a collection. Returns zero value when the collection is empty.
func MaxBy ¶
MaxBy search the maximum value of a collection using the given comparison function. If several values of the collection are equal to the greatest value, returns the first such value. Returns zero value when the collection is empty.
func Mean ¶
Mean calculates the mean of a collection of numbers.
Example ¶
list := []int{1, 2, 3, 4, 5}
result := Mean(list)
fmt.Printf("%v", result)
Output:
func MeanBy ¶
MeanBy calculates the mean of a collection of numbers using the given return value from the iteration function.
Example ¶
list := []string{"foo", "bar"}
result := MeanBy(list, func(item string) int {
return len(item)
})
fmt.Printf("%v", result)
Output:
func Min ¶
Min search the minimum value of a collection. Returns zero value when the collection is empty.
func MinBy ¶
MinBy search the minimum value of a collection using the given comparison function. If several values of the collection are equal to the smallest value, returns the first such value. Returns zero value when the collection is empty.
func Must ¶
Must is a helper that wraps a call to a function returning a value and an error and panics if err is error or false. Play: https://go.dev/play/p/TMoWrRp3DyC
Example ¶
defer func() {
_ = recover()
}()
// won't panic
Must(42, nil)
// won't panic
cb := func() (int, error) {
return 42, nil
}
Must(cb())
// will panic
Must(42, fmt.Errorf("my error"))
// will panic with error message
Must(42, fmt.Errorf("world"), "hello")
Output:
func Must0 ¶
Must0 has the same behavior as Must, but callback returns no variable. Play: https://go.dev/play/p/TMoWrRp3DyC
Example ¶
defer func() {
_ = recover()
}()
// won't panic
Must0(nil)
// will panic
Must0(fmt.Errorf("my error"))
// will panic with error message
Must0(fmt.Errorf("world"), "hello")
Output:
func Must1 ¶
Must1 is an alias to Must Play: https://go.dev/play/p/TMoWrRp3DyC
Example ¶
defer func() {
_ = recover()
}()
// won't panic
Must1(42, nil)
// won't panic
cb := func() (int, error) {
return 42, nil
}
Must1(cb())
// will panic
Must1(42, fmt.Errorf("my error"))
// will panic with error message
Must1(42, fmt.Errorf("world"), "hello")
Output:
func Must2 ¶
Must2 has the same behavior as Must, but callback returns 2 variables. Play: https://go.dev/play/p/TMoWrRp3DyC
Example ¶
defer func() {
_ = recover()
}()
// won't panic
Must2(42, "hello", nil)
// will panic
Must2(42, "hello", fmt.Errorf("my error"))
// will panic with error message
Must2(42, "hello", fmt.Errorf("world"), "hello")
Output:
func Must3 ¶
Must3 has the same behavior as Must, but callback returns 3 variables. Play: https://go.dev/play/p/TMoWrRp3DyC
Example ¶
defer func() {
_ = recover()
}()
// won't panic
Must3(42, "hello", 4.2, nil)
// will panic
Must3(42, "hello", 4.2, fmt.Errorf("my error"))
// will panic with error message
Must3(42, "hello", 4.2, fmt.Errorf("world"), "hello")
Output:
func Must4 ¶
func Must4[T1, T2, T3, T4 any](val1 T1, val2 T2, val3 T3, val4 T4, err any, messageArgs ...any) (T1, T2, T3, T4)
Must4 has the same behavior as Must, but callback returns 4 variables. Play: https://go.dev/play/p/TMoWrRp3DyC
Example ¶
defer func() {
_ = recover()
}()
// won't panic
Must4(42, "hello", 4.2, true, nil)
// will panic
Must4(42, "hello", 4.2, true, fmt.Errorf("my error"))
// will panic with error message
Must4(42, "hello", 4.2, true, fmt.Errorf("world"), "hello")
Output:
func Must5 ¶
func Must5[T1, T2, T3, T4, T5 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err any, messageArgs ...any) (T1, T2, T3, T4, T5)
Must5 has the same behavior as Must, but callback returns 5 variables. Play: https://go.dev/play/p/TMoWrRp3DyC
Example ¶
defer func() {
_ = recover()
}()
// won't panic
Must5(42, "hello", 4.2, true, foo{}, nil)
// will panic
Must5(42, "hello", 4.2, true, foo{}, fmt.Errorf("my error"))
// will panic with error message
Must5(42, "hello", 4.2, true, foo{}, fmt.Errorf("world"), "hello")
Output:
func Must6 ¶
func Must6[T1, T2, T3, T4, T5, T6 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, val6 T6, err any, messageArgs ...any) (T1, T2, T3, T4, T5, T6)
Must6 has the same behavior as Must, but callback returns 6 variables. Play: https://go.dev/play/p/TMoWrRp3DyC
Example ¶
defer func() {
_ = recover()
}()
// won't panic
Must5(42, "hello", 4.2, true, foo{}, "foobar", nil)
// will panic
Must5(42, "hello", 4.2, true, foo{}, "foobar", fmt.Errorf("my error"))
// will panic with error message
Must5(42, "hello", 4.2, true, foo{}, "foobar", fmt.Errorf("world"), "hello")
Output:
func NewDebounce ¶
NewDebounce creates a debounced instance that delays invoking functions given until after wait milliseconds have elapsed. Play: https://go.dev/play/p/mz32VMK2nqe
Example ¶
i := int32(0)
calls := []int32{}
mu := sync.Mutex{}
debounce, cancel := NewDebounce(time.Millisecond, func() {
mu.Lock()
defer mu.Unlock()
calls = append(calls, atomic.LoadInt32(&i))
})
debounce()
atomic.AddInt32(&i, 1)
time.Sleep(5 * time.Millisecond)
debounce()
atomic.AddInt32(&i, 1)
debounce()
atomic.AddInt32(&i, 1)
debounce()
atomic.AddInt32(&i, 1)
time.Sleep(5 * time.Millisecond)
cancel()
mu.Lock()
fmt.Printf("%v", calls)
mu.Unlock()
Output: [1 4]
func NewDebounceBy ¶
func NewDebounceBy[T comparable](duration time.Duration, f ...func(key T, count int)) (func(key T), func(key T))
NewDebounceBy creates a debounced instance for each distinct key, that delays invoking functions given until after wait milliseconds have elapsed. Play: https://go.dev/play/p/d3Vpt6pxhY8
Example ¶
calls := map[string][]int{}
mu := sync.Mutex{}
debounce, cancel := NewDebounceBy(time.Millisecond, func(userID string, count int) {
mu.Lock()
defer mu.Unlock()
if _, ok := calls[userID]; !ok {
calls[userID] = []int{}
}
calls[userID] = append(calls[userID], count)
})
debounce("samuel")
debounce("john")
time.Sleep(5 * time.Millisecond)
debounce("john")
debounce("john")
debounce("samuel")
debounce("john")
time.Sleep(5 * time.Millisecond)
cancel("samuel")
cancel("john")
mu.Lock()
fmt.Printf("samuel: %v\n", calls["samuel"])
fmt.Printf("john: %v\n", calls["john"])
mu.Unlock()
Output: samuel: [1 1] john: [1 3]
func None ¶
func None[T comparable](collection []T, subset []T) bool
None returns true if no element of a subset are contained into a collection or if the subset is empty.
func NoneBy ¶
NoneBy returns true if the predicate returns true for none of the elements in the collection or if the collection is empty.
func Nth ¶
Nth returns the element at index `nth` of collection. If `nth` is negative, the nth element from the end is returned. An error is returned when nth is out of slice bounds.
func OmitBy ¶
func OmitBy[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) bool) Map
OmitBy returns same map type filtered by given predicate. Play: https://go.dev/play/p/EtBsR43bdsd
Example ¶
kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}
result := OmitBy(kv, func(key string, value int) bool {
return value%2 == 1
})
fmt.Printf("%v", result)
Output: map[bar:2]
func OmitByKeys ¶
func OmitByKeys[K comparable, V any, Map ~map[K]V](in Map, keys []K) Map
OmitByKeys returns same map type filtered by given keys. Play: https://go.dev/play/p/t1QjCrs-ysk
Example ¶
kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}
result := OmitByKeys(kv, []string{"foo", "baz"})
fmt.Printf("%v", result)
Output: map[bar:2]
func OmitByValues ¶
func OmitByValues[K comparable, V comparable, Map ~map[K]V](in Map, values []V) Map
OmitByValues returns same map type filtered by given values. Play: https://go.dev/play/p/9UYZi-hrs8j
Example ¶
kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}
result := OmitByValues(kv, []int{1, 3})
fmt.Printf("%v", result)
Output: map[bar:2]
func Partial ¶
func Partial[T1, T2, R any](f func(a T1, b T2) R, arg1 T1) func(T2) R
Partial returns new function that, when called, has its first argument set to the provided value.
func Partial1 ¶
func Partial1[T1, T2, R any](f func(T1, T2) R, arg1 T1) func(T2) R
Partial1 returns new function that, when called, has its first argument set to the provided value.
func Partial2 ¶
func Partial2[T1, T2, T3, R any](f func(T1, T2, T3) R, arg1 T1) func(T2, T3) R
Partial2 returns new function that, when called, has its first argument set to the provided value.
func Partial3 ¶
func Partial3[T1, T2, T3, T4, R any](f func(T1, T2, T3, T4) R, arg1 T1) func(T2, T3, T4) R
Partial3 returns new function that, when called, has its first argument set to the provided value.
func Partial4 ¶
func Partial4[T1, T2, T3, T4, T5, R any](f func(T1, T2, T3, T4, T5) R, arg1 T1) func(T2, T3, T4, T5) R
Partial4 returns new function that, when called, has its first argument set to the provided value.
func Partial5 ¶
func Partial5[T1, T2, T3, T4, T5, T6, R any](f func(T1, T2, T3, T4, T5, T6) R, arg1 T1) func(T2, T3, T4, T5, T6) R
Partial5 returns new function that, when called, has its first argument set to the provided value
func PartitionBy ¶
func PartitionBy[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) K) []Slice
PartitionBy returns an array of elements split into groups. The order of grouped values is determined by the order they occur in collection. The grouping is generated from the results of running each element of collection through iteratee. Play: https://go.dev/play/p/NfQ_nGjkgXW
Example ¶
list := []int{-2, -1, 0, 1, 2, 3, 4}
result := PartitionBy(list, func(x int) string {
if x < 0 {
return "negative"
} else if x%2 == 0 {
return "even"
}
return "odd"
})
for _, item := range result {
fmt.Printf("%v\n", item)
}
Output: [-2 -1] [0 2 4] [1 3]
func PickBy ¶
func PickBy[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) bool) Map
PickBy returns same map type filtered by given predicate. Play: https://go.dev/play/p/kdg8GR_QMmf
Example ¶
kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}
result := PickBy(kv, func(key string, value int) bool {
return value%2 == 1
})
fmt.Printf("%v %v %v", len(result), result["foo"], result["baz"])
Output: 2 1 3
func PickByKeys ¶
func PickByKeys[K comparable, V any, Map ~map[K]V](in Map, keys []K) Map
PickByKeys returns same map type filtered by given keys. Play: https://go.dev/play/p/R1imbuci9qU
Example ¶
kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}
result := PickByKeys(kv, []string{"foo", "baz"})
fmt.Printf("%v %v %v", len(result), result["foo"], result["baz"])
Output: 2 1 3
func PickByValues ¶
func PickByValues[K comparable, V comparable, Map ~map[K]V](in Map, values []V) Map
PickByValues returns same map type filtered by given values. Play: https://go.dev/play/p/1zdzSvbfsJc
Example ¶
kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}
result := PickByValues(kv, []int{1, 3})
fmt.Printf("%v %v %v", len(result), result["foo"], result["baz"])
Output: 2 1 3
func Range ¶
Range creates an array of numbers (positive and/or negative) with given length. Play: https://go.dev/play/p/0r6VimXAi9H
Example ¶
result1 := Range(4)
result2 := Range(-4)
result3 := RangeFrom(1, 5)
result4 := RangeFrom(1.0, 5)
result5 := RangeWithSteps(0, 20, 5)
result6 := RangeWithSteps[float32](-1.0, -4.0, -1.0)
result7 := RangeWithSteps(1, 4, -1)
result8 := Range(0)
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
fmt.Printf("%v\n", result6)
fmt.Printf("%v\n", result7)
fmt.Printf("%v\n", result8)
Output: [0 1 2 3] [0 -1 -2 -3] [1 2 3 4 5] [1 2 3 4 5] [0 5 10 15] [-1 -2 -3] [] []
func RangeFrom ¶
RangeFrom creates an array of numbers from start with specified length. Play: https://go.dev/play/p/0r6VimXAi9H
func RangeWithSteps ¶
RangeWithSteps creates an array of numbers (positive and/or negative) progressing from start up to, but not including end. step set to zero will return empty array. Play: https://go.dev/play/p/0r6VimXAi9H
func Reduce ¶
func Reduce[T any, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R
Reduce reduces collection to a value which is the accumulated result of running each element in collection through accumulator, where each successive invocation is supplied the return value of the previous. Play: https://go.dev/play/p/R4UHXZNaaUG
Example ¶
list := []int64{1, 2, 3, 4}
result := Reduce(list, func(agg int64, item int64, index int) int64 {
return agg + item
}, 0)
fmt.Printf("%v", result)
Output: 10
func ReduceRight ¶
func ReduceRight[T any, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R
ReduceRight helper is like Reduce except that it iterates over elements of collection from right to left. Play: https://go.dev/play/p/Fq3W70l7wXF
Example ¶
list := [][]int{{0, 1}, {2, 3}, {4, 5}}
result := ReduceRight(list, func(agg []int, item []int, index int) []int {
return append(agg, item...)
}, []int{})
fmt.Printf("%v", result)
Output: [4 5 2 3 0 1]
func Reject ¶
Reject is the opposite of Filter, this method returns the elements of collection that predicate does not return truthy for. Play: https://go.dev/play/p/YkLMODy1WEL
Example ¶
list := []int{0, 1, 2, 3, 4, 5}
result := Reject(list, func(x int, _ int) bool {
return x%2 == 0
})
fmt.Printf("%v", result)
Output: [1 3 5]
func RejectMap ¶
RejectMap is the opposite of FilterMap, this method returns a slice which obtained after both filtering and mapping using the given callback function. The callback function should return two values:
- the result of the mapping operation and
- whether the result element should be included or not.
func Repeat ¶
Repeat builds a slice with N copies of initial value. Play: https://go.dev/play/p/g3uHXbmc3b6
Example ¶
result := Repeat(2, foo{"a"})
fmt.Printf("%v", result)
Output: [{a} {a}]
func RepeatBy ¶
RepeatBy builds a slice with values returned by N calls of callback. Play: https://go.dev/play/p/ozZLCtX_hNU
Example ¶
result := RepeatBy(5, func(i int) string {
return strconv.FormatInt(int64(math.Pow(float64(i), 2)), 10)
})
fmt.Printf("%v", result)
Output: [0 1 4 9 16]
func Replace ¶
func Replace[T comparable, Slice ~[]T](collection Slice, old T, new T, n int) Slice
Replace returns a copy of the slice with the first n non-overlapping instances of old replaced by new. Play: https://go.dev/play/p/XfPzmf9gql6
Example ¶
list := []int{0, 1, 0, 1, 2, 3, 0}
result := Replace(list, 0, 42, 1)
fmt.Printf("%v\n", result)
result = Replace(list, -1, 42, 1)
fmt.Printf("%v\n", result)
result = Replace(list, 0, 42, 2)
fmt.Printf("%v\n", result)
result = Replace(list, 0, 42, -1)
fmt.Printf("%v\n", result)
Output: [42 1 0 1 2 3 0] [0 1 0 1 2 3 0] [42 1 42 1 2 3 0] [42 1 42 1 2 3 42]
func ReplaceAll ¶
func ReplaceAll[T comparable, Slice ~[]T](collection Slice, old T, new T) Slice
ReplaceAll returns a copy of the slice with all non-overlapping instances of old replaced by new. Play: https://go.dev/play/p/a9xZFUHfYcV
Example ¶
list := []string{"", "foo", "", "bar", ""}
result := Compact(list)
fmt.Printf("%v", result)
Output: [foo bar]
func Reverse ¶
func Reverse[T any, Slice ~[]T](collection Slice) Slice
Reverse reverses array so that the first element becomes the last, the second element becomes the second to last, and so on. Play: https://go.dev/play/p/fhUMLvZ7vS6
Example ¶
list := []int{0, 1, 2, 3, 4, 5}
result := Reverse(list)
fmt.Printf("%v", result)
Output: [5 4 3 2 1 0]
func Shuffle ¶
Shuffle returns an array of shuffled values. Uses the Fisher-Yates shuffle algorithm. Play: https://go.dev/play/p/Qp73bnTDnc7
Example ¶
list := []int{0, 1, 2, 3, 4, 5}
gen := rand.New(rand.NewSource(time.Now().UnixNano()))
result := Shuffle(list, gen)
fmt.Printf("%v", result)
Output:
func Slice ¶
Slice returns a copy of a slice from `start` up to, but not including `end`. Like `slice[start:end]`, but does not panic on overflow. Play: https://go.dev/play/p/8XWYhfMMA1h
Example ¶
list := []int{0, 1, 2, 3, 4, 5}
result := Slice(list, 1, 4)
fmt.Printf("%v\n", result)
result = Slice(list, 4, 1)
fmt.Printf("%v\n", result)
result = Slice(list, 4, 5)
fmt.Printf("%v\n", result)
Output: [1 2 3] [] [4]
func SliceToChannel ¶
SliceToChannel returns a read-only channels of collection elements.
func Some ¶
func Some[T comparable](collection []T, subset []T) bool
Some returns true if at least 1 element of a subset is contained into a collection. If the subset is empty Some returns false.
func SomeBy ¶
SomeBy returns true if the predicate returns true for any of the elements in the collection. If the collection is empty SomeBy returns false.
func Splice ¶
Splice inserts multiple elements at index i. A negative index counts back from the end of the slice. The helper is protected against overflow errors. Play: https://go.dev/play/p/G5_GhkeSUBA
func Subset ¶
Subset returns a copy of a slice from `offset` up to `length` elements. Like `slice[start:start+length]`, but does not panic on overflow. Play: https://go.dev/play/p/tOQu1GhFcog
Example ¶
list := []int{0, 1, 2, 3, 4, 5}
result := Subset(list, 2, 3)
fmt.Printf("%v", result)
Output: [2 3 4]
func Sum ¶
Sum sums the values in a collection. If collection is empty 0 is returned. Play: https://go.dev/play/p/upfeJVqs4Bt
Example ¶
list := []int{1, 2, 3, 4, 5}
sum := Sum(list)
fmt.Printf("%v", sum)
Output: 15
func SumBy ¶
SumBy summarizes the values in a collection using the given return value from the iteration function. If collection is empty 0 is returned. Play: https://go.dev/play/p/Dz_a_7jN_ca
Example ¶
list := []string{"foo", "bar"}
result := SumBy(list, func(item string) int {
return len(item)
})
fmt.Printf("%v", result)
Output: 6
func Switch ¶
func Switch[T comparable, R any](predicate T) *switchCase[T, R]
Switch is a pure functional switch/case/default statement. Play: https://go.dev/play/p/TGbKUMAeRUd
Example ¶
result1 := Switch[int, string](1).
Case(1, "1").
Case(2, "2").
Default("3")
result2 := Switch[int, string](2).
Case(1, "1").
Case(2, "2").
Default("3")
result3 := Switch[int, string](42).
Case(1, "1").
Case(2, "2").
Default("3")
result4 := Switch[int, string](1).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
result5 := Switch[int, string](2).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
result6 := Switch[int, string](42).
CaseF(1, func() string { return "1" }).
CaseF(2, func() string { return "2" }).
DefaultF(func() string { return "3" })
fmt.Printf("%v\n", result1)
fmt.Printf("%v\n", result2)
fmt.Printf("%v\n", result3)
fmt.Printf("%v\n", result4)
fmt.Printf("%v\n", result5)
fmt.Printf("%v\n", result6)
Output: 1 2 3 1 2 3
func Synchronize ¶
Synchronize wraps the underlying callback in a mutex. It receives an optional mutex.
func Ternary ¶
Ternary is a 1 line if/else statement. Play: https://go.dev/play/p/t-D7WBL44h2
Example ¶
result := Ternary(true, "a", "b")
fmt.Printf("%v", result)
Output: a
func TernaryF ¶
TernaryF is a 1 line if/else statement whose options are functions Play: https://go.dev/play/p/AO4VW20JoqM
Example ¶
result := TernaryF(true, func() string { return "a" }, func() string { return "b" })
fmt.Printf("%v", result)
Output: a
func Times ¶
Times invokes the iteratee n times, returning an array of the results of each invocation. The iteratee is invoked with index as argument. Play: https://go.dev/play/p/vgQj3Glr6lT
Example ¶
result := Times(3, func(i int) string {
return strconv.FormatInt(int64(i), 10)
})
fmt.Printf("%v", result)
Output: [0 1 2]
func ToAnySlice ¶
ToAnySlice returns a slice with all elements mapped to `any` type
func ToSlicePtr ¶
func ToSlicePtr[T any](collection []T) []*T
ToSlicePtr returns a slice of pointer copy of value.
func Try ¶
Try calls the function and return false in case of error.
Example ¶
ok1 := Try(func() error {
return nil
})
ok2 := Try(func() error {
return fmt.Errorf("my error")
})
ok3 := Try(func() error {
panic("my error")
})
fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)
Output: true false false
func Try0 ¶
func Try0(callback func()) bool
Try0 has the same behavior as Try, but callback returns no variable. Play: https://go.dev/play/p/mTyyWUvn9u4
func Try1 ¶
Try1 is an alias to Try. Play: https://go.dev/play/p/mTyyWUvn9u4
Example ¶
ok1 := Try1(func() error {
return nil
})
ok2 := Try1(func() error {
return fmt.Errorf("my error")
})
ok3 := Try1(func() error {
panic("my error")
})
fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)
Output: true false false
func Try2 ¶
Try2 has the same behavior as Try, but callback returns 2 variables. Play: https://go.dev/play/p/mTyyWUvn9u4
Example ¶
ok1 := Try2(func() (int, error) {
return 42, nil
})
ok2 := Try2(func() (int, error) {
return 42, fmt.Errorf("my error")
})
ok3 := Try2(func() (int, error) {
panic("my error")
})
fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)
Output: true false false
func Try3 ¶
Try3 has the same behavior as Try, but callback returns 3 variables. Play: https://go.dev/play/p/mTyyWUvn9u4
Example ¶
ok1 := Try3(func() (int, string, error) {
return 42, "foobar", nil
})
ok2 := Try3(func() (int, string, error) {
return 42, "foobar", fmt.Errorf("my error")
})
ok3 := Try3(func() (int, string, error) {
panic("my error")
})
fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)
Output: true false false
func Try4 ¶
Try4 has the same behavior as Try, but callback returns 4 variables. Play: https://go.dev/play/p/mTyyWUvn9u4
Example ¶
ok1 := Try4(func() (int, string, float64, error) {
return 42, "foobar", 4.2, nil
})
ok2 := Try4(func() (int, string, float64, error) {
return 42, "foobar", 4.2, fmt.Errorf("my error")
})
ok3 := Try4(func() (int, string, float64, error) {
panic("my error")
})
fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)
Output: true false false
func Try5 ¶
Try5 has the same behavior as Try, but callback returns 5 variables. Play: https://go.dev/play/p/mTyyWUvn9u4
Example ¶
ok1 := Try5(func() (int, string, float64, bool, error) {
return 42, "foobar", 4.2, true, nil
})
ok2 := Try5(func() (int, string, float64, bool, error) {
return 42, "foobar", 4.2, true, fmt.Errorf("my error")
})
ok3 := Try5(func() (int, string, float64, bool, error) {
panic("my error")
})
fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)
Output: true false false
func Try6 ¶
Try6 has the same behavior as Try, but callback returns 6 variables. Play: https://go.dev/play/p/mTyyWUvn9u4
Example ¶
ok1 := Try6(func() (int, string, float64, bool, foo, error) {
return 42, "foobar", 4.2, true, foo{}, nil
})
ok2 := Try6(func() (int, string, float64, bool, foo, error) {
return 42, "foobar", 4.2, true, foo{}, fmt.Errorf("my error")
})
ok3 := Try6(func() (int, string, float64, bool, foo, error) {
panic("my error")
})
fmt.Printf("%v\n", ok1)
fmt.Printf("%v\n", ok2)
fmt.Printf("%v\n", ok3)
Output: true false false
func TryCatch ¶
func TryCatch(callback func() error, catch func())
TryCatch has the same behavior as Try, but calls the catch function in case of error. Play: https://go.dev/play/p/PnOON-EqBiU
func TryCatchWithErrorValue ¶
TryCatchWithErrorValue has the same behavior as TryWithErrorValue, but calls the catch function in case of error. Play: https://go.dev/play/p/8Pc9gwX_GZO
Example ¶
TryCatchWithErrorValue(
func() error {
panic("trigger an error")
},
func(err any) {
fmt.Printf("catch: %s", err)
},
)
Output: catch: trigger an error
func TryOr ¶
TryOr has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X
Example ¶
value1, ok1 := TryOr(func() (int, error) {
return 42, nil
}, 21)
value2, ok2 := TryOr(func() (int, error) {
return 42, fmt.Errorf("my error")
}, 21)
value3, ok3 := TryOr(func() (int, error) {
panic("my error")
}, 21)
fmt.Printf("%v %v\n", value1, ok1)
fmt.Printf("%v %v\n", value2, ok2)
fmt.Printf("%v %v\n", value3, ok3)
Output: 42 true 21 false 21 false
func TryOr1 ¶
TryOr1 has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X
Example ¶
value1, ok1 := TryOr1(func() (int, error) {
return 42, nil
}, 21)
value2, ok2 := TryOr1(func() (int, error) {
return 42, fmt.Errorf("my error")
}, 21)
value3, ok3 := TryOr1(func() (int, error) {
panic("my error")
}, 21)
fmt.Printf("%v %v\n", value1, ok1)
fmt.Printf("%v %v\n", value2, ok2)
fmt.Printf("%v %v\n", value3, ok3)
Output: 42 true 21 false 21 false
func TryOr2 ¶
TryOr2 has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X
Example ¶
value1, value2, ok3 := TryOr2(func() (int, string, error) {
panic("my error")
}, 21, "hello")
fmt.Printf("%v %v %v\n", value1, value2, ok3)
Output: 21 hello false
func TryOr3 ¶
func TryOr3[A, B, C any](callback func() (A, B, C, error), fallbackA A, fallbackB B, fallbackC C) (A, B, C, bool)
TryOr3 has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X
Example ¶
value1, value2, value3, ok3 := TryOr3(func() (int, string, bool, error) {
panic("my error")
}, 21, "hello", false)
fmt.Printf("%v %v %v %v\n", value1, value2, value3, ok3)
Output: 21 hello false false
func TryOr4 ¶
func TryOr4[A, B, C, D any](callback func() (A, B, C, D, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D) (A, B, C, D, bool)
TryOr4 has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X
Example ¶
value1, value2, value3, value4, ok3 := TryOr4(func() (int, string, bool, foo, error) {
panic("my error")
}, 21, "hello", false, foo{bar: "bar"})
fmt.Printf("%v %v %v %v %v\n", value1, value2, value3, value4, ok3)
Output: 21 hello false {bar} false
func TryOr5 ¶
func TryOr5[A, B, C, D, E any](callback func() (A, B, C, D, E, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D, fallbackE E) (A, B, C, D, E, bool)
TryOr5 has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X
Example ¶
value1, value2, value3, value4, value5, ok3 := TryOr5(func() (int, string, bool, foo, float64, error) {
panic("my error")
}, 21, "hello", false, foo{bar: "bar"}, 4.2)
fmt.Printf("%v %v %v %v %v %v\n", value1, value2, value3, value4, value5, ok3)
Output: 21 hello false {bar} 4.2 false
func TryOr6 ¶
func TryOr6[A, B, C, D, E, F any](callback func() (A, B, C, D, E, F, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D, fallbackE E, fallbackF F) (A, B, C, D, E, F, bool)
TryOr6 has the same behavior as Must, but returns a default value in case of error. Play: https://go.dev/play/p/B4F7Wg2Zh9X
Example ¶
value1, value2, value3, value4, value5, value6, ok3 := TryOr6(func() (int, string, bool, foo, float64, string, error) {
panic("my error")
}, 21, "hello", false, foo{bar: "bar"}, 4.2, "world")
fmt.Printf("%v %v %v %v %v %v %v\n", value1, value2, value3, value4, value5, value6, ok3)
Output: 21 hello false {bar} 4.2 world false
func TryWithErrorValue ¶
TryWithErrorValue has the same behavior as Try, but also returns value passed to panic. Play: https://go.dev/play/p/Kc7afQIT2Fs
Example ¶
err1, ok1 := TryWithErrorValue(func() error {
return nil
})
err2, ok2 := TryWithErrorValue(func() error {
return fmt.Errorf("my error")
})
err3, ok3 := TryWithErrorValue(func() error {
panic("my error")
})
fmt.Printf("%v %v\n", err1, ok1)
fmt.Printf("%v %v\n", err2, ok2)
fmt.Printf("%v %v\n", err3, ok3)
Output: <nil> true my error false my error false
func Union ¶
func Union[T comparable, Slice ~[]T](lists ...Slice) Slice
Union returns all distinct elements from given collections. result returns will not change the order of elements relatively.
func Uniq ¶
func Uniq[T comparable, Slice ~[]T](collection Slice) Slice
Uniq returns a duplicate-free version of an array, in which only the first occurrence of each element is kept. The order of result values is determined by the order they occur in the array. Play: https://go.dev/play/p/DTzbeXZ6iEN
Example ¶
list := []int{1, 2, 2, 1}
result := Uniq(list)
fmt.Printf("%v", result)
Output: [1 2]
func UniqBy ¶
func UniqBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice
UniqBy returns a duplicate-free version of an array, in which only the first occurrence of each element is kept. The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is invoked for each element in array to generate the criterion by which uniqueness is computed. Play: https://go.dev/play/p/g42Z3QSb53u
Example ¶
list := []int{0, 1, 2, 3, 4, 5}
result := UniqBy(list, func(i int) int {
return i % 3
})
fmt.Printf("%v", result)
Output: [0 1 2]
func UniqKeys ¶
func UniqKeys[K comparable, V any](in ...map[K]V) []K
UniqKeys creates an array of unique keys in the map. Play: https://go.dev/play/p/TPKAb6ILdHk
Example ¶
kv := map[string]int{"foo": 1, "bar": 2}
kv2 := map[string]int{"bar": 3}
result := UniqKeys(kv, kv2)
sort.Strings(result)
fmt.Printf("%v", result)
Output: [bar foo]
func UniqValues ¶
func UniqValues[K comparable, V comparable](in ...map[K]V) []V
UniqValues creates an array of unique values in the map. Play: https://go.dev/play/p/nf6bXMh7rM3
Example ¶
kv := map[string]int{"foo": 1, "bar": 2}
kv2 := map[string]int{"baz": 2}
result := UniqValues(kv, kv2)
sort.Ints(result)
fmt.Printf("%v", result)
Output: [1 2]
func Unpack2 ¶
Unpack2 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W
Example ¶
a, b := Unpack2(T2("hello", 2))
fmt.Printf("%v %v", a, b)
Output: hello 2
func Unpack3 ¶
Unpack3 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W
Example ¶
a, b, c := Unpack3(T3("hello", 2, true))
fmt.Printf("%v %v %v", a, b, c)
Output: hello 2 true
func Unpack4 ¶
Unpack4 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W
Example ¶
a, b, c, d := Unpack4(T4("hello", 2, true, foo{bar: "bar"}))
fmt.Printf("%v %v %v %v", a, b, c, d)
Output: hello 2 true {bar}
func Unpack5 ¶
Unpack5 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W
Example ¶
a, b, c, d, e := Unpack5(T5("hello", 2, true, foo{bar: "bar"}, 4.2))
fmt.Printf("%v %v %v %v %v", a, b, c, d, e)
Output: hello 2 true {bar} 4.2
func Unpack6 ¶
Unpack6 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W
Example ¶
a, b, c, d, e, f := Unpack6(T6("hello", 2, true, foo{bar: "bar"}, 4.2, "plop"))
fmt.Printf("%v %v %v %v %v %v", a, b, c, d, e, f)
Output: hello 2 true {bar} 4.2 plop
func Unpack7 ¶
Unpack7 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W
Example ¶
a, b, c, d, e, f, g := Unpack7(T7("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false))
fmt.Printf("%v %v %v %v %v %v %v", a, b, c, d, e, f, g)
Output: hello 2 true {bar} 4.2 plop false
func Unpack8 ¶
func Unpack8[A, B, C, D, E, F, G, H any](tuple Tuple8[A, B, C, D, E, F, G, H]) (A, B, C, D, E, F, G, H)
Unpack8 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W
Example ¶
a, b, c, d, e, f, g, h := Unpack8(T8("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false, 42))
fmt.Printf("%v %v %v %v %v %v %v %v", a, b, c, d, e, f, g, h)
Output: hello 2 true {bar} 4.2 plop false 42
func Unpack9 ¶
func Unpack9[A, B, C, D, E, F, G, H, I any](tuple Tuple9[A, B, C, D, E, F, G, H, I]) (A, B, C, D, E, F, G, H, I)
Unpack9 returns values contained in tuple. Play: https://go.dev/play/p/xVP_k0kJ96W
Example ¶
a, b, c, d, e, f, g, h, i := Unpack9(T9("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false, 42, "hello world"))
fmt.Printf("%v %v %v %v %v %v %v %v %v", a, b, c, d, e, f, g, h, i)
Output: hello 2 true {bar} 4.2 plop false 42 hello world
func Unzip2 ¶
Unzip2 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW
Example ¶
a, b := Unzip2([]Tuple2[string, int]{T2("hello", 2)})
fmt.Printf("%v %v", a, b)
Output: [hello] [2]
func Unzip3 ¶
Unzip3 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW
Example ¶
a, b, c := Unzip3([]Tuple3[string, int, bool]{T3("hello", 2, true)})
fmt.Printf("%v %v %v", a, b, c)
Output: [hello] [2] [true]
func Unzip4 ¶
Unzip4 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW
Example ¶
a, b, c, d := Unzip4([]Tuple4[string, int, bool, foo]{T4("hello", 2, true, foo{bar: "bar"})})
fmt.Printf("%v %v %v %v", a, b, c, d)
Output: [hello] [2] [true] [{bar}]
func Unzip5 ¶
Unzip5 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW
Example ¶
a, b, c, d, e := Unzip5([]Tuple5[string, int, bool, foo, float64]{T5("hello", 2, true, foo{bar: "bar"}, 4.2)})
fmt.Printf("%v %v %v %v %v", a, b, c, d, e)
Output: [hello] [2] [true] [{bar}] [4.2]
func Unzip6 ¶
Unzip6 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW
Example ¶
a, b, c, d, e, f := Unzip6([]Tuple6[string, int, bool, foo, float64, string]{T6("hello", 2, true, foo{bar: "bar"}, 4.2, "plop")})
fmt.Printf("%v %v %v %v %v %v", a, b, c, d, e, f)
Output: [hello] [2] [true] [{bar}] [4.2] [plop]
func Unzip7 ¶
func Unzip7[A, B, C, D, E, F, G any](tuples []Tuple7[A, B, C, D, E, F, G]) ([]A, []B, []C, []D, []E, []F, []G)
Unzip7 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW
Example ¶
a, b, c, d, e, f, g := Unzip7([]Tuple7[string, int, bool, foo, float64, string, bool]{T7("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false)})
fmt.Printf("%v %v %v %v %v %v %v", a, b, c, d, e, f, g)
Output: [hello] [2] [true] [{bar}] [4.2] [plop] [false]
func Unzip8 ¶
func Unzip8[A, B, C, D, E, F, G, H any](tuples []Tuple8[A, B, C, D, E, F, G, H]) ([]A, []B, []C, []D, []E, []F, []G, []H)
Unzip8 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW
Example ¶
a, b, c, d, e, f, g, h := Unzip8([]Tuple8[string, int, bool, foo, float64, string, bool, int]{T8("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false, 42)})
fmt.Printf("%v %v %v %v %v %v %v %v", a, b, c, d, e, f, g, h)
Output: [hello] [2] [true] [{bar}] [4.2] [plop] [false] [42]
func Unzip9 ¶
func Unzip9[A, B, C, D, E, F, G, H, I any](tuples []Tuple9[A, B, C, D, E, F, G, H, I]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)
Unzip9 accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration. Play: https://go.dev/play/p/ciHugugvaAW
Example ¶
a, b, c, d, e, f, g, h, i := Unzip9([]Tuple9[string, int, bool, foo, float64, string, bool, int, string]{T9("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false, 42, "hello world")})
fmt.Printf("%v %v %v %v %v %v %v %v %v", a, b, c, d, e, f, g, h, i)
Output: [hello] [2] [true] [{bar}] [4.2] [plop] [false] [42] [hello world]
func UnzipBy2 ¶
UnzipBy2 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.
func UnzipBy3 ¶
func UnzipBy3[In any, A any, B any, C any](items []In, iteratee func(In) (a A, b B, c C)) ([]A, []B, []C)
UnzipBy3 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.
func UnzipBy4 ¶
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)
UnzipBy4 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.
func UnzipBy5 ¶
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)
UnzipBy5 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.
func UnzipBy6 ¶
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)
UnzipBy6 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.
func UnzipBy7 ¶
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)
UnzipBy7 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.
func UnzipBy8 ¶
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)
UnzipBy8 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.
func UnzipBy9 ¶
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)
UnzipBy9 iterates over a collection and creates an array regrouping the elements to their pre-zip configuration.
func Validate ¶
Validate is a helper that creates an error when a condition is not met. Play: https://go.dev/play/p/vPyh51XpCBt
Example ¶
i := 42
err1 := Validate(i < 0, "expected %d < 0", i)
err2 := Validate(i > 0, "expected %d > 0", i)
fmt.Printf("%v\n%v", err1, err2)
Output: expected 42 < 0 <nil>
func ValueOr ¶
func ValueOr[K comparable, V any](in map[K]V, key K, fallback V) V
ValueOr returns the value of the given key or the fallback value if the key is not present. Play: https://go.dev/play/p/bAq9mHErB4V
Example ¶
kv := map[string]int{"foo": 1, "bar": 2}
result1 := ValueOr(kv, "foo", 42)
result2 := ValueOr(kv, "baz", 42)
fmt.Printf("%v %v", result1, result2)
Output: 1 42
func Values ¶
func Values[K comparable, V any](in ...map[K]V) []V
Values creates an array of the map values. Play: https://go.dev/play/p/nnRTQkzQfF6
Example ¶
kv := map[string]int{"foo": 1, "bar": 2}
kv2 := map[string]int{"baz": 3}
result := Values(kv, kv2)
sort.Ints(result)
fmt.Printf("%v", result)
Output: [1 2 3]
func WaitFor ¶
func WaitFor(condition func(i int) bool, timeout time.Duration, heartbeatDelay time.Duration) (totalIterations int, elapsed time.Duration, conditionFound bool)
WaitFor runs periodically until a condition is validated.
func WaitForWithContext ¶
func WaitForWithContext(ctx context.Context, condition func(ctx context.Context, currentIteration int) bool, timeout time.Duration, heartbeatDelay time.Duration) (totalIterations int, elapsed time.Duration, conditionFound bool)
WaitForWithContext runs periodically until a condition is validated or context is canceled.
func Without ¶
func Without[T comparable, Slice ~[]T](collection Slice, exclude ...T) Slice
Without returns slice excluding all given values.
func WithoutEmpty
deprecated
func WithoutEmpty[T comparable, Slice ~[]T](collection Slice) Slice
WithoutEmpty returns slice excluding empty values.
Deprecated: Use wiz.Compact instead.
func ZipBy2 ¶
ZipBy2 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.
func ZipBy3 ¶
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
ZipBy3 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.
func ZipBy4 ¶
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
ZipBy4 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.
func ZipBy5 ¶
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
ZipBy5 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.
func ZipBy6 ¶
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, iteratee func(a A, b B, c C, d D, e E, f F) Out) []Out
ZipBy6 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.
func ZipBy7 ¶
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, iteratee func(a A, b B, c C, d D, e E, f F, g G) Out) []Out
ZipBy7 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.
func ZipBy8 ¶
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, iteratee func(a A, b B, c C, d D, e E, f F, g G, h H) Out) []Out
ZipBy8 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.
func ZipBy9 ¶
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, iteratee func(a A, b B, c C, d D, e E, f F, g G, h H, i I) Out) []Out
ZipBy9 creates a slice of transformed elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value.
Types ¶
type Clonable ¶
type Clonable[T any] interface { Clone() T }
Clonable defines a constraint of types having Clone() T method.
type Complex ¶
type Complex interface {
~complex64 | ~complex128
}
Complex is a constraint that permits any complex numeric type. If future releases of Go add new predeclared complex numeric types, this constraint will be modified to include them.
type DispatchingStrategy ¶
func DispatchingStrategyWeightedRandom ¶
func DispatchingStrategyWeightedRandom[T any](weights []int, gen *rand.Rand) DispatchingStrategy[T]
DispatchingStrategyWeightedRandom distributes messages in a weighted manner. If the channel capacity is exceeded, another random channel will be selected and so on.
type Entry ¶
type Entry[K comparable, V any] struct { Key K Value V }
Entry defines a key/value pairs.
func Entries ¶
func Entries[K comparable, V any](in map[K]V) []Entry[K, V]
Entries transforms a map into array of key/value pairs. Play:
Example ¶
kv := map[string]int{"foo": 1, "bar": 2, "baz": 3}
result := Entries(kv)
sort.Slice(result, func(i, j int) bool {
return strings.Compare(result[i].Key, result[j].Key) < 0
})
fmt.Printf("%v", result)
Output: [{bar 2} {baz 3} {foo 1}]
func ToPairs ¶
func ToPairs[K comparable, V any](in map[K]V) []Entry[K, V]
ToPairs transforms a map into array of key/value pairs. Alias of Entries(). Play: https://go.dev/play/p/3Dhgx46gawJ
type Float ¶
Float is a constraint that permits any floating-point type. If future releases of Go add new predeclared floating-point types, this constraint will be modified to include them.
type Integer ¶
Integer is a constraint that permits any integer type. If future releases of Go add new predeclared integer types, this constraint will be modified to include them.
type Signed ¶
Signed is a constraint that permits any signed integer type. If future releases of Go add new predeclared signed integer types, this constraint will be modified to include them.
type Transaction ¶
type Transaction[T any] struct { // contains filtered or unexported fields }
Transaction implements a Saga pattern
Example ¶
transaction := NewTransaction[int]().
Then(
func(state int) (int, error) {
fmt.Println("step 1")
return state + 10, nil
},
func(state int) int {
fmt.Println("rollback 1")
return state - 10
},
).
Then(
func(state int) (int, error) {
fmt.Println("step 2")
return state + 15, nil
},
func(state int) int {
fmt.Println("rollback 2")
return state - 15
},
).
Then(
func(state int) (int, error) {
fmt.Println("step 3")
if true {
return state, fmt.Errorf("error")
}
return state + 42, nil
},
func(state int) int {
fmt.Println("rollback 3")
return state - 42
},
)
_, _ = transaction.Process(-5)
Output: step 1 step 2 step 3 rollback 2 rollback 1
Example (Error) ¶
transaction := NewTransaction[int]().
Then(
func(state int) (int, error) {
return state + 10, nil
},
func(state int) int {
return state - 10
},
).
Then(
func(state int) (int, error) {
return state, fmt.Errorf("error")
},
func(state int) int {
return state - 15
},
).
Then(
func(state int) (int, error) {
return state + 42, nil
},
func(state int) int {
return state - 42
},
)
state, err := transaction.Process(-5)
fmt.Println(state)
fmt.Println(err)
Output: -5 error
Example (Ok) ¶
transaction := NewTransaction[int]().
Then(
func(state int) (int, error) {
return state + 10, nil
},
func(state int) int {
return state - 10
},
).
Then(
func(state int) (int, error) {
return state + 15, nil
},
func(state int) int {
return state - 15
},
).
Then(
func(state int) (int, error) {
return state + 42, nil
},
func(state int) int {
return state - 42
},
)
state, err := transaction.Process(-5)
fmt.Println(state)
fmt.Println(err)
Output: 62 <nil>
func NewTransaction ¶
func NewTransaction[T any]() *Transaction[T]
NewTransaction instantiate a new transaction.
func (*Transaction[T]) Process ¶
func (t *Transaction[T]) Process(state T) (T, error)
Process runs the Transaction steps and rollbacks in case of errors.
func (*Transaction[T]) Then ¶
func (t *Transaction[T]) Then(exec func(T) (T, error), onRollback func(T) T) *Transaction[T]
Then adds a step to the chain of callbacks. It returns the same Transaction.
type Tuple2 ¶
type Tuple2[A, B any] struct { A A B B }
Tuple2 is a group of 2 elements (pair).
func T2 ¶
T2 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm
Example ¶
result := T2("hello", 2)
fmt.Printf("%v %v", result.A, result.B)
Output: hello 2
func Zip2 ¶
Zip2 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp
Example ¶
result := Zip2([]string{"hello"}, []int{2})
fmt.Printf("%v", result)
Output: [{hello 2}]
type Tuple3 ¶
type Tuple3[A, B, C any] struct { A A B B C C }
Tuple3 is a group of 3 elements.
func T3 ¶
T3 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm
Example ¶
result := T3("hello", 2, true)
fmt.Printf("%v %v %v", result.A, result.B, result.C)
Output: hello 2 true
func Zip3 ¶
Zip3 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp
Example ¶
result := Zip3([]string{"hello"}, []int{2}, []bool{true})
fmt.Printf("%v", result)
Output: [{hello 2 true}]
type Tuple4 ¶
type Tuple4[A, B, C, D any] struct { A A B B C C D D }
Tuple4 is a group of 4 elements.
func T4 ¶
T4 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm
Example ¶
result := T4("hello", 2, true, foo{bar: "bar"})
fmt.Printf("%v %v %v %v", result.A, result.B, result.C, result.D)
Output: hello 2 true {bar}
func Zip4 ¶
Zip4 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp
Example ¶
result := Zip4([]string{"hello"}, []int{2}, []bool{true}, []foo{{bar: "bar"}})
fmt.Printf("%v", result)
Output: [{hello 2 true {bar}}]
type Tuple5 ¶
type Tuple5[A, B, C, D, E any] struct { A A B B C C D D E E }
Tuple5 is a group of 5 elements.
func T5 ¶
T5 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm
Example ¶
result := T5("hello", 2, true, foo{bar: "bar"}, 4.2)
fmt.Printf("%v %v %v %v %v", result.A, result.B, result.C, result.D, result.E)
Output: hello 2 true {bar} 4.2
func Zip5 ¶
Zip5 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp
Example ¶
result := Zip5([]string{"hello"}, []int{2}, []bool{true}, []foo{{bar: "bar"}}, []float64{4.2})
fmt.Printf("%v", result)
Output: [{hello 2 true {bar} 4.2}]
type Tuple6 ¶
type Tuple6[A, B, C, D, E, F any] struct { A A B B C C D D E E F F }
Tuple6 is a group of 6 elements.
func T6 ¶
T6 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm
Example ¶
result := T6("hello", 2, true, foo{bar: "bar"}, 4.2, "plop")
fmt.Printf("%v %v %v %v %v %v", result.A, result.B, result.C, result.D, result.E, result.F)
Output: hello 2 true {bar} 4.2 plop
func Zip6 ¶
func Zip6[A, B, C, D, E, F any](a []A, b []B, c []C, d []D, e []E, f []F) []Tuple6[A, B, C, D, E, F]
Zip6 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp
Example ¶
result := Zip6([]string{"hello"}, []int{2}, []bool{true}, []foo{{bar: "bar"}}, []float64{4.2}, []string{"plop"})
fmt.Printf("%v", result)
Output: [{hello 2 true {bar} 4.2 plop}]
type Tuple7 ¶
type Tuple7[A, B, C, D, E, F, G any] struct { A A B B C C D D E E F F G G }
Tuple7 is a group of 7 elements.
func T7 ¶
T7 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm
Example ¶
result := T7("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false)
fmt.Printf("%v %v %v %v %v %v %v", result.A, result.B, result.C, result.D, result.E, result.F, result.G)
Output: hello 2 true {bar} 4.2 plop false
func Zip7 ¶
func Zip7[A, B, C, D, E, F, G any](a []A, b []B, c []C, d []D, e []E, f []F, g []G) []Tuple7[A, B, C, D, E, F, G]
Zip7 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp
Example ¶
result := Zip7([]string{"hello"}, []int{2}, []bool{true}, []foo{{bar: "bar"}}, []float64{4.2}, []string{"plop"}, []bool{false})
fmt.Printf("%v", result)
Output: [{hello 2 true {bar} 4.2 plop false}]
type Tuple8 ¶
type Tuple8[A, B, C, D, E, F, G, H any] struct { A A B B C C D D E E F F G G H H }
Tuple8 is a group of 8 elements.
func T8 ¶
func T8[A, B, C, D, E, F, G, H any](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]
T8 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm
Example ¶
result := T8("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false, 42)
fmt.Printf("%v %v %v %v %v %v %v %v", result.A, result.B, result.C, result.D, result.E, result.F, result.G, result.H)
Output: hello 2 true {bar} 4.2 plop false 42
func Zip8 ¶
func Zip8[A, B, C, D, E, F, G, H any](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]
Zip8 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp
Example ¶
result := Zip8([]string{"hello"}, []int{2}, []bool{true}, []foo{{bar: "bar"}}, []float64{4.2}, []string{"plop"}, []bool{false}, []int{42})
fmt.Printf("%v", result)
Output: [{hello 2 true {bar} 4.2 plop false 42}]
type Tuple9 ¶
type Tuple9[A, B, C, D, E, F, G, H, I any] struct { A A B B C C D D E E F F G G H H I I }
Tuple9 is a group of 9 elements.
func T9 ¶
func T9[A, B, C, D, E, F, G, H, I any](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]
T9 creates a tuple from a list of values. Play: https://go.dev/play/p/IllL3ZO4BQm
Example ¶
result := T9("hello", 2, true, foo{bar: "bar"}, 4.2, "plop", false, 42, "hello world")
fmt.Printf("%v %v %v %v %v %v %v %v %v", result.A, result.B, result.C, result.D, result.E, result.F, result.G, result.H, result.I)
Output: hello 2 true {bar} 4.2 plop false 42 hello world
func Zip9 ¶
func Zip9[A, B, C, D, E, F, G, H, I any](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]
Zip9 creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on. When collections have different size, the Tuple attributes are filled with zero value. Play: https://go.dev/play/p/jujaA6GaJTp
Example ¶
result := Zip9([]string{"hello"}, []int{2}, []bool{true}, []foo{{bar: "bar"}}, []float64{4.2}, []string{"plop"}, []bool{false}, []int{42}, []string{"hello world"})
fmt.Printf("%v", result)
Output: [{hello 2 true {bar} 4.2 plop false 42 hello world}]
Source Files
¶
Directories
¶
| Path | Synopsis |
|---|---|
|
internal
|
|
|
constraints
Package constraints defines a set of useful constraints to be used with type parameters.
|
Package constraints defines a set of useful constraints to be used with type parameters. |