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.6.1

Aug 17, 2024

Changes in this version

+ func MapSum[M ~map[K]V, K comparable, V any, R constraints.Number](m M, handler func(key K, value V) R) R

+ func SliceSum[S ~[]V, V any, R constraints.Number](slice S, handler func(i int, value V) R) R

v0.6.0

Aug 14, 2024

Changes in this version

+ var ErrCircularDependencyDetected = errors.New("circular dependency detected")

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

+ func TopologicalSort[S ~[]V, Index comparable, V any](slice S, queryIndexHandler func(item V) Index, ...) (S, error)

v0.5.8

May 1, 2024

v0.5.7

Apr 23, 2024

v0.5.6

Apr 19, 2024

v0.5.5

Apr 10, 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 ConvertMapKeysToBatches[M ~map[K]V, K comparable, V any](m M, batchSize int) [][]K

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

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

+ 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 ConvertSliceToBatches[S ~[]V, V any](s S, batchSize int) []S

+ 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 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 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 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 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 MergeSlice[V any](values ...V) (result []V)

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

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

+ 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