Slice: reverse and shufffle v2 (#19)

* Slice: reverse and shufffle v2

Migrate from reflection to generic form

Note: after migration, old reverse must be removed

* Suffle test: remove reflection calls

* Reverse test: change name of test

slice/slice.go

@@ -504,26 +504,22 @@ func Intersection[T comparable](slices ...[]T) []T {
 	return Unique(res)
 }
 
-// ReverseSlice return slice of element order is reversed to the given slice
-func ReverseSlice(slice interface{}) {
-	sv := sliceValue(slice)
-	swp := reflect.Swapper(sv.Interface())
-	for i, j := 0, sv.Len()-1; i < j; i, j = i+1, j-1 {
-		swp(i, j)
+// Reverse return slice of element order is reversed to the given slice
+func Reverse[T any](slice []T) {
+	for i, j := 0, len(slice)-1; i < j; i, j = i+1, j-1 {
+		slice[i], slice[j] = slice[j], slice[i]
 	}
 }
 
 // Shuffle creates an slice of shuffled values
-func Shuffle(slice interface{}) interface{} {
-	sv := sliceValue(slice)
-	length := sv.Len()
+func Shuffle[T any](slice []T) []T {
 
-	res := reflect.MakeSlice(sv.Type(), length, length)
-	for i, v := range rand.Perm(length) {
-		res.Index(i).Set(sv.Index(v))
+	res := make([]T, len(slice))
+	for i, v := range rand.Perm(len(slice)) {
+		res[i] = slice[v]
 	}
 
-	return res.Interface()
+	return res
 }
 
 // SortByField return sorted slice by field
@@ -576,11 +572,20 @@ func SortByField(slice interface{}, field string, sortType ...string) error {
 	})
 
 	if sortType[0] == "desc" {
-		ReverseSlice(slice)
+		reverseSlice(slice)
 	}
 	return nil
 }
 
+// todo remove after migration
+func reverseSlice(slice interface{}) {
+	sv := sliceValue(slice)
+	swp := reflect.Swapper(sv.Interface())
+	for i, j := 0, sv.Len()-1; i < j; i, j = i+1, j-1 {
+		swp(i, j)
+	}
+}
+
 // Without creates a slice excluding all given values
 func Without(slice interface{}, values ...interface{}) interface{} {
 	sv := sliceValue(slice)

slice/slice_test.go

@@ -1,7 +1,6 @@
 package slice
 
 import (
-	"reflect"
 	"testing"
 
 	"github.com/duke-git/lancet/internal"
@@ -398,15 +397,15 @@ func TestIntersection(t *testing.T) {
 	}
 }
 
-func TestReverseSlice(t *testing.T) {
+func TestReverse(t *testing.T) {
 	assert := internal.NewAssert(t, "TestIntersection")
 
 	s1 := []int{1, 2, 3, 4, 5}
-	ReverseSlice(s1)
+	Reverse(s1)
 	assert.Equal([]int{5, 4, 3, 2, 1}, s1)
 
 	s2 := []string{"a", "b", "c", "d", "e"}
-	ReverseSlice(s2)
+	Reverse(s2)
 	assert.Equal([]string{"e", "d", "c", "b", "a"}, s2)
 }
 
@@ -457,17 +456,5 @@ func TestShuffle(t *testing.T) {
 	res := Shuffle(s)
 	t.Log("Shuffle result: ", res)
 
-	assert.Equal(reflect.TypeOf(s), reflect.TypeOf(res))
-
-	rv := reflect.ValueOf(res)
-	assert.Equal(5, rv.Len())
-
-	assert.Equal(true, rv.Kind() == reflect.Slice)
-	assert.Equal(true, rv.Type().Elem().Kind() == reflect.Int)
-
-	// assert.Equal(true, Contain(res, 1))
-	// assert.Equal(true, Contain(res, 2))
-	// assert.Equal(true, Contain(res, 3))
-	// assert.Equal(true, Contain(res, 4))
-	// assert.Equal(true, Contain(res, 5))
+	assert.Equal(5, len(res))
 }