Replace util.SliceXxx with slices.Xxx (#26958)

modules/util/slice.go

@@ -1,37 +1,21 @@
 // Copyright 2022 The Gitea Authors. All rights reserved.
 // SPDX-License-Identifier: MIT
 
-// Most of the functions in this file can have better implementations with "golang.org/x/exp/slices".
-// However, "golang.org/x/exp" is experimental and unreliable, we shouldn't use it.
-// So lets waiting for the "slices" has be promoted to the main repository one day.
-
 package util
 
-import "strings"
-
-// SliceContains returns true if the target exists in the slice.
-func SliceContains[T comparable](slice []T, target T) bool {
-	return SliceContainsFunc(slice, func(t T) bool { return t == target })
-}
-
-// SliceContainsFunc returns true if any element in the slice satisfies the targetFunc.
-func SliceContainsFunc[T any](slice []T, targetFunc func(T) bool) bool {
-	for _, v := range slice {
-		if targetFunc(v) {
-			return true
-		}
-	}
-	return false
-}
+import (
+	"slices"
+	"strings"
+)
 
 // SliceContainsString sequential searches if string exists in slice.
 func SliceContainsString(slice []string, target string, insensitive ...bool) bool {
 	if len(insensitive) != 0 && insensitive[0] {
 		target = strings.ToLower(target)
-		return SliceContainsFunc(slice, func(t string) bool { return strings.ToLower(t) == target })
+		return slices.ContainsFunc(slice, func(t string) bool { return strings.ToLower(t) == target })
 	}
 
-	return SliceContains(slice, target)
+	return slices.Contains(slice, target)
 }
 
 // SliceSortedEqual returns true if the two slices will be equal when they get sorted.
@@ -57,34 +41,7 @@ func SliceSortedEqual[T comparable](s1, s2 []T) bool {
 	return true
 }
 
-// SliceEqual returns true if the two slices are equal.
-func SliceEqual[T comparable](s1, s2 []T) bool {
-	if len(s1) != len(s2) {
-		return false
-	}
-
-	for i, v := range s1 {
-		if s2[i] != v {
-			return false
-		}
-	}
-	return true
-}
-
 // SliceRemoveAll removes all the target elements from the slice.
 func SliceRemoveAll[T comparable](slice []T, target T) []T {
-	return SliceRemoveAllFunc(slice, func(t T) bool { return t == target })
-}
-
-// SliceRemoveAllFunc removes all elements which satisfy the targetFunc from the slice.
-func SliceRemoveAllFunc[T comparable](slice []T, targetFunc func(T) bool) []T {
-	idx := 0
-	for _, v := range slice {
-		if targetFunc(v) {
-			continue
-		}
-		slice[idx] = v
-		idx++
-	}
-	return slice[:idx]
+	return slices.DeleteFunc(slice, func(t T) bool { return t == target })
 }

modules/util/slice_test.go

@@ -9,20 +9,6 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestSliceContains(t *testing.T) {
-	assert.True(t, SliceContains([]int{2, 0, 2, 3}, 2))
-	assert.True(t, SliceContains([]int{2, 0, 2, 3}, 0))
-	assert.True(t, SliceContains([]int{2, 0, 2, 3}, 3))
-
-	assert.True(t, SliceContains([]string{"2", "0", "2", "3"}, "0"))
-	assert.True(t, SliceContains([]float64{2, 0, 2, 3}, 0))
-	assert.True(t, SliceContains([]bool{false, true, false}, true))
-
-	assert.False(t, SliceContains([]int{2, 0, 2, 3}, 4))
-	assert.False(t, SliceContains([]int{}, 4))
-	assert.False(t, SliceContains(nil, 4))
-}
-
 func TestSliceContainsString(t *testing.T) {
 	assert.True(t, SliceContainsString([]string{"c", "b", "a", "b"}, "a"))
 	assert.True(t, SliceContainsString([]string{"c", "b", "a", "b"}, "b"))
@@ -54,25 +40,6 @@ func TestSliceSortedEqual(t *testing.T) {
 	assert.False(t, SliceSortedEqual([]int{2, 0, 0, 3}, []int{2, 0, 2, 3}))
 }
 
-func TestSliceEqual(t *testing.T) {
-	assert.True(t, SliceEqual([]int{2, 0, 2, 3}, []int{2, 0, 2, 3}))
-	assert.True(t, SliceEqual([]int{}, []int{}))
-	assert.True(t, SliceEqual([]int(nil), nil))
-	assert.True(t, SliceEqual([]int(nil), []int{}))
-	assert.True(t, SliceEqual([]int{}, []int{}))
-
-	assert.True(t, SliceEqual([]string{"2", "0", "2", "3"}, []string{"2", "0", "2", "3"}))
-	assert.True(t, SliceEqual([]float64{2, 0, 2, 3}, []float64{2, 0, 2, 3}))
-	assert.True(t, SliceEqual([]bool{false, true, false}, []bool{false, true, false}))
-
-	assert.False(t, SliceEqual([]int{3, 0, 2, 2}, []int{2, 0, 2, 3}))
-	assert.False(t, SliceEqual([]int{2, 0, 2}, []int{2, 0, 2, 3}))
-	assert.False(t, SliceEqual([]int{}, []int{2, 0, 2, 3}))
-	assert.False(t, SliceEqual(nil, []int{2, 0, 2, 3}))
-	assert.False(t, SliceEqual([]int{2, 0, 2, 4}, []int{2, 0, 2, 3}))
-	assert.False(t, SliceEqual([]int{2, 0, 0, 3}, []int{2, 0, 2, 3}))
-}
-
 func TestSliceRemoveAll(t *testing.T) {
 	assert.ElementsMatch(t, []int{2, 2, 3}, SliceRemoveAll([]int{2, 0, 2, 3}, 0))
 	assert.ElementsMatch(t, []int{0, 3}, SliceRemoveAll([]int{2, 0, 2, 3}, 2))