Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

collection

package

Go to main page

Versions in this module

v0

v0.5.8

May 1, 2024

v0.5.7

Apr 23, 2024

v0.5.6

Apr 19, 2024

v0.5.5

Apr 10, 2024

v0.5.4

Mar 12, 2024

v0.5.3

Feb 4, 2024

Changes in this version

+ func MergeSlice[V any](values ...V) (result []V)

v0.5.2

Jan 24, 2024

Changes in this version

+ func ConvertMapKeysToBatches[M ~map[K]V, K comparable, V any](m M, batchSize int) [][]K

+ func ConvertMapValuesToBatches[M ~map[K]V, K comparable, V any](m M, batchSize int) [][]V

+ func ConvertSliceToBatches[S ~[]V, V any](s S, batchSize int) []S

+ func EqualComparableMap[M ~map[K]V, K comparable, V comparable](map1 M, map2 M) bool

+ func EqualComparableSlice[S ~[]V, V comparable](slice1 S, slice2 S) bool

+ func EqualMap[M ~map[K]V, K comparable, V any](map1 M, map2 M, handler ComparisonHandler[V]) bool

+ func EqualSlice[S ~[]V, V any](slice1 S, slice2 S, handler ComparisonHandler[V]) bool

+ func LoopMapByKeyGetterAsc[M ~map[K]V, K comparable, V comparable, N generic.Ordered](m M, getter func(k K) N, f func(i int, key K, val V) bool)

+ func LoopMapByKeyGetterDesc[M ~map[K]V, K comparable, V comparable, N generic.Ordered](m M, getter func(k K) N, f func(i int, key K, val V) bool)

+ func LoopMapByOrderedKeyAsc[M ~map[K]V, K generic.Ordered, V any](m M, f func(i int, key K, val V) bool)

+ func LoopMapByOrderedKeyDesc[M ~map[K]V, K generic.Ordered, V any](m M, f func(i int, key K, val V) bool)

+ func LoopMapByOrderedValueAsc[M ~map[K]V, K comparable, V generic.Ordered](m M, f func(i int, key K, val V) bool)

+ func LoopMapByOrderedValueDesc[M ~map[K]V, K comparable, V generic.Ordered](m M, f func(i int, key K, val V) bool)

+ func LoopMapByValueGetterAsc[M ~map[K]V, K comparable, V any, N generic.Ordered](m M, getter func(v V) N, f func(i int, key K, val V) bool)

+ func LoopMapByValueGetterDesc[M ~map[K]V, K comparable, V any, N generic.Ordered](m M, getter func(v V) N, f func(i int, key K, val V) bool)

+ func LoopMap[M ~map[K]V, K comparable, V any](m M, f func(i int, key K, val V) bool)

+ func LoopSlice[S ~[]V, V any](slice S, f func(i int, val V) bool)

+ func ReverseLoopSlice[S ~[]V, V any](slice S, f func(i int, val V) bool)

v0.5.1

Jan 14, 2024

v0.5.0

Jan 12, 2024

Changes in this version

+ func AllInComparableSlice[S ~[]V, V comparable](slice S, values []V) bool

+ func AllInComparableSlices[S ~[]V, V comparable](slices []S, values []V) bool

+ func AllInSlice[S ~[]V, V any](slice S, values []V, handler ComparisonHandler[V]) bool

+ func AllInSlices[S ~[]V, V any](slices []S, values []V, handler ComparisonHandler[V]) bool

+ func AllKeyInMap[M ~map[K]V, K comparable, V any](m M, keys ...K) bool

+ func AllKeyInMaps[M ~map[K]V, K comparable, V any](maps []M, keys ...K) bool

+ func AllValueInMap[M ~map[K]V, K comparable, V any](m M, values []V, handler ComparisonHandler[V]) bool

+ func AllValueInMaps[M ~map[K]V, K comparable, V any](maps []M, values []V, handler ComparisonHandler[V]) bool

+ func AnyInAllComparableSlices[S ~[]V, V comparable](slices []S, values []V) bool

+ func AnyInAllSlices[S ~[]V, V any](slices []S, values []V, handler ComparisonHandler[V]) bool

+ func AnyInComparableSlice[S ~[]V, V comparable](slice S, values []V) bool

+ func AnyInComparableSlices[S ~[]V, V comparable](slices []S, values []V) bool

+ func AnyInSlice[S ~[]V, V any](slice S, values []V, handler ComparisonHandler[V]) bool

+ func AnyInSlices[S ~[]V, V any](slices []S, values []V, handler ComparisonHandler[V]) bool

+ func AnyKeyInAllMaps[M ~map[K]V, K comparable, V any](maps []M, keys []K) bool

+ func AnyKeyInMap[M ~map[K]V, K comparable, V any](m M, keys ...K) bool

+ func AnyKeyInMaps[M ~map[K]V, K comparable, V any](maps []M, keys ...K) bool

+ func AnyValueInMap[M ~map[K]V, K comparable, V any](m M, values []V, handler ComparisonHandler[V]) bool

+ func AnyValueInMaps[M ~map[K]V, K comparable, V any](maps []M, values []V, handler ComparisonHandler[V]) bool

+ func AscByClone[S ~[]V, V any, Sort generic.Ordered](slice S, getter func(index int) Sort) S

+ func AscBy[Sort generic.Ordered](a, b Sort) bool

+ func Asc[S ~[]V, V any, Sort generic.Ordered](slice *S, getter func(index int) Sort)

+ func ChooseRandomIndexN[S ~[]V, V any](slice S, n int) (result []int)

+ func ChooseRandomIndexRepeatN[S ~[]V, V any](slice S, n int) (result []int)

+ func ChooseRandomIndex[S ~[]V, V any](slice S) (index int)

+ func ChooseRandomMapKeyAndValueN[M ~map[K]V, K comparable, V any](m M, n int) M

+ func ChooseRandomMapKeyAndValueRepeatN[M ~map[K]V, K comparable, V any](m M, n int) M

+ func ChooseRandomMapKeyAndValue[M ~map[K]V, K comparable, V any](m M) (k K, v V)

+ func ChooseRandomMapKeyN[M ~map[K]V, K comparable, V any](m M, n int) (result []K)

+ func ChooseRandomMapKeyRepeatN[M ~map[K]V, K comparable, V any](m M, n int) (result []K)

+ func ChooseRandomMapKey[M ~map[K]V, K comparable, V any](m M) (k K)

+ func ChooseRandomMapValueN[M ~map[K]V, K comparable, V any](m M, n int) (result []V)

+ func ChooseRandomMapValueRepeatN[M ~map[K]V, K comparable, V any](m M, n int) (result []V)

+ func ChooseRandomMapValue[M ~map[K]V, K comparable, V any](m M) (v V)

+ func ChooseRandomSliceElementN[S ~[]V, V any](slice S, n int) (result []V)

+ func ChooseRandomSliceElementRepeatN[S ~[]V, V any](slice S, n int) (result []V)

+ func ChooseRandomSliceElement[S ~[]V, V any](slice S) (v V)

+ func ClearMap[M ~map[K]V, K comparable, V any](m M)

+ func ClearSlice[S ~[]V, V any](slice *S)

+ func CloneMapN[M ~map[K]V, K comparable, V any](m M, n int) []M

+ func CloneMap[M ~map[K]V, K comparable, V any](m M) M

+ func CloneMaps[M ~map[K]V, K comparable, V any](maps ...M) []M

+ func CloneSliceN[S ~[]V, V any](slice S, n int) []S

+ func CloneSlice[S ~[]V, V any](slice S) S

+ func CloneSlices[S ~[]V, V any](slices ...S) []S

+ func ConvertMapKeysToSlice[M ~map[K]V, K comparable, V any](m M) []K

+ func ConvertMapValuesToBool[M ~map[K]V, N map[K]bool, K comparable, V any](m M) N

+ func ConvertMapValuesToSlice[M ~map[K]V, K comparable, V any](m M) []V

+ func ConvertSliceToAny[S ~[]V, V any](s S) []any

+ func ConvertSliceToBoolMap[S ~[]V, V comparable](s S) map[V]bool

+ func ConvertSliceToIndexMap[S ~[]V, V any](s S) map[int]V

+ func ConvertSliceToIndexOnlyMap[S ~[]V, V any](s S) map[int]struct

+ func ConvertSliceToMap[S ~[]V, V comparable](s S) map[V]struct

+ func DeduplicateSliceInPlaceWithCompare[S ~[]V, V any](s *S, compare func(a, b V) bool)

+ func DeduplicateSliceInPlace[S ~[]V, V comparable](s *S)

+ func DeduplicateSliceWithCompare[S ~[]V, V any](s S, compare func(a, b V) bool) S

+ func DeduplicateSlice[S ~[]V, V comparable](s S) S

+ func DescByClone[S ~[]V, V any, Sort generic.Ordered](slice S, getter func(index int) Sort) S

+ func DescBy[Sort generic.Ordered](a, b Sort) bool

+ func Desc[S ~[]V, V any, Sort generic.Ordered](slice *S, getter func(index int) Sort)

+ func DropSliceByCondition[S ~[]V, V any](slice *S, condition func(v V) bool)

+ func DropSliceByIndices[S ~[]V, V any](slice *S, indices ...int)

+ func DropSliceOverlappingElements[S ~[]V, V any](slice *S, anotherSlice []V, comparisonHandler ComparisonHandler[V])

+ func FilterOutByCondition[S ~[]V, V any](slice S, condition func(v V) bool) S

+ func FilterOutByIndices[S []V, V any](slice S, indices ...int) S

+ func FilterOutByKey[M ~map[K]V, K comparable, V any](m M, key K) M

+ func FilterOutByKeys[M ~map[K]V, K comparable, V any](m M, keys ...K) M

+ func FilterOutByMap[M ~map[K]V, K comparable, V any](m M, condition func(k K, v V) bool) M

+ func FilterOutByValue[M ~map[K]V, K comparable, V any](m M, value V, handler ComparisonHandler[V]) M

+ func FilterOutByValues[M ~map[K]V, K comparable, V any](m M, values []V, handler ComparisonHandler[V]) M

+ func FindCombinationsInSliceByRange[S ~[]V, V any](s S, minSize, maxSize int) []S

+ func FindFirstOrDefaultInSlice[S ~[]V, V any](slice S, defaultValue V) V

+ func FindInComparableSlice[S ~[]V, V comparable](slice S, v V) (i int, t V)

+ func FindInSlice[S ~[]V, V any](slice S, handler func(v V) bool) (i int, t V)

+ func FindIndexInComparableSlice[S ~[]V, V comparable](slice S, v V) int

+ func FindIndexInSlice[S ~[]V, V any](slice S, handler func(v V) bool) int

+ func FindLoopedNextInSlice[S ~[]V, V any](slice S, i int) (next int, value V)

+ func FindLoopedPrevInSlice[S ~[]V, V any](slice S, i int) (prev int, value V)

+ func FindMaxFromComparableMap[M ~map[K]V, K comparable, V generic.Ordered](m M) (result V)

+ func FindMaxFromMap[M ~map[K]V, K comparable, V any, N generic.Ordered](m M, handler OrderedValueGetter[V, N]) (result V)

+ func FindMaximumInComparableSlice[S ~[]V, V generic.Ordered](slice S) (result V)

+ func FindMaximumInSlice[S ~[]V, V any, N generic.Ordered](slice S, handler OrderedValueGetter[V, N]) (result V)

+ func FindMin2MaxFromComparableMap[M ~map[K]V, K comparable, V generic.Ordered](m M) (min, max V)

+ func FindMin2MaxFromMap[M ~map[K]V, K comparable, V generic.Ordered](m M) (min, max V)

+ func FindMin2MaxInComparableSlice[S ~[]V, V generic.Ordered](slice S) (min, max V)

+ func FindMin2MaxInSlice[S ~[]V, V any, N generic.Ordered](slice S, handler OrderedValueGetter[V, N]) (min, max V)

+ func FindMinFromComparableMap[M ~map[K]V, K comparable, V generic.Ordered](m M) (result V)

+ func FindMinFromMap[M ~map[K]V, K comparable, V any, N generic.Ordered](m M, handler OrderedValueGetter[V, N]) (result V)

+ func FindMinimumInComparableSlice[S ~[]V, V generic.Ordered](slice S) (result V)

+ func FindMinimumInSlice[S ~[]V, V any, N generic.Ordered](slice S, handler OrderedValueGetter[V, N]) (result V)

+ func FindOrDefaultInComparableSlice[S ~[]V, V comparable](slice S, v V, defaultValue V) (t V)

+ func FindOrDefaultInSlice[S ~[]V, V any](slice S, defaultValue V, handler func(v V) bool) (t V)

+ func InAllComparableSlices[S ~[]V, V comparable](slices []S, v V) bool

+ func InAllSlices[S ~[]V, V any](slices []S, v V, handler ComparisonHandler[V]) bool

+ func InComparableSlice[S ~[]V, V comparable](slice S, v V) bool

+ func InComparableSlices[S ~[]V, V comparable](slices []S, v V) bool

+ func InSlice[S ~[]V, V any](slice S, v V, handler ComparisonHandler[V]) bool

+ func InSlices[S ~[]V, V any](slices []S, v V, handler ComparisonHandler[V]) bool

+ func InvertMap[M ~map[K]V, N map[V]K, K, V comparable](m M) N

+ func KeyInAllMaps[M ~map[K]V, K comparable, V any](maps []M, key K) bool

+ func KeyInMap[M ~map[K]V, K comparable, V any](m M, key K) bool

+ func MappingFromMap[M ~map[K]V, NM map[K]N, K comparable, V, N any](m M, handler func(value V) N) NM

+ func MappingFromSlice[S ~[]V, NS []N, V, N any](slice S, handler func(value V) N) NS

+ func MergeMapsWithSkip[M ~map[K]V, K comparable, V any](maps ...M) (result M)

+ func MergeMaps[M ~map[K]V, K comparable, V any](maps ...M) (result M)

+ func MergeSlices[S ~[]V, V any](slices ...S) (result S)

+ func ReverseSlice[S ~[]V, V any](s *S)

+ func ShuffleByClone[S ~[]V, V any](slice S) S

+ func Shuffle[S ~[]V, V any](slice *S)

+ func SwapSlice[S ~[]V, V any](slice *S, i, j int)

+ func ValueInMap[M ~map[K]V, K comparable, V any](m M, value V, handler ComparisonHandler[V]) bool

+ type ComparisonHandler func(source, target V) bool

+ type OrderedValueGetter func(v V) N