Moved stuff, added Contains to sliceutils

sliceutils/sliceUtils.go

@@ -0,0 +1,82 @@
+package sliceutils
+
+// MapS applies a given function to every element of a slice.
+// The return type may be different from the initial type of the slice.
+func Map[T any, M any](arr []T, apply func(T) M) []M {
+	n := make([]M, len(arr))
+	for i, e := range arr {
+		n[i] = apply(e)
+	}
+	return n
+}
+
+// Filter filters a slice using a given function.
+// If the filter function returns true, the element stays, otherwise it gets removed.
+func Filter[T any](arr []T, filter func(T) bool) []T {
+	n := make([]T, 0)
+	for _, e := range arr {
+		if filter(e) {
+			n = append(n, e)
+		}
+	}
+	return n
+}
+
+// RemoveDuplicate removes all duplicates inside a slice.
+func RemoveDuplicate[T comparable](sliceList []T) []T {
+	allKeys := make(map[T]bool)
+	list := []T{}
+	for _, item := range sliceList {
+		if _, value := allKeys[item]; !value {
+			allKeys[item] = true
+			list = append(list, item)
+		}
+	}
+	return list
+}
+
+// Reverse reverses a given slice.
+func Reverse[E any](s []E) {
+	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
+		s[i], s[j] = s[j], s[i]
+	}
+}
+
+// CompareOrdered compares two slices for both element equality and element order.
+func CompareOrdered[T comparable](a, b []T) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i, v := range a {
+		if b[i] != v {
+			return false
+		}
+	}
+	return true
+}
+
+// CompareUnorderedS compares two slices for element equality.
+// The order of those elements does not matter.
+func CompareUnordered[T comparable](a, b []T) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	hits := 0
+	for _, v := range a {
+		for _, o := range b {
+			if o == v {
+				hits += 1
+			}
+		}
+	}
+	return hits == len(a)
+}
+
+func Contains[T comparable](a []T, b T) bool {
+	for _, v := range a {
+		if v == b {
+			return true
+		}
+	}
+	return false
+}