The highest tagged major version is
Documentation
¶
Index ¶
- func AllMatch[T any](values []T, predicate func(v *T) bool) bool
- func AnyMatch[T any](values []T, predicate func(v *T) bool) bool
- func AsString[T uconst.Stringable](delimiter string, values ...T) string
- func BestMatchBy[T any](values []T, predicate func(currentBest, candidate *T) bool) *T
- func CollectAsMap[K comparable, V, R any](values []V, key func(v *V) K, val func(v V) R) map[K]R
- func Contains[V comparable](values []V, val V) int
- func ContainsAny[V comparable](from []V, values ...V) int
- func ContainsPredicate[T any](values []T, predicate func(v *T) bool) (int, *T)
- func ContainsStruct[K comparable, V Indexed[K]](values []V, val V) (int, *V)
- func CopyWithoutIndex[T any](src []T, index int) []T
- func CopyWithoutIndexes[T any](src []T, indexes []int) []T
- func EqualValues[T constraints.Ordered](left []T, right []T) bool
- func EqualValuesCompare[T any](left []T, right []T, compare func(t1, t2 T) bool, less func(t1, t2 T) bool) bool
- func EqualsCompareWithOrder[T any](left []T, right []T, compare func(t1 T, t2 T) bool) bool
- func EqualsWithOrder[T comparable](left []T, right []T) bool
- func Filter[V any](values []V, filter func(v *V) bool) []V
- func FilterAll[V any](values []V, filter func(v *V) bool) ([]V, []V)
- func FilterBySet[V comparable](values []V, filter ...V) []V
- func FilterOut[V any](values []V, filter func(v *V) bool) []V
- func FilterOutBySet[V comparable](values []V, filter ...V) []V
- func Find[V any](values []V, filter func(v *V) bool) *V
- func FindBinary[V any](values []V, filter func(v *V) bool) *V
- func Flat[V any](values [][]V) []V
- func FlatMap[V, R any](values [][]V, m func(v *V) R) []R
- func GroupBy[V any, G comparable](values []V, group func(v *V) G, aggregator func(v1, v2 *V) V) []V
- func GroupToMapBy[V any, G comparable](values []V, group func(v *V) G) map[G][]V
- func Has[T comparable](values []T, val T) bool
- func IndexOfUint32(slice []uint32, value uint32) int
- func Map[V, R any](values []V, m func(v *V) R) []R
- func MapAggr[V, R any](values []V, aggr func(v *V) []R) []R
- func MapAndGroupToMapBy[V any, G comparable, R any](values []V, group func(v *V) (G, R)) map[G][]R
- func Merge[K comparable, T any](t1 []T, t2 []T, key func(t *T) K) []T
- func Range[T uconst.Integer](from, to T) []T
- func RangeWithStep(from, to, step int) []int
- func SortFind[V any](values []V, less func(a, b V) bool, filter func(*V) bool) *V
- func Split[T any](slice []T, chunkSize int) [][]T
- func ToMap[V any, K comparable, R any](values []V, m func(v *V) (K, R)) map[K]R
- func ToMultiMap[V any, K comparable, R any](values []V, m func(v *V) (K, R)) map[K][]R
- func Uniq[V any, F comparable](values []V, getter func(v *V) F) []V
- func Unique[V comparable](values []V, transform ...func(v *V) V) []V
- type Indexed
- type Pair
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func AllMatch ¶ added in v1.16.8
AllMatch checks if all slice elements match the predicate. Returns true if all elements match the predicate, false otherwise.
func AnyMatch ¶
AnyMatch checks if slice has an element that matches predicate. Returns true if there's a match, false otherwise.
func AsString ¶ added in v1.20.0
func AsString[T uconst.Stringable](delimiter string, values ...T) string
AsString converts any supported numeric value to a string and joins them with the specified delimiter.
func BestMatchBy ¶ added in v1.19.1
BestMatchBy iterates over the slice and selects the element that satisfies the predicate function as the best match. The predicate function compares the current best match with the candidate and determines if the candidate is better. Returns a pointer to the selected element or nil if the slice is empty.
func CollectAsMap ¶
func CollectAsMap[K comparable, V, R any](values []V, key func(v *V) K, val func(v V) R) map[K]R
CollectAsMap collects corresponding values to a map.
func Contains ¶
func Contains[V comparable](values []V, val V) int
Contains checks if slice contains specified element. Returns its index if found, -1 otherwise.
func ContainsAny ¶
func ContainsAny[V comparable](from []V, values ...V) int
ContainsAny checks if slice contains any element from another slice. Returns its index if found, -1 otherwise.
func ContainsPredicate ¶
ContainsPredicate checks if slice contains specified struct element by using a predicate. Returns its index and value if found, -1 and nil otherwise.
func ContainsStruct ¶
func ContainsStruct[K comparable, V Indexed[K]](values []V, val V) (int, *V)
ContainsStruct checks if slice contains specified struct element. Returns its index and value if found, -1 and nil otherwise.
func CopyWithoutIndex ¶
CopyWithoutIndex copies a slice while ignoring an element at specific index
func CopyWithoutIndexes ¶ added in v1.17.4
CopyWithoutIndexes copies a slice while ignoring elements at specific indexes. Duplicate values for indexes are ignored.
func EqualValues ¶
func EqualValues[T constraints.Ordered](left []T, right []T) bool
EqualValues compares values of two slices regardless of elements order
func EqualValuesCompare ¶
func EqualValuesCompare[T any](left []T, right []T, compare func(t1, t2 T) bool, less func(t1, t2 T) bool) bool
EqualValuesCompare compares values of two slices regardless of elements order
func EqualsCompareWithOrder ¶
EqualsCompareWithOrder compares two slices taking into consideration elements order
func EqualsWithOrder ¶
func EqualsWithOrder[T comparable](left []T, right []T) bool
EqualsWithOrder compares two slices taking into consideration elements order
func Filter ¶
Filter filters values slice and returns a copy with filtered elements matching a predicate. Returns its index if found, -1 otherwise.
func FilterAll ¶
FilterAll filters values slice and returns a copy with filtered elements matching a predicate and elements that do not match any filter. Returns its index if found, -1 otherwise.
func FilterBySet ¶
func FilterBySet[V comparable](values []V, filter ...V) []V
FilterBySet filters values slice and returns a copy with filtered elements matching values from filter. Returns its index if found, -1 otherwise.
func FilterOut ¶ added in v1.10.0
FilterOut is a macros to Filter, so it acts like Filter, but filters out values. That means that only values not matching the filter will be returned.
func FilterOutBySet ¶ added in v1.18.1
func FilterOutBySet[V comparable](values []V, filter ...V) []V
FilterOutBySet filters out values slice and returns a copy without filtered elements matching values from filter. Returns its index if found, -1 otherwise.
func FindBinary ¶ added in v1.25.0
FindBinary finds the first match in a sorted slice using binary search. The filter function should implement a comparison suitable for binary search.
func FlatMap ¶
func FlatMap[V, R any](values [][]V, m func(v *V) R) []R
FlatMap applies the Map method and the Flat method consequently.
func GroupBy ¶
func GroupBy[V any, G comparable](values []V, group func(v *V) G, aggregator func(v1, v2 *V) V) []V
GroupBy groups and aggregates elements with aggregator method func
func GroupToMapBy ¶
func GroupToMapBy[V any, G comparable](values []V, group func(v *V) G) map[G][]V
GroupToMapBy groups elements with group method func
func Has ¶ added in v1.18.1
func Has[T comparable](values []T, val T) bool
Has checks if slice has an element. Returns true if there's a match, false otherwise.
func IndexOfUint32 ¶
func MapAggr ¶
func MapAggr[V, R any](values []V, aggr func(v *V) []R) []R
MapAggr maps a func to each set of elements and returns an aggregated result.
func MapAndGroupToMapBy ¶ added in v1.18.4
func MapAndGroupToMapBy[V any, G comparable, R any](values []V, group func(v *V) (G, R)) map[G][]R
MapAndGroupToMapBy same as GroupToMapBy, but allows elements to be mapped to a different type.
func Merge ¶
func Merge[K comparable, T any](t1 []T, t2 []T, key func(t *T) K) []T
Merge merges two slices with t1 elements prioritized against elements of t2.
func Range ¶ added in v1.10.0
Range generates a slice of integers from 'from' to 'to' (exclusive). The type T must be an integer type (e.g., int, int64, uint, etc.). The returned slice includes 'from', but is exclusive to 'to'. Example usage: FromRange(1, 5) returns []int{1, 2, 3, 4}.
func RangeWithStep ¶ added in v1.10.0
RangeWithStep generates a slice of integers starting from 'from' up to and including 'to' with a specified step. The 'from' argument specifies the starting value (inclusive). The 'to' argument specifies the ending value (inclusive). The 'step' argument specifies the interval between generated elements. The function returns a slice of integers with elements generated using the specified step. Example usage: result := uarray.RangeWithStep(1, 9, 2) generates []int{1, 3, 5, 7, 9}. Example usage: result := uarray.RangeWithStep(1, 9, 100) generates []int{1, 101} when step > range.
Note: The 'to' argument is inclusive to ensure that the last element specified by 'to' is included in the result. When the 'step' value is larger than the range (i.e., 'to - from'), the function generates a slice with only two elements: the starting value 'from' and the incremented value 'from + step'. This behavior is intentional to handle cases where the step is larger than the range and still provide a predictable result.
func SortFind ¶ added in v1.10.0
SortFind sorts the given slice using the provided less function and then finds the first match using a binary search with the filter function. This approach is efficient for large slices and repeated searches, as it leverages the speed of binary search. NOTE: please note that the original slice will be modified.
Parameters:
- values: the slice of elements to search through.
- less: a function that defines the order of elements for sorting.
- filter: a function that tests each element to find a match.
Returns:
- A pointer to the found element, or nil if no match is found.
func Split ¶ added in v1.19.3
Split divides a slice into multiple smaller slices (chunks) of a specified size and returns a slice of these chunks.
If chunkSize is less than or equal to zero, the function returns a slice containing the original slice as its only element. If the length of the input slice isn't perfectly divisible by chunkSize, the last chunk will contain the remaining elements.
Example:
input: []int{1, 2, 3, 4, 5}, chunkSize: 2
output: [][]int{{1, 2}, {3, 4}, {5}}
Type Parameters:
T - The type of elements in the slice.
Parameters:
slice - The input slice to be split. chunkSize - The desired size of each chunk.
Returns:
A two-dimensional slice where each inner slice is a chunk of the original slice.
func ToMap ¶
func ToMap[V any, K comparable, R any](values []V, m func(v *V) (K, R)) map[K]R
ToMap collects elements of a slice into a map using a collector function. Note:
If the mapping function produces the same key for multiple elements, the resulting map will contain only the last value associated with that key, as the map does not behave like a multimap. Each key in the returned map corresponds to a single value, and any previous value for the same key will be overwritten.
func ToMultiMap ¶
func ToMultiMap[V any, K comparable, R any](values []V, m func(v *V) (K, R)) map[K][]R
ToMultiMap collects a stream using collector func to a multimap.
func Uniq ¶
func Uniq[V any, F comparable](values []V, getter func(v *V) F) []V
Uniq filters unique elements by predicate that returns any comparable value
func Unique ¶ added in v1.24.0
func Unique[V comparable](values []V, transform ...func(v *V) V) []V
Unique filters unique elements from a slice.
The function accepts an optional list of transform functions. Each transform function can modify the elements before comparing them. If no transform functions are provided, elements are compared directly.
Parameters: - values: The slice of comparable elements to filter. - transform: A variadic list of functions that take a pointer to a value and return the transformed value. All transform functions are applied in provided order.
Returns: - A slice of unique elements from the input, based on the provided transform functions (if any).
Example:
values := []int{1, 2, 2, 3, 4, 4}
uniqueValues := Unique(values) // Output: [1, 2, 3, 4]
// Using a transform function to compare absolute values
valuesWithNegatives := []int{-1, 1, -2, 2, 3}
uniqueAbsValues := Unique(valuesWithNegatives, func(v *int) int { return abs(*v) })
// Output: [-1, -2, 3]
Source Files