refactor: introduce clone helper for slice copying

- Add clone() function that returns a shallow copy without preserving nilness
	is guaranteed to be inlined by the compiler (verified with -gcflags=-m)
  (separate from Clone() which preserves nilness - library convention is to return empty slice)
- Simplify Clone() to delegate to clone() for non-nil collections
- Refactor Chunk, Sliding, Drop, DropRight, DropWhile, DropRightWhile, Take, TakeWhile, Replace, Trim to use clone()
- Update SamplesBy and debounce.reset to use clone()
- Replace make(Slice, 0) with Slice{} for return statements

Also
- Some redundant checks have been removed in Take, NthOrEmpty
- Simplify TrimPrefix and TrimSuffix loops
- Micro-optimize Replace() by reordering condition to short-circuit on n != 0 first
  (TODO: consider adding early break when n reaches 0)

Author: d-enk

find.go

@@ -671,11 +671,7 @@ func NthOr[T any, N constraints.Integer](collection []T, nth N, fallback T) T {
 // If `nth` is out of slice bounds, it returns the zero value (empty value) for that type.
 // Play: https://go.dev/play/p/sHoh88KWt6B
 func NthOrEmpty[T any, N constraints.Integer](collection []T, nth N) T {
-	value, err := Nth(collection, nth)
-	if err != nil {
-		var zeroValue T
-		return zeroValue
-	}
+	value, _ := Nth(collection, nth)
 	return value
 }
 
@@ -686,8 +682,7 @@ type randomIntGenerator func(n int) int
 // Sample returns a random item from collection.
 // Play: https://go.dev/play/p/vCcSJbh5s6l
 func Sample[T any](collection []T) T {
-	result := SampleBy(collection, xrand.IntN)
-	return result
+	return SampleBy(collection, xrand.IntN)
 }
 
 // SampleBy returns a random item from collection, using randomIntGenerator as the random index generator.
@@ -715,7 +710,7 @@ func SamplesBy[T any, Slice ~[]T](collection Slice, count int, randomIntGenerato
 		count = size
 	}
 
-	cOpy := append(Slice{}, collection...)
+	cOpy := clone(collection)
 
 	results := make(Slice, count)
 

retry.go

@@ -30,7 +30,7 @@ func (d *debounce) reset() {
 	d.timer = time.AfterFunc(d.after, func() {
 		// We need to lock the mutex here to avoid race conditions with 2 concurrent calls to reset()
 		d.mu.Lock()
-		callbacks := append([]func(){}, d.callbacks...)
+		callbacks := clone(d.callbacks)
 		d.mu.Unlock()
 
 		for i := range callbacks {

slice.go

@@ -224,9 +224,7 @@ func Chunk[T any, Slice ~[]T](collection Slice, size int) []Slice {
 		}
 
 		// Copy chunk in a new slice, to prevent memory leak and free memory from initial collection.
-		newSlice := make(Slice, last-i*size)
-		copy(newSlice, collection[i*size:last])
-		result = append(result, newSlice)
+		result = append(result, clone(collection[i*size:last]))
 	}
 
 	return result
@@ -312,9 +310,7 @@ func Sliding[T any, Slice ~[]T](collection Slice, size, step int) []Slice {
 	result := make([]Slice, 0, n/step+1)
 
 	for i := 0; i <= n; i += step {
-		window := make(Slice, size)
-		copy(window, collection[i:i+size])
-		result = append(result, window)
+		result = append(result, clone(collection[i:i+size]))
 	}
 
 	return result
@@ -517,12 +513,10 @@ func Drop[T any, Slice ~[]T](collection Slice, n int) Slice {
 	}
 
 	if len(collection) <= n {
-		return make(Slice, 0)
+		return Slice{}
 	}
 
-	result := make(Slice, 0, len(collection)-n)
-
-	return append(result, collection[n:]...)
+	return clone(collection[n:])
 }
 
 // DropRight drops n elements from the end of a slice.
@@ -536,8 +530,7 @@ func DropRight[T any, Slice ~[]T](collection Slice, n int) Slice {
 		return Slice{}
 	}
 
-	result := make(Slice, 0, len(collection)-n)
-	return append(result, collection[:len(collection)-n]...)
+	return clone(collection[:len(collection)-n])
 }
 
 // DropWhile drops elements from the beginning of a slice while the predicate returns true.
@@ -550,8 +543,7 @@ func DropWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool)
 		}
 	}
 
-	result := make(Slice, 0, len(collection)-i)
-	return append(result, collection[i:]...)
+	return clone(collection[i:])
 }
 
 // DropRightWhile drops elements from the end of a slice while the predicate returns true.
@@ -564,8 +556,7 @@ func DropRightWhile[T any, Slice ~[]T](collection Slice, predicate func(item T)
 		}
 	}
 
-	result := make(Slice, 0, i+1)
-	return append(result, collection[:i+1]...)
+	return clone(collection[:i+1])
 }
 
 // Take takes the first n elements from a slice.
@@ -574,24 +565,11 @@ func Take[T any, Slice ~[]T](collection Slice, n int) Slice {
 		panic("lo.Take: n must not be negative")
 	}
 
-	if n == 0 {
-		return make(Slice, 0)
-	}
-
-	size := len(collection)
-	if size == 0 {
-		return make(Slice, 0)
+	if len(collection) > n {
+		collection = collection[:n]
 	}
 
-	if n >= size {
-		result := make(Slice, size)
-		copy(result, collection)
-		return result
-	}
-
-	result := make(Slice, n)
-	copy(result, collection)
-	return result
+	return clone(collection)
 }
 
 // TakeWhile takes elements from the beginning of a slice while the predicate returns true.
@@ -603,9 +581,7 @@ func TakeWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool)
 		}
 	}
 
-	result := make(Slice, i)
-	copy(result, collection[:i])
-	return result
+	return clone(collection[:i])
 }
 
 // DropByIndex drops elements from a slice by the index.
@@ -614,7 +590,7 @@ func TakeWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool)
 func DropByIndex[T any, Slice ~[]T](collection Slice, indexes ...int) Slice {
 	initialSize := len(collection)
 	if initialSize == 0 {
-		return make(Slice, 0)
+		return Slice{}
 	}
 
 	for i := range indexes {
@@ -648,7 +624,7 @@ func TakeFilter[T any, Slice ~[]T](collection Slice, n int, predicate func(item
 	}
 
 	if n == 0 {
-		return make(Slice, 0)
+		return Slice{}
 	}
 
 	result := make(Slice, 0, n)
@@ -822,11 +798,10 @@ func Slice[T any, Slice ~[]T](collection Slice, start, end int) Slice {
 // Replace returns a copy of the slice with the first n non-overlapping instances of old replaced by new.
 // Play: https://go.dev/play/p/XfPzmf9gql6
 func Replace[T comparable, Slice ~[]T](collection Slice, old, nEw T, n int) Slice {
-	result := make(Slice, len(collection))
-	copy(result, collection)
+	result := clone(collection)
 
 	for i := range result {
-		if result[i] == old && n != 0 {
+		if n != 0 && result[i] == old {
 			result[i] = nEw
 			n--
 		}
@@ -850,6 +825,12 @@ func Clone[T any, Slice ~[]T](collection Slice) Slice {
 	if collection == nil {
 		return nil
 	}
+
+	return clone(collection)
+}
+
+// clone returns a shallow copy of the collection without preserving nilness.
+func clone[T any, Slice ~[]T](collection Slice) Slice {
 	// Avoid s[:0:0] as it leads to unwanted liveness when cloning a
 	// zero-length slice of a large array; see https://go.dev/issue/68488.
 	return append(Slice{}, collection...)
@@ -934,7 +915,7 @@ func Splice[T any, Slice ~[]T](collection Slice, i int, elements ...T) Slice {
 // Play: https://go.dev/play/p/GiL3qhpIP3f
 func Cut[T comparable, Slice ~[]T](collection, separator Slice) (before, after Slice, found bool) {
 	if len(separator) == 0 {
-		return make(Slice, 0), collection, true
+		return Slice{}, collection, true
 	}
 
 	for i := 0; i+len(separator) <= len(collection); i++ {
@@ -950,7 +931,7 @@ func Cut[T comparable, Slice ~[]T](collection, separator Slice) (before, after S
 		}
 	}
 
-	return collection, make(Slice, 0), false
+	return collection, Slice{}, false
 }
 
 // CutPrefix returns collection without the provided leading prefix []T
@@ -1020,8 +1001,7 @@ func Trim[T comparable, Slice ~[]T](collection, cutset Slice) Slice {
 		}
 	}
 
-	result := make(Slice, 0, j+1-i)
-	return append(result, collection[i:j+1]...)
+	return clone(collection[i : j+1])
 }
 
 // TrimLeft removes all the leading cutset from the collection.
@@ -1042,12 +1022,11 @@ func TrimPrefix[T comparable, Slice ~[]T](collection, prefix Slice) Slice {
 		return collection
 	}
 
-	for {
-		if !HasPrefix(collection, prefix) {
-			return collection
-		}
+	for HasPrefix(collection, prefix) {
 		collection = collection[len(prefix):]
 	}
+
+	return collection
 }
 
 // TrimRight removes all the trailing cutset from the collection.
@@ -1068,10 +1047,9 @@ func TrimSuffix[T comparable, Slice ~[]T](collection, suffix Slice) Slice {
 		return collection
 	}
 
-	for {
-		if !HasSuffix(collection, suffix) {
-			return collection
-		}
+	for HasSuffix(collection, suffix) {
 		collection = collection[:len(collection)-len(suffix)]
 	}
+
+	return collection
 }

slice_test.go

@@ -1525,6 +1525,12 @@ func TestCutSuccess(t *testing.T) {
 	is.True(result)
 	is.Equal([]string{}, actualLeft)
 	is.Equal([]string{"b"}, actualRight)
+
+	// case 8
+	actualLeft, actualRight, result = Cut([]string{"a", "b"}, []string{})
+	is.True(result)
+	is.Equal([]string{}, actualLeft)
+	is.Equal([]string{"a", "b"}, actualRight)
 }
 
 func TestCutFail(t *testing.T) {