ref(comparers): prevent in-place sort

Close #4

comparers.go

@@ -10,36 +10,43 @@ func equal[T constraints.Ordered](a, b []T) bool {
 	if len(a) != len(b) {
 		return false
 	}
-	slices.Sort(a)
-	slices.Sort(b)
-	for i := range a {
-		if a[i] != b[i] {
+
+	aa := make([]T, len(a))
+	copy(aa, a)
+	slices.Sort(aa)
+
+	bb := make([]T, len(b))
+	copy(bb, b)
+	slices.Sort(bb)
+
+	for i := range aa {
+		if aa[i] != bb[i] {
 			return false
 		}
 	}
 	return true
 }
 
 // IntSliceComparer is a go-cmp comparer that doesn't care if the slices in
-// question is not sorted. Note that this will sort the slices in place.
+// question is not sorted. The slices are copies and can be safely reused.
 var IntSliceComparer = cmp.Comparer(func(a, b []int) bool {
 	return equal(a, b)
 })
 
 // Int32SliceComparer is a go-cmp comparer that doesn't care if the slices in
-// question is not sorted. Note that this will sort the slices in place.
+// question is not sorted. The slices are copies and can be safely reused.
 var Int32SliceComparer = cmp.Comparer(func(a, b []int32) bool {
 	return equal(a, b)
 })
 
 // Int64SliceComparer is a go-cmp comparer that doesn't care if the slices in
-// question is not sorted. Note that this will sort the slices in place.
+// question is not sorted. The slices are copies and can be safely reused.
 var Int64SliceComparer = cmp.Comparer(func(a, b []int64) bool {
 	return equal(a, b)
 })
 
 // StringSliceComparer is a go-cmp comparer that doesn't care if the slices in
-// question is not sorted. Note that this will sort the slices in place.
+// question is not sorted. The slices are copies and can be safely reused.
 var StringSliceComparer = cmp.Comparer(func(a, b []string) bool {
 	return equal(a, b)
 })

comparers_test.go

@@ -28,6 +28,11 @@ func testComparerIntSliceComparer(t *testing.T) {
 	assert.NotEmpty(t, cmp.Diff(a, b, testament.IntSliceComparer))
 	assert.Empty(t, cmp.Diff(a, a, testament.IntSliceComparer))
 
+	a = []int{3, 1, 2}
+	b = []int{3, 1, 2}
+	cmp.Diff(a, b, testament.IntSliceComparer)
+	assert.Equal(t, []int{3, 1, 2}, b)
+
 	f := func(a []int) bool {
 		b := make([]int, len(a))
 		copy(b, a)
@@ -51,6 +56,11 @@ func testComparerInt32SliceComparer(t *testing.T) {
 	assert.NotEmpty(t, cmp.Diff(a, b, testament.Int32SliceComparer))
 	assert.Empty(t, cmp.Diff(a, a, testament.Int32SliceComparer))
 
+	a = []int32{3, 1, 2}
+	b = []int32{3, 1, 2}
+	cmp.Diff(a, b, testament.IntSliceComparer)
+	assert.Equal(t, []int32{3, 1, 2}, b)
+
 	f := func(a []int32) bool {
 		b := make([]int32, len(a))
 		copy(b, a)
@@ -74,6 +84,11 @@ func testComparerInt64SliceComparer(t *testing.T) {
 	assert.NotEmpty(t, cmp.Diff(a, b, testament.Int64SliceComparer))
 	assert.Empty(t, cmp.Diff(a, a, testament.Int64SliceComparer))
 
+	a = []int64{3, 1, 2}
+	b = []int64{3, 1, 2}
+	cmp.Diff(a, b, testament.IntSliceComparer)
+	assert.Equal(t, []int64{3, 1, 2}, b)
+
 	f := func(a []int64) bool {
 		b := make([]int64, len(a))
 		copy(b, a)
@@ -97,6 +112,11 @@ func testComparerStringSliceComparer(t *testing.T) {
 	assert.NotEmpty(t, cmp.Diff(a, b, testament.StringSliceComparer))
 	assert.Empty(t, cmp.Diff(a, a, testament.StringSliceComparer))
 
+	a = []string{"d", "a", "b"}
+	b = []string{"d", "a", "b"}
+	cmp.Diff(a, b, testament.IntSliceComparer)
+	assert.Equal(t, []string{"d", "a", "b"}, b)
+
 	f := func(a []string) bool {
 		b := make([]string, len(a))
 		copy(b, a)