coder/coderd/util/slice/slice.go

package slice

import (
	"golang.org/x/exp/constraints"
)

// List is a helper function to reduce boilerplate when converting slices of
// database types to slices of codersdk types.
// Only works if the function takes a single argument.
func List[F any, T any](list []F, convert func(F) T) []T {
	return ListLazy(convert)(list)
}

// ListLazy returns the converter function for a list, but does not eval
// the input. Helpful for combining the Map and the List functions.
func ListLazy[F any, T any](convert func(F) T) func(list []F) []T {
	return func(list []F) []T {
		into := make([]T, 0, len(list))
		for _, item := range list {
			into = append(into, convert(item))
		}
		return into
	}
}

// ToStrings works for any type where the base type is a string.
func ToStrings[T ~string](a []T) []string {
	tmp := make([]string, 0, len(a))
	for _, v := range a {
		tmp = append(tmp, string(v))
	}
	return tmp
}

func StringEnums[E ~string](a []string) []E {
	if a == nil {
		return nil
	}
	tmp := make([]E, 0, len(a))
	for _, v := range a {
		tmp = append(tmp, E(v))
	}
	return tmp
}

// Omit creates a new slice with the arguments omitted from the list.
func Omit[T comparable](a []T, omits ...T) []T {
	tmp := make([]T, 0, len(a))
	for _, v := range a {
		if Contains(omits, v) {
			continue
		}
		tmp = append(tmp, v)
	}
	return tmp
}

// SameElements returns true if the 2 lists have the same elements in any
// order.
func SameElements[T comparable](a []T, b []T) bool {
	if len(a) != len(b) {
		return false
	}

	for _, element := range a {
		if !Contains(b, element) {
			return false
		}
	}
	return true
}

func ContainsCompare[T any](haystack []T, needle T, equal func(a, b T) bool) bool {
	for _, hay := range haystack {
		if equal(needle, hay) {
			return true
		}
	}
	return false
}

func Contains[T comparable](haystack []T, needle T) bool {
	return ContainsCompare(haystack, needle, func(a, b T) bool {
		return a == b
	})
}

func CountMatchingPairs[A, B any](a []A, b []B, match func(A, B) bool) int {
	count := 0
	for _, a := range a {
		for _, b := range b {
			if match(a, b) {
				count++
				break
			}
		}
	}
	return count
}

// Find returns the first element that satisfies the condition.
func Find[T any](haystack []T, cond func(T) bool) (T, bool) {
	for _, hay := range haystack {
		if cond(hay) {
			return hay, true
		}
	}
	var empty T
	return empty, false
}

// Filter returns all elements that satisfy the condition.
func Filter[T any](haystack []T, cond func(T) bool) []T {
	out := make([]T, 0, len(haystack))
	for _, hay := range haystack {
		if cond(hay) {
			out = append(out, hay)
		}
	}
	return out
}

// Overlap returns if the 2 sets have any overlap (element(s) in common)
func Overlap[T comparable](a []T, b []T) bool {
	return OverlapCompare(a, b, func(a, b T) bool {
		return a == b
	})
}

func UniqueFunc[T any](a []T, equal func(a, b T) bool) []T {
	cpy := make([]T, 0, len(a))

	for _, v := range a {
		if ContainsCompare(cpy, v, equal) {
			continue
		}

		cpy = append(cpy, v)
	}

	return cpy
}

// Unique returns a new slice with all duplicate elements removed.
func Unique[T comparable](a []T) []T {
	cpy := make([]T, 0, len(a))
	seen := make(map[T]struct{}, len(a))

	for _, v := range a {
		if _, ok := seen[v]; ok {
			continue
		}

		seen[v] = struct{}{}
		cpy = append(cpy, v)
	}

	return cpy
}

func OverlapCompare[T any](a []T, b []T, equal func(a, b T) bool) bool {
	// For each element in b, if at least 1 is contained in 'a',
	// return true.
	for _, element := range b {
		if ContainsCompare(a, element, equal) {
			return true
		}
	}
	return false
}

// New is a convenience method for creating []T.
func New[T any](items ...T) []T {
	return items
}

func Ascending[T constraints.Ordered](a, b T) int {
	if a < b {
		return -1
	} else if a == b {
		return 0
	}
	return 1
}

func Descending[T constraints.Ordered](a, b T) int {
	return -Ascending[T](a, b)
}

// SymmetricDifference returns the elements that need to be added and removed
// to get from set 'a' to set 'b'. Note that duplicates are ignored in sets.
// In classical set theory notation, SymmetricDifference returns
// all elements of {add} and {remove} together. It is more useful to
// return them as their own slices.
// Notation: A Δ B = (A\B) ∪ (B\A)
// Example:
//
//	a := []int{1, 3, 4}
//	b := []int{1, 2, 2, 2}
//	add, remove := SymmetricDifference(a, b)
//	fmt.Println(add)    // [2]
//	fmt.Println(remove) // [3, 4]
func SymmetricDifference[T comparable](a, b []T) (add []T, remove []T) {
	f := func(a, b T) bool { return a == b }
	return SymmetricDifferenceFunc(a, b, f)
}

func SymmetricDifferenceFunc[T any](a, b []T, equal func(a, b T) bool) (add []T, remove []T) {
	// Ignore all duplicates
	a, b = UniqueFunc(a, equal), UniqueFunc(b, equal)
	return DifferenceFunc(b, a, equal), DifferenceFunc(a, b, equal)
}

func DifferenceFunc[T any](a []T, b []T, equal func(a, b T) bool) []T {
	tmp := make([]T, 0, len(a))
	for _, v := range a {
		if !ContainsCompare(b, v, equal) {
			tmp = append(tmp, v)
		}
	}
	return tmp
}

func CountConsecutive[T comparable](needle T, haystack ...T) int {
	maxLength := 0
	curLength := 0

	for _, v := range haystack {
		if v == needle {
			curLength++
		} else {
			maxLength = max(maxLength, curLength)
			curLength = 0
		}
	}

	return max(maxLength, curLength)
}

// Convert converts a slice of type F to a slice of type T using the provided function f.
func Convert[F any, T any](a []F, f func(F) T) []T {
	if a == nil {
		return []T{}
	}

	tmp := make([]T, 0, len(a))
	for _, v := range a {
		tmp = append(tmp, f(v))
	}
	return tmp
}

func ToMapFunc[T any, K comparable, V any](a []T, cnv func(t T) (K, V)) map[K]V {
	m := make(map[K]V, len(a))

	for i := range a {
		k, v := cnv(a[i])
		m[k] = v
	}
	return m
}