import "github.com/sudhirj/slicy"

func All[S ~[]T, T any](slice S, predicate func(value T, index int, slice S) bool) bool

All returns true if the given predicate returns true for every element of the given slice.

func Any[S ~[]T, T any](slice S, predicate func(value T, index int, slice S) bool) bool

Any return true if the given predicate returns true for any element of the given slice.

func Chunk[S ~[]T, T any](slice S, chunkSize int) []S

Chunk splits the given slice into smaller slices, each the length of chunkSize. If the slice cannot be split evenly, the last chunk will have the remaining elements.

func Concat[S ~[]T, T any](slices ...S) S

Concat combines all the elements from all the given slices into a single slice.

func CountBy[S ~[]T, T any, U comparable](slice S, iteratee func(T) U) map[U]int

CountBy creates a map composed of keys generated from the results of running each element of the slice through iteratee. The corresponding value of each key is the number of times the key was returned by iteratee.

func Difference[S ~[]T, T comparable](slice S, others ...S) S

Difference returns a list of items present in slice that are not present in any of the others slices. The comparison is performed with ==.

func DifferenceBy[S ~[]T, T any, U comparable](slice S, iteratee func(T) U, others ...S) S

DifferenceBy returns a list of items present in slice that are not present in any of the others slices, with the comparison made by passing items into the iteratee function and checking == on the result. This allows changing the way the item is viewed for comparison.

func DifferenceWith[S ~[]T, T any](slice S, comparator func(T, T) bool, others ...S) S

DifferenceWith returns a slice of items present in slice that are not present in any of the others slices, with the comparison made using the given comparator.

func Drop[S ~[]T, T any](slice S, n int) S

Drop returns a new slice with n elements dropped from the beginning.

func DropRight[S ~[]T, T any](slice S, n int) S

DropRight returns a new slice with n elements dropped from the end.

func DropRightWhile[S ~[]T, T any](slice S, predicate func(value T, index int, slice S) bool) S

DropRightWhile creates a new slice excluding elements dropped from the end. Elements are dropped until predicate returns false.

func DropWhile[S ~[]T, T any](slice S, predicate func(value T, index int, slice S) bool) S

DropWhile creates a new slice excluding elements dropped from the beginning. Elements are dropped until predicate returns false.

func Each[S ~[]T, T any](slice S, iteratee func(value T, index int, slice S))

Each invokes the given iteratee for every element in the slice, from left to right.

func EachRight[S ~[]T, T any](slice S, iteratee func(value T, index int, slice S))

EachRight invokes the given iteratee for every element in the slice, from right to left.

func Every[S ~[]T, T any](slice S, predicate func(value T, index int, slice S) bool) bool

Every returns true if the given predicate returns true for every element of the given slice.

func Fill[S ~[]T, T any](slice S, value T, start int, end int)

Fill fills elements of slice with value from start up to, but not including end.

func Filter[S ~[]T, T any](slice S, predicate func(value T, index int, slice S) bool) S

Filter iterates over the elements of slice, returning a slice of all elements that the predicate returns true for.

func Find[S ~[]T, T any](slice S, predicate func(value T, index int, slice S) bool) (result T)

Find iterates over the elements of slice, returning the first element that predicate returns true for.

func FindIndex[S ~[]T, T any](slice S, predicate func(T) bool) int

FindIndex returns the index of the first element for which the predicate returns true.

func FindLastIndex[S ~[]T, T any](slice S, predicate func(T) bool) int

FindLastIndex returns the index of the last element of which the predicate returns true.

func FlatMap[S ~[]T, T any, U any](slice S, iteratee func(value T, index int, slice S) []U) []U

FlatMap creates a flattened slice of values by running each element in slice through iteratee and flattening the mapped results.

func GroupBy[S ~[]T, T any, U comparable](slice S, iteratee func(T) U) map[U]S

GroupBy creates a map composed of keys generated from the results of running each element of slice through iteratee. The order of the grouped values is determined by the order that they occur in slice. The corresponding value of each key is a slice of elements responsible for generating the key.

func Includes[S ~[]T, T comparable](slice S, value T) bool

Includes checks if value is in slice. Equality is checked with ==.

func IndexOf[S ~[]T, T comparable](slice S, value T) int

IndexOf returns the index at which the first occurrence of value is found in slice. Returns -1 if not found.

func Intersection[S ~[]T, T comparable](slices ...S) S

Intersection returns a slice of unique values that are included in all given slices. The order of the result values are determined by the first slice.

func IntersectionBy[S ~[]T, T any, U comparable](iteratee func(T) U, others ...S) S

IntersectionBy returns a slice of unique values that are included in all given slices, with comparison happening on the result of the iteratee function. The order of the result values are determined by the first slice.

func IntersectionWith[S ~[]T, T any](comparator func(T, T) bool, slices ...S) S

IntersectionWith returns a slice of unique values that are included in all given slice, with comparison happening inside the given comparator. The order of the result values are determined by the first slice.

func Join[S ~[]T, T any](slice S, separator string) string

Join concatenates all the elements of the slice into a string separated by separator. fmt.Sprint is used for to get the string representation of the given value, so mixed types are possible with []any.

func KeyBy[S ~[]T, T any, U comparable](slice S, iteratee func(T) U) map[U]T

KeyBy creates a map composed of keys generated from the results of running each element of slice through iteratee. The corresponding value of each key is the last element responsible for generating the key.

func LastIndexOf[S ~[]T, T comparable](slice S, value T) int

LastIndexOf returns the index at which the last occurrence of value is found in slice. Returns -1 if not found.

func Map[S ~[]T, T any, U any](slice S, iteratee func(T) U) []U

Map creates a slice of values by running each element in slice through iteratee.

func Nth[S ~[]T, T any](slice S, n int) T

Nth gets the element at index n of the slice. If n is negative, the nth element from the end is returned.

func Partition[S ~[]T, T any](slice S, predicate func(T) bool) (truths S, falsehoods S)

Partition creates two slices, the first of which contains elements that predicate returns true for, with the second containing elements for which predicate returns false.

func Pull[S ~[]T, T comparable](slice S, values ...T) S

Pull returns a new slice without all the given values.

func PullAll[S ~[]T, T comparable](slice S, values []T) S

PullAll returns a new slice without the items in values.

func PullAllBy[S ~[]T, T any, U comparable](slice S, values []T, iteratee func(T) U) S

PullAllBy returns a new slice without the items in values, with the comparison made by passing both values through the iteratee function.

func PullAllWith[S ~[]T, T any](slice S, values []T, comparator func(T, T) bool) S

PullAllWith returns a new slice without the items in values, with the comparison made using the given comparator.

func PullAt[S ~[]T, T comparable](slice S, indexes ...int) S

PullAt returns a new slice without the items at the given indexes.

func Reduce[S ~[]T, T any, U any](slice S, iteratee func(acc U, value T, index int, slice S) U, accumulator U) U

Reduce reduces slice to a value which is the accumulated result of running each element in slice through iteratee, where each successive invocation is supplied the return value of the previous one. accumulator is used as the initial value.

func ReduceRight[S ~[]T, T any, U any](slice S, iteratee func(acc U, value T, index int, slice S) U, accumulator U) U

ReduceRight reduces slice to a value which is the accumulated result of running each element in slice, from right to left, through iteratee, where each successive invocation is supplied the return value of the previous one. accumulator is used as the initial value.

func Reject[S ~[]T, T any](slice S, predicate func(value T, index int, slice S) bool) S

Reject iterates over the elements of slice, returning a new slice of the elements for which predicate returns false.

func Remove[S ~[]T, T any](slice S, predicate func(value T, index int, slice S) bool) S

Remove returns a new slice without the elements for which the predicate returns true.

func Reverse[S ~[]T, T any](slice S) S

Reverse return the reverse of slice: with the first element last, the second element second-to-last, and so on.

func Some[S ~[]T, T any](slice S, predicate func(value T, index int, slice S) bool) bool

Some return true if the given predicate returns true for any element of the given slice.

func SortedIndex[S ~[]T, T constraints.Ordered](slice S, value T) int

SortedIndex uses a binary search to determine the lowest index at which value should be inserted into slice in order to maintain its sort order.

func SortedIndexBy[S ~[]T, T any, U constraints.Ordered](slice S, value T, iteratee func(T) U) int

SortedIndexBy uses a binary search to determine the lowest index at which value should be inserted into slice in order to maintain its sort order, with the iteratee function used to compute sort ranking.

func SortedIndexOf[S ~[]T, T constraints.Ordered](slice S, value T) int

SortedIndexOf performs a binary search on a sorted slice to find the given value. Returns -1 if not found.

func SortedLastIndex[S ~[]T, T constraints.Ordered](slice S, value T) int

SortedLastIndex returns the highest index at which value should be inserted into the sorted slice to maintain its sort order.

func SortedLastIndexBy[S ~[]T, T any, U constraints.Ordered](slice S, value T, iteratee func(T) U) int

SortedLastIndexBy returns the highest index at which value should be inserted into the sorted slice to maintain its sort order, with comparisons made on the result of passing all values through iteratee.

func SortedLastIndexOf[S ~[]T, T constraints.Ordered](slice S, value T) int

SortedLastIndexOf returns the highest index at which the value is present in the sorted slice.

func Take[S ~[]T, T any](slice S, n int) S

Take returns a new slice with n elements taken from the beginning.

func TakeRight[S ~[]T, T any](slice S, n int) S

TakeRight returns a new slice with n elements taken from the end.

func TakeRightWhile[S ~[]T, T any](slice S, predicate func(value T, index int, slice S) bool) S

TakeRightWhile creates a slice of elements taken from the end of slice. Elements are taken until the predicate returns false.

func TakeWhile[S ~[]T, T any](slice S, predicate func(value T, index int, slice S) bool) S

TakeWhile creates a slice of elements taken from the beginning of slice. Elements are taken until the predicate returns false.

func Union[S ~[]T, T comparable](slices ...S) S

Union creates a new slice, in order, of unique values of all the given slices. Uses == for equality checks.

func UnionBy[S ~[]T, T any, U comparable](iteratee func(T) U, slices ...S) S

UnionBy creates a new slice, in order, of unique values of all the given slices. Uses the result of the given iteratee to check equality.

func UnionWith[S ~[]T, T any](comparator func(T, T) bool, sliceList ...S) S

UnionWith creates a new slice, in order, of unique values of all the given slices. Uses the given comparator to check equality between elements.

func Uniq[S ~[]T, T comparable](slice S) S

Uniq returns a new slice, in order, with no duplicates, with only the first occurrence of each element kept. Comparison is performed with ==.

func UniqBy[S ~[]T, T any, U comparable](iteratee func(T) U, slice S) S

UniqBy returns a new slice, in order, with no duplicates, with only the first occurrence of each element kept. Comparison is performed with == on the result of passing each element through the given iteratee.

func UniqWith[S ~[]T, T any](comparator func(T, T) bool, slice S) S

UniqWith returns a new slice, in order, with no duplicates, with only the first occurrence of each element kept. Comparison is performed using the given comparator.

func Without[S ~[]T, T comparable](slice S, values ...T) S

Without returns a new slice without the given elements. Uses == for equality checks.

func Xor[S ~[]T, T comparable](slices ...S) S

Xor returns a new slice of unique values that is the symmetric difference (elements which are any of the sets but not in their intersection) of the given slices. The order of result values is determined by the order they occur in the slices.

func XorBy[S ~[]T, T any, U comparable](iteratee func(T) U, slices ...S) S

XorBy returns a new slice of unique values that is the symmetric difference (elements which are any of the sets but not in their intersection) of the given slices. The order of result values is determined by the order they occur in the slices. Equality is determined by passing elements through the given iteratee.

func XorWith[S ~[]T, T any](comparator func(T, T) bool, sliceList ...S) S

XorWith returns a new slice of unique values that is the symmetric difference (elements which are any of the sets but not in their intersection) of the given slices. The order of result values is determined by the order they occur in the slices. Equality is determined by passing elements to the given comparator.