Documentation ΒΆ
Index ΒΆ
- func Assign[K comparable, V any](maps ...map[K]V) map[K]V
- func Associate[T any, K comparable, V any](collection []T, transform func(item T) (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 any, B any](f func() (A, B)) chan Tuple2[A, B]
- func Async3[A any, B any, C any](f func() (A, B, C)) chan Tuple3[A, B, C]
- func Async4[A any, B any, C any, D any](f func() (A, B, C, D)) chan Tuple4[A, B, C, D]
- func Async5[A any, B any, C any, D any, E any](f func() (A, B, C, D, E)) chan Tuple5[A, B, C, D, E]
- func Async6[A any, B any, C any, D any, E any, 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 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)
- func BatchWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool)
- func ChannelDispatcher[T any](stream <-chan T, count int, channelBufferCap int, ...) []<-chan T
- func ChannelMerge[T any](channelBufferCap int, upstreams ...<-chan T) <-chan T
- func ChannelToSlice[T any](ch <-chan T) []T
- func Chunk[T any](collection []T, size int) [][]T
- func ChunkString[T ~string](str T, size int) []T
- func Clamp[T constraints.Ordered](value T, min T, max T) T
- func Coalesce[T comparable](v ...T) (result T, ok bool)
- func Compact[T comparable](collection []T) []T
- 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](list1 []T, list2 []T) ([]T, []T)
- 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](msg T, index uint64, channels []<-chan T) int
- func DispatchingStrategyRoundRobin[T any](msg T, index uint64, channels []<-chan T) int
- func Drop[T any](collection []T, n int) []T
- func DropRight[T any](collection []T, n int) []T
- func DropRightWhile[T any](collection []T, predicate func(item T) bool) []T
- func DropWhile[T any](collection []T, predicate func(item T) bool) []T
- func Empty[T any]() 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 Fill[T Clonable[T]](collection []T, initial T) []T
- func Filter[V any](collection []V, predicate func(item V, index int) bool) []V
- func FilterMap[T any, R any](collection []T, callback func(item T, index int) (R, bool)) []R
- func Find[T any](collection []T, predicate func(item T) bool) (T, bool)
- func FindDuplicates[T comparable](collection []T) []T
- func FindDuplicatesBy[T any, U comparable](collection []T, iteratee func(item T) U) []T
- 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](collection []T) []T
- func FindUniquesBy[T any, U comparable](collection []T, iteratee func(item T) U) []T
- func FlatMap[T any, R any](collection []T, iteratee func(item T, index int) []R) []R
- func Flatten[T any](collection [][]T) []T
- func ForEach[T any](collection []T, iteratee func(item T, index int))
- 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 Generator[T any](bufferSize int, generator func(yield func(T))) <-chan T
- func GroupBy[T any, U comparable](collection []T, iteratee func(item T) U) map[U][]T
- 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](collections ...[]T) []T
- func Intersect[T comparable](list1 []T, list2 []T) []T
- func Invert[K comparable, V comparable](in map[K]V) map[V]K
- func IsEmpty[T comparable](v T) bool
- func IsNotEmpty[T comparable](v T) bool
- func IsSorted[T constraints.Ordered](collection []T) bool
- func IsSortedByKey[T any, K constraints.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, error)
- func LastIndexOf[T comparable](collection []T, element T) int
- 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 constraints.Ordered](collection []T) T
- func MaxBy[T any](collection []T, comparison func(a T, b T) bool) T
- func Min[T constraints.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 ...interface{}) T
- func Must0(err any, messageArgs ...interface{})
- func Must1[T any](val T, err any, messageArgs ...interface{}) T
- func Must2[T1 any, T2 any](val1 T1, val2 T2, err any, messageArgs ...interface{}) (T1, T2)
- func Must3[T1 any, T2 any, T3 any](val1 T1, val2 T2, val3 T3, err any, messageArgs ...interface{}) (T1, T2, T3)
- func Must4[T1 any, T2 any, T3 any, T4 any](val1 T1, val2 T2, val3 T3, val4 T4, err any, messageArgs ...interface{}) (T1, T2, T3, T4)
- func Must5[T1 any, T2 any, T3 any, T4 any, T5 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err any, ...) (T1, T2, T3, T4, T5)
- func Must6[T1 any, T2 any, T3 any, T4 any, T5 any, 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 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 constraints.Integer](collection []T, nth N) (T, error)
- func OmitBy[K comparable, V any](in map[K]V, predicate func(key K, value V) bool) map[K]V
- func OmitByKeys[K comparable, V any](in map[K]V, keys []K) map[K]V
- func OmitByValues[K comparable, V comparable](in map[K]V, values []V) map[K]V
- func Partial[T1, T2, R any](f func(a T1, b T2) R, arg1 T1) func(T2) R
- func PartitionBy[T any, K comparable](collection []T, iteratee func(item T) K) [][]T
- func PickBy[K comparable, V any](in map[K]V, predicate func(key K, value V) bool) map[K]V
- func PickByKeys[K comparable, V any](in map[K]V, keys []K) map[K]V
- func PickByValues[K comparable, V comparable](in map[K]V, values []V) map[K]V
- func Range(elementNum int) []int
- func RangeFrom[T constraints.Integer | constraints.Float](start T, elementNum int) []T
- func RangeWithSteps[T constraints.Integer | constraints.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[V any](collection []V, predicate func(item V, index int) bool) []V
- 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](collection []T, old T, new T, n int) []T
- func ReplaceAll[T comparable](collection []T, old T, new T) []T
- func Reverse[T any](collection []T) []T
- func RuneLength(str string) int
- func Sample[T any](collection []T) T
- func Samples[T any](collection []T, count int) []T
- func Shuffle[T any](collection []T) []T
- func Slice[T any](collection []T, start int, end int) []T
- func SliceToChannel[T any](bufferSize int, collection []T) <-chan T
- func SliceToMap[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V
- func Some[T comparable](collection []T, subset []T) bool
- func SomeBy[T any](collection []T, predicate func(item T) bool) bool
- func Subset[T any](collection []T, offset int, length uint) []T
- func Substring[T ~string](str T, offset int, length uint) T
- func Sum[T constraints.Float | constraints.Integer | constraints.Complex](collection []T) T
- func SumBy[T any, R constraints.Float | constraints.Integer | constraints.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 any, B any](callback func() (A, B, error), fallbackA A, fallbackB B) (A, B, bool)
- func TryOr3[A any, B any, C any](callback func() (A, B, C, error), fallbackA A, fallbackB B, fallbackC C) (A, B, C, bool)
- func TryOr4[A any, B any, C any, D any](callback func() (A, B, C, D, error), fallbackA A, fallbackB B, fallbackC C, ...) (A, B, C, D, bool)
- func TryOr5[A any, B any, C any, D any, 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 any, B any, C any, D any, E any, 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](list1 []T, list2 []T) []T
- func Uniq[T comparable](collection []T) []T
- func UniqBy[T any, U comparable](collection []T, iteratee func(item T) U) []T
- func Unpack2[A any, B any](tuple Tuple2[A, B]) (A, B)
- func Unpack3[A any, B any, C any](tuple Tuple3[A, B, C]) (A, B, C)
- func Unpack4[A any, B any, C any, D any](tuple Tuple4[A, B, C, D]) (A, B, C, D)
- func Unpack5[A any, B any, C any, D any, E any](tuple Tuple5[A, B, C, D, E]) (A, B, C, D, E)
- func Unpack6[A any, B any, C any, D any, E any, F any](tuple Tuple6[A, B, C, D, E, F]) (A, B, C, D, E, F)
- func Unpack7[A any, B any, C any, D any, E any, F any, G any](tuple Tuple7[A, B, C, D, E, F, G]) (A, B, C, D, E, F, G)
- func Unpack8[A any, B any, C any, D any, E any, F any, G any, H any](tuple Tuple8[A, B, C, D, E, F, G, H]) (A, B, C, D, E, F, G, H)
- func Unpack9[A any, B any, C any, D any, E any, F any, G any, H any, 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 any, B any](tuples []Tuple2[A, B]) ([]A, []B)
- func Unzip3[A any, B any, C any](tuples []Tuple3[A, B, C]) ([]A, []B, []C)
- func Unzip4[A any, B any, C any, D any](tuples []Tuple4[A, B, C, D]) ([]A, []B, []C, []D)
- func Unzip5[A any, B any, C any, D any, E any](tuples []Tuple5[A, B, C, D, E]) ([]A, []B, []C, []D, []E)
- func Unzip6[A any, B any, C any, D any, E any, F any](tuples []Tuple6[A, B, C, D, E, F]) ([]A, []B, []C, []D, []E, []F)
- func Unzip7[A any, B any, C any, D any, E any, F any, G any](tuples []Tuple7[A, B, C, D, E, F, G]) ([]A, []B, []C, []D, []E, []F, []G)
- func Unzip8[A any, B any, C any, D any, E any, F any, G any, H any](tuples []Tuple8[A, B, C, D, E, F, G, H]) ([]A, []B, []C, []D, []E, []F, []G, []H)
- func Unzip9[A any, B any, C any, D any, E any, F any, G any, H any, I any](tuples []Tuple9[A, B, C, D, E, F, G, H, I]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)
- func Validate(ok bool, format string, args ...any) error
- func Values[K comparable, V any](in map[K]V) []V
- func Without[T comparable](collection []T, exclude ...T) []T
- func WithoutEmpty[T comparable](collection []T) []T
- type Clonable
- type DispatchingStrategy
- type Entry
- type Tuple2
- type Tuple3
- type Tuple4
- type Tuple5
- type Tuple6
- type Tuple7
- type Tuple8
- type Tuple9
- func T9[A any, B any, C any, D any, E any, F any, G any, H any, 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]
- func Zip9[A any, B any, C any, D any, E any, F any, G any, H any, 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]
Examples ΒΆ
- Assign
- Associate
- Attempt
- AttemptWithDelay
- Chunk
- ChunkString
- Clamp
- Count
- CountBy
- CountValues
- CountValuesBy
- Drop
- DropRight
- DropRightWhile
- DropWhile
- Entries
- ErrorsAs
- Fill
- Filter
- FilterMap
- FlatMap
- Flatten
- ForEach
- FromEntries
- GroupBy
- If
- IfF
- Interleave
- Invert
- IsSorted
- IsSortedByKey
- KeyBy
- Keys
- Map
- MapEntries
- MapKeys
- MapToSlice
- MapValues
- Must
- Must0
- Must1
- Must2
- Must3
- Must4
- Must5
- Must6
- NewDebounce
- OmitBy
- OmitByKeys
- OmitByValues
- PartitionBy
- PickBy
- PickByKeys
- PickByValues
- Range
- Reduce
- ReduceRight
- Reject
- Repeat
- RepeatBy
- Replace
- ReplaceAll
- Reverse
- RuneLength
- Shuffle
- Slice
- Subset
- Substring
- Sum
- SumBy
- Switch
- T2
- T3
- T4
- T5
- T6
- T7
- T8
- T9
- Ternary
- TernaryF
- Times
- Try
- Try1
- Try2
- Try3
- Try4
- Try5
- Try6
- TryCatchWithErrorValue
- TryOr
- TryOr1
- TryOr2
- TryOr3
- TryOr4
- TryOr5
- TryOr6
- TryWithErrorValue
- Uniq
- UniqBy
- Unpack2
- Unpack3
- Unpack4
- Unpack5
- Unpack6
- Unpack7
- Unpack8
- Unpack9
- Unzip2
- Unzip3
- Unzip4
- Unzip5
- Unzip6
- Unzip7
- Unzip8
- Unzip9
- Validate
- 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](maps ...map[K]V) map[K]V
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 Associate ΒΆ added in v1.26.0
func Associate[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V
Associate 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 := Associate(list, func(str string) (string, int) { return str, len(str) }) fmt.Printf("%v", result)
Output: map[a:1 aa:2 aaa:3]
func Async ΒΆ added in v1.12.0
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 ΒΆ added in v1.17.0
func Async0(f func()) chan struct{}
Async0 executes a function in a goroutine and returns a channel set once the function finishes.
func Async2 ΒΆ added in v1.17.0
Async2 has the same behavior as Async, but returns the 2 results as a tuple inside the channel.
func Async3 ΒΆ added in v1.17.0
Async3 has the same behavior as Async, but returns the 3 results as a tuple inside the channel.
func Async4 ΒΆ added in v1.17.0
Async4 has the same behavior as Async, but returns the 4 results as a tuple inside the channel.
func Async5 ΒΆ added in v1.17.0
Async5 has the same behavior as Async, but returns the 5 results as a tuple inside the channel.
func Async6 ΒΆ added in v1.17.0
func Async6[A any, B any, C any, D any, E any, F any](f func() (A, B, C, D, E, F)) chan Tuple6[A, B, C, D, E, F]
Async6 has the same behavior as Async, but returns the 6 results as a tuple inside the channel.
func Attempt ΒΆ added in v1.5.0
Attempt invokes a function N times until it returns valid output. Returning either the caught error or nil. When 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 AttemptWithDelay ΒΆ added in v1.16.0
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. Returning either the caught error or nil. When 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 Batch ΒΆ added in v1.31.0
func Batch[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)
Batch 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 BatchWithTimeout ΒΆ added in v1.31.0
func BatchWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool)
BatchWithTimeout 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 ΒΆ added in v1.28.0
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 ΒΆ added in v1.33.0
ChannelMerge collects messages from multiple input channels into a single buffered channel. Output messages has no priority.
func ChannelToSlice ΒΆ added in v1.32.0
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 ChunkString ΒΆ added in v1.27.0
ChunkString returns an array of strings 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/__FLTuJVz54
Example ΒΆ
result1 := ChunkString("123456", 2) result2 := ChunkString("1234567", 2) result3 := ChunkString("", 2) result4 := ChunkString("1", 2) fmt.Printf("%v\n", result1) fmt.Printf("%v\n", result2) fmt.Printf("%v\n", result3) fmt.Printf("%v\n", result4)
Output: [12 34 56] [12 34 56 7] [] [1]
func Clamp ΒΆ added in v1.13.0
func Clamp[T constraints.Ordered](value T, min T, max T) T
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 ΒΆ added in v1.14.0
func Coalesce[T comparable](v ...T) (result T, ok bool)
Coalesce returns the first non-empty arguments. Arguments must be comparable.
func Compact ΒΆ added in v1.22.0
func Compact[T comparable](collection []T) []T
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 ΒΆ added in v1.7.0
ContainsBy returns true if predicate function return true.
func Count ΒΆ added in v1.12.0
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 ΒΆ added in v1.12.0
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 ΒΆ added in v1.32.0
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 ΒΆ added in v1.32.0
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 lo.Map and lo.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](list1 []T, list2 []T) ([]T, []T)
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 ΒΆ added in v1.28.0
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 ΒΆ added in v1.28.0
DispatchingStrategyLeast distributes messages in the emptiest channel.
func DispatchingStrategyMost ΒΆ added in v1.28.0
DispatchingStrategyMost distributes messages in the fullest channel. If the channel capacity is exceeded, the next channel will be selected and so on.
func DispatchingStrategyRandom ΒΆ added in v1.28.0
DispatchingStrategyRandom distributes messages in a random manner. If the channel capacity is exceeded, another random channel will be selected and so on.
func DispatchingStrategyRoundRobin ΒΆ added in v1.28.0
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 ΒΆ added in v1.9.0
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 DropRight ΒΆ added in v1.9.0
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 ΒΆ added in v1.9.0
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 ΒΆ added in v1.9.0
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 ErrorsAs ΒΆ added in v1.29.0
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 ΒΆ added in v1.18.0
EveryBy returns true if the predicate returns true for all of the elements in the collection or if the collection is empty.
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{foo{"a"}, foo{"a"}} result := Fill[foo](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 ΒΆ added in v1.12.0
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 Find ΒΆ
Find search an element in a slice based on a predicate. It returns element and true if element was found.
func FindDuplicates ΒΆ added in v1.25.0
func FindDuplicates[T comparable](collection []T) []T
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 ΒΆ added in v1.25.0
func FindDuplicatesBy[T any, U comparable](collection []T, iteratee func(item T) U) []T
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 ΒΆ added in v1.12.0
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 ΒΆ added in v1.23.0
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 ΒΆ added in v1.23.0
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 ΒΆ added in v1.12.0
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 ΒΆ added in v1.12.0
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 ΒΆ added in v1.25.0
func FindUniques[T comparable](collection []T) []T
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 ΒΆ added in v1.25.0
func FindUniquesBy[T any, U comparable](collection []T, iteratee func(item T) U) []T
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 FlatMap ΒΆ added in v1.7.0
FlatMap manipulates a slice and transforms and flattens it to a slice of another type. 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](collection [][]T) []T
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 FromAnySlice ΒΆ added in v1.21.0
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 ΒΆ added in v1.22.0
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 FromPtr ΒΆ added in v1.22.0
func FromPtr[T any](x *T) T
FromPtr returns the pointer value or empty.
func FromPtrOr ΒΆ added in v1.26.0
func FromPtrOr[T any](x *T, fallback T) T
FromPtrOr returns the pointer value or the fallback value.
func GroupBy ΒΆ
func GroupBy[T any, U comparable](collection []T, iteratee func(item T) U) map[U][]T
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 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 ΒΆ added in v1.13.0
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 ΒΆ added in v1.32.0
func Interleave[T any](collections ...[]T) []T
Interleave round-robbin alternating input slices and sequentially appending value at index into result Play: https://go.dev/play/p/DDhlwrShbwe
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](list1 []T, list2 []T) []T
Intersect returns the intersection between two collections.
func Invert ΒΆ added in v1.13.0
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 ΒΆ added in v1.22.0
func IsEmpty[T comparable](v T) bool
IsEmpty returns true if argument is a zero value.
func IsNotEmpty ΒΆ added in v1.25.0
func IsNotEmpty[T comparable](v T) bool
IsNotEmpty returns true if argument is not a zero value.
func IsSorted ΒΆ added in v1.26.0
func IsSorted[T constraints.Ordered](collection []T) bool
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 ΒΆ added in v1.26.0
func IsSortedByKey[T any, K constraints.Ordered](collection []T, iteratee func(item T) K) bool
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 ΒΆ added in v1.10.1
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[int, string](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} result := Keys(kv) sort.StringSlice(result).Sort() fmt.Printf("%v", result)
Output: [bar 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 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 ΒΆ added in v1.32.0
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 ΒΆ added in v1.13.0
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, v int) string { return strconv.FormatInt(int64(v), 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 ΒΆ added in v1.26.0
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 ΒΆ added in v1.7.0
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(_ int, v int) string { return strconv.FormatInt(int64(v), 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 Max ΒΆ
func Max[T constraints.Ordered](collection []T) T
Max searches the maximum value of a collection. Returns zero value when collection is empty.
func MaxBy ΒΆ added in v1.12.0
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 collection is empty.
func Min ΒΆ
func Min[T constraints.Ordered](collection []T) T
Min search the minimum value of a collection. Returns zero value when collection is empty.
func MinBy ΒΆ added in v1.12.0
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 collection is empty.
func Must ΒΆ added in v1.12.0
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 ΒΆ added in v1.12.0
func Must0(err any, messageArgs ...interface{})
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 ΒΆ added in v1.12.0
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 ΒΆ added in v1.12.0
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 ΒΆ added in v1.12.0
func Must3[T1 any, T2 any, T3 any](val1 T1, val2 T2, val3 T3, err any, messageArgs ...interface{}) (T1, T2, T3)
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 ΒΆ added in v1.12.0
func Must4[T1 any, T2 any, T3 any, T4 any](val1 T1, val2 T2, val3 T3, val4 T4, err any, messageArgs ...interface{}) (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 ΒΆ added in v1.12.0
func Must5[T1 any, T2 any, T3 any, T4 any, T5 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err any, messageArgs ...interface{}) (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 ΒΆ added in v1.12.0
func Must6[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, val6 T6, err any, messageArgs ...interface{}) (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 ΒΆ added in v1.11.0
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 := 0 calls := []int{} mu := sync.Mutex{} debounce, cancel := NewDebounce(time.Millisecond, func() { mu.Lock() defer mu.Unlock() calls = append(calls, i) }) debounce() i++ time.Sleep(5 * time.Millisecond) debounce() i++ debounce() i++ debounce() i++ time.Sleep(5 * time.Millisecond) cancel() fmt.Printf("%v", calls)
Output: [1 4]
func None ΒΆ added in v1.18.0
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 ΒΆ added in v1.18.0
NoneBy returns true if the predicate returns true for none of the elements in the collection or if the collection is empty.
func Nth ΒΆ
func Nth[T any, N constraints.Integer](collection []T, nth N) (T, error)
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 ΒΆ added in v1.13.0
func OmitBy[K comparable, V any](in map[K]V, predicate func(key K, value V) bool) map[K]V
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 ΒΆ added in v1.13.0
func OmitByKeys[K comparable, V any](in map[K]V, keys []K) map[K]V
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 ΒΆ added in v1.13.0
func OmitByValues[K comparable, V comparable](in map[K]V, values []V) map[K]V
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 ΒΆ added in v1.22.0
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 PartitionBy ΒΆ added in v1.4.0
func PartitionBy[T any, K comparable](collection []T, iteratee func(item T) K) [][]T
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 ΒΆ added in v1.13.0
func PickBy[K comparable, V any](in map[K]V, predicate func(key K, value V) bool) map[K]V
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 ΒΆ added in v1.13.0
func PickByKeys[K comparable, V any](in map[K]V, keys []K) map[K]V
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 ΒΆ added in v1.13.0
func PickByValues[K comparable, V comparable](in map[K]V, values []V) map[K]V
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 ΒΆ added in v1.10.0
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 ΒΆ added in v1.10.0
func RangeFrom[T constraints.Integer | constraints.Float](start T, elementNum int) []T
RangeFrom creates an array of numbers from start with specified length. Play: https://go.dev/play/p/0r6VimXAi9H
func RangeWithSteps ΒΆ added in v1.10.0
func RangeWithSteps[T constraints.Integer | constraints.Float](start, end, step T) []T
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 ΒΆ added in v1.26.0
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 ΒΆ added in v1.11.0
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 Repeat ΒΆ added in v1.5.0
Repeat builds a slice with N copies of initial value. Play: https://go.dev/play/p/g3uHXbmc3b6
Example ΒΆ
result := Repeat[foo](2, foo{"a"}) fmt.Printf("%v", result)
Output: [{a} {a}]
func RepeatBy ΒΆ added in v1.19.0
RepeatBy builds a slice with values returned by N calls of callback. Play: https://go.dev/play/p/ozZLCtX_hNU
Example ΒΆ
result := RepeatBy[string](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 ΒΆ added in v1.19.0
func Replace[T comparable](collection []T, old T, new T, n int) []T
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 ΒΆ added in v1.19.0
func ReplaceAll[T comparable](collection []T, old T, new T) []T
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](collection []T) []T
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 RuneLength ΒΆ added in v1.19.0
RuneLength is an alias to utf8.RuneCountInString which returns the number of runes in string. Play: https://go.dev/play/p/tuhgW_lWY8l
Example ΒΆ
result1, chars1 := RuneLength("hellΓ΄"), len("hellΓ΄") result2, chars2 := RuneLength("π€"), len("π€") fmt.Printf("%v %v\n", result1, chars1) fmt.Printf("%v %v\n", result2, chars2)
Output: 5 6 1 4
func Sample ΒΆ added in v1.6.0
func Sample[T any](collection []T) T
Sample returns a random item from collection.
func Shuffle ΒΆ
func Shuffle[T any](collection []T) []T
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} result := Shuffle(list) fmt.Printf("%v", result)
Output:
func Slice ΒΆ added in v1.22.0
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 ΒΆ added in v1.31.0
SliceToChannel returns a read-only channels of collection elements.
func SliceToMap ΒΆ added in v1.27.0
func SliceToMap[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V
SliceToMap 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. Alias of Associate(). Play: https://go.dev/play/p/WHa2CfMO3Lr
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 ΒΆ added in v1.18.0
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 Subset ΒΆ added in v1.19.0
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 Substring ΒΆ added in v1.19.0
Substring return part of a string. Play: https://go.dev/play/p/TQlxQi82Lu1
Example ΒΆ
result1 := Substring("hello", 2, 3) result2 := Substring("hello", -4, 3) result3 := Substring("hello", -2, math.MaxUint) fmt.Printf("%v\n", result1) fmt.Printf("%v\n", result2) fmt.Printf("%v\n", result3)
Output: llo ell lo
func Sum ΒΆ added in v1.32.0
func Sum[T constraints.Float | constraints.Integer | constraints.Complex](collection []T) T
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 ΒΆ added in v1.20.0
func SumBy[T any, R constraints.Float | constraints.Integer | constraints.Complex](collection []T, iteratee func(item T) R) R
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 ΒΆ added in v1.20.0
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 ΒΆ added in v1.30.0
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 ΒΆ added in v1.5.0
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 ΒΆ added in v1.21.0
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 ΒΆ added in v1.11.0
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 ΒΆ added in v1.11.0
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 ΒΆ added in v1.11.0
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 ΒΆ added in v1.11.0
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 ΒΆ added in v1.11.0
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 ΒΆ added in v1.11.0
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 ΒΆ added in v1.11.0
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 ΒΆ added in v1.11.0
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 ΒΆ added in v1.11.0
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 ΒΆ added in v1.11.0
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 ΒΆ added in v1.29.0
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 ΒΆ added in v1.29.0
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 ΒΆ added in v1.29.0
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 ΒΆ added in v1.29.0
func TryOr3[A any, B any, 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 ΒΆ added in v1.29.0
func TryOr4[A any, B any, C any, 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 ΒΆ added in v1.29.0
func TryOr5[A any, B any, C any, D any, 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 ΒΆ added in v1.29.0
func TryOr6[A any, B any, C any, D any, E any, 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 ΒΆ added in v1.11.0
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 ΒΆ added in v1.8.0
func Union[T comparable](list1 []T, list2 []T) []T
Union returns all distinct elements from both collections. result returns will not change the order of elements relatively.
func Uniq ΒΆ
func Uniq[T comparable](collection []T) []T
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](collection []T, iteratee func(item T) U) []T
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 Unpack2 ΒΆ added in v1.17.0
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 ΒΆ added in v1.17.0
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 ΒΆ added in v1.17.0
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 ΒΆ added in v1.17.0
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 ΒΆ added in v1.17.0
func Unpack6[A any, B any, C any, D any, E any, F any](tuple Tuple6[A, B, C, D, E, F]) (A, B, C, D, E, F)
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 ΒΆ added in v1.17.0
func Unpack7[A any, B any, C any, D any, E any, F any, G any](tuple Tuple7[A, B, C, D, E, F, G]) (A, B, C, D, E, F, G)
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 ΒΆ added in v1.17.0
func Unpack8[A any, B any, C any, D any, E any, F any, G any, 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 ΒΆ added in v1.17.0
func Unpack9[A any, B any, C any, D any, E any, F any, G any, H any, 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 ΒΆ added in v1.4.0
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 ΒΆ added in v1.4.0
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 ΒΆ added in v1.4.0
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 ΒΆ added in v1.4.0
func Unzip5[A any, B any, C any, D any, E any](tuples []Tuple5[A, B, C, D, E]) ([]A, []B, []C, []D, []E)
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 ΒΆ added in v1.4.0
func Unzip6[A any, B any, C any, D any, E any, F any](tuples []Tuple6[A, B, C, D, E, F]) ([]A, []B, []C, []D, []E, []F)
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 ΒΆ added in v1.4.0
func Unzip7[A any, B any, C any, D any, E any, F any, 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 ΒΆ added in v1.4.0
func Unzip8[A any, B any, C any, D any, E any, F any, G any, 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 ΒΆ added in v1.4.0
func Unzip9[A any, B any, C any, D any, E any, F any, G any, H any, 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 Validate ΒΆ added in v1.30.0
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 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} result := Values(kv) sort.IntSlice(result).Sort() fmt.Printf("%v", result)
Output: [1 2]
func Without ΒΆ added in v1.24.0
func Without[T comparable](collection []T, exclude ...T) []T
Without returns slice excluding all given values.
func WithoutEmpty ΒΆ added in v1.24.0
func WithoutEmpty[T comparable](collection []T) []T
WithoutEmpty returns slice excluding empty values.
Types ΒΆ
type Clonable ΒΆ
type Clonable[T any] interface { Clone() T }
Clonable defines a constraint of types having Clone() T method.
type DispatchingStrategy ΒΆ added in v1.28.0
func DispatchingStrategyWeightedRandom ΒΆ added in v1.28.0
func DispatchingStrategyWeightedRandom[T any](weights []int) 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 ΒΆ added in v1.22.0
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 Tuple2 ΒΆ added in v1.4.0
Tuple2 is a group of 2 elements (pair).
func T2 ΒΆ added in v1.13.0
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 ΒΆ added in v1.4.0
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 ΒΆ added in v1.4.0
Tuple3 is a group of 3 elements.
func T3 ΒΆ added in v1.13.0
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 ΒΆ added in v1.4.0
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 ΒΆ added in v1.4.0
Tuple4 is a group of 4 elements.
func T4 ΒΆ added in v1.13.0
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 ΒΆ added in v1.4.0
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 ΒΆ added in v1.4.0
Tuple5 is a group of 5 elements.
func T5 ΒΆ added in v1.13.0
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 ΒΆ added in v1.4.0
func Zip5[A any, B any, C any, D any, E any](a []A, b []B, c []C, d []D, e []E) []Tuple5[A, B, C, D, E]
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 ΒΆ added in v1.4.0
Tuple6 is a group of 6 elements.
func T6 ΒΆ added in v1.13.0
func T6[A any, B any, C any, D any, E any, F any](a A, b B, c C, d D, e E, f F) Tuple6[A, B, C, D, E, F]
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 ΒΆ added in v1.4.0
func Zip6[A any, B any, C any, D any, E any, 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 ΒΆ added in v1.4.0
Tuple7 is a group of 7 elements.
func T7 ΒΆ added in v1.13.0
func T7[A any, B any, C any, D any, E any, F any, G any](a A, b B, c C, d D, e E, f F, g G) Tuple7[A, B, C, D, E, F, G]
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 ΒΆ added in v1.4.0
func Zip7[A any, B any, C any, D any, E any, F any, 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 ΒΆ added in v1.4.0
type Tuple8[A any, B any, C any, D any, E any, F any, G any, 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 ΒΆ added in v1.13.0
func T8[A any, B any, C any, D any, E any, F any, G any, 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 ΒΆ added in v1.4.0
func Zip8[A any, B any, C any, D any, E any, F any, G any, 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 ΒΆ added in v1.4.0
type Tuple9[A any, B any, C any, D any, E any, F any, G any, H any, 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 ΒΆ added in v1.13.0
func T9[A any, B any, C any, D any, E any, F any, G any, H any, 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 ΒΆ added in v1.4.0
func Zip9[A any, B any, C any, D any, E any, F any, G any, H any, 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}]