Merge pull request #28 from Azer0s/feature/drop

Add Drop, DropRight, DropWhile and DropRightWhile

README.md

@@ -65,6 +65,10 @@ Supported helpers for slices:
 - Fill
 - Repeat
 - ToMap
+- Drop
+- DropRight
+- DropWhile
+- DropRightWhile
 
 Supported helpers for maps:
 
@@ -411,6 +415,46 @@ m := lo.ToMap[int, string]([]string{"a", "aa", "aaa"}, func(str string) int {
 // map[int]string{1: "a", 2: "aa", 3: "aaa"}
 ```
 
+### Drop
+
+Drops n elements from the beginning of a slice or array.
+
+```go
+l := lo.Drop[int]([]int{0, 1, 2, 3, 4, 5}, 2)
+// []int{2, 3, 4, 5}
+```
+
+### DropRight
+
+Drops n elements from the end of a slice or array.
+
+```go
+l := lo.DropRight[int]([]int{0, 1, 2, 3, 4, 5}, 2)
+// []int{0, 1, 2, 3}
+```
+
+### DropWhile
+
+Drop elements from the beginning of a slice or array while the predicate returns true.
+
+```go
+l := lo.DropWhile[string]([]string{"a", "aa", "aaa", "aa", "aa"}, func(val string) bool {
+	return len(val) <= 2
+})
+// []string{"aaa", "aa", "a"}
+```
+
+### DropRightWhile
+
+Drop elements from the end of a slice or array while the predicate returns true.
+
+```go
+l := lo.DropRightWhile[string]([]string{"a", "aa", "aaa", "aa", "aa"}, func(val string) bool {
+	return len(val) <= 2
+})
+// []string{"a", "aa", "aaa"}
+```
+
 ### Keys
 
 Creates an array of the map keys.

drop.go

@@ -0,0 +1,65 @@
+package lo
+
+//Drop drops n elements from the beginning of a slice or array.
+func Drop[T any](collection []T, n int) []T {
+	if len(collection) <= n {
+		return make([]T, 0)
+	}
+
+	result := make([]T, len(collection)-n)
+	for i := n; i < len(collection); i++ {
+		result[i-n] = collection[i]
+	}
+
+	return result
+}
+
+//DropWhile drops elements from the beginning of a slice or array while the predicate returns true.
+func DropWhile[T any](collection []T, predicate func(T) bool) []T {
+	i := 0
+	for ; i < len(collection); i++ {
+		if !predicate(collection[i]) {
+			break
+		}
+	}
+
+	result := make([]T, len(collection)-i)
+
+	for j := 0; i < len(collection); i, j = i+1, j+1 {
+		result[j] = collection[i]
+	}
+
+	return result
+}
+
+//DropRight drops n elements from the end of a slice or array.
+func DropRight[T any](collection []T, n int) []T {
+	if len(collection) <= n {
+		return make([]T, 0)
+	}
+
+	result := make([]T, len(collection)-n)
+	for i := len(collection) - 1 - n; i != 0; i-- {
+		result[i] = collection[i]
+	}
+
+	return result
+}
+
+//DropRightWhile drops elements from the end of a slice or array while the predicate returns true.
+func DropRightWhile[T any](collection []T, predicate func(T) bool) []T {
+	i := len(collection) - 1
+	for ; i >= 0; i-- {
+		if !predicate(collection[i]) {
+			break
+		}
+	}
+
+	result := make([]T, i+1)
+
+	for ; i >= 0; i-- {
+		result[i] = collection[i]
+	}
+
+	return result
+}

drop_test.go

@@ -0,0 +1,64 @@
+package lo
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestDrop(t *testing.T) {
+	is := assert.New(t)
+
+	is.Equal([]int{1, 2, 3, 4}, Drop([]int{0, 1, 2, 3, 4}, 1))
+	is.Equal([]int{2, 3, 4}, Drop([]int{0, 1, 2, 3, 4}, 2))
+	is.Equal([]int{3, 4}, Drop([]int{0, 1, 2, 3, 4}, 3))
+	is.Equal([]int{4}, Drop([]int{0, 1, 2, 3, 4}, 4))
+	is.Equal([]int{}, Drop([]int{0, 1, 2, 3, 4}, 5))
+	is.Equal([]int{}, Drop([]int{0, 1, 2, 3, 4}, 6))
+}
+
+func TestDropRight(t *testing.T) {
+	is := assert.New(t)
+
+	is.Equal([]int{0, 1, 2, 3}, DropRight([]int{0, 1, 2, 3, 4}, 1))
+	is.Equal([]int{0, 1, 2}, DropRight([]int{0, 1, 2, 3, 4}, 2))
+	is.Equal([]int{0, 1}, DropRight([]int{0, 1, 2, 3, 4}, 3))
+	is.Equal([]int{0}, DropRight([]int{0, 1, 2, 3, 4}, 4))
+	is.Equal([]int{}, DropRight([]int{0, 1, 2, 3, 4}, 5))
+	is.Equal([]int{}, DropRight([]int{0, 1, 2, 3, 4}, 6))
+}
+
+func TestDropWhile(t *testing.T) {
+	is := assert.New(t)
+
+	is.Equal([]int{4, 5, 6}, DropWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool {
+		return t != 4
+	}))
+
+	is.Equal([]int{}, DropWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool {
+		return true
+	}))
+
+	is.Equal([]int{0, 1, 2, 3, 4, 5, 6}, DropWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool {
+		return t == 10
+	}))
+}
+
+func TestDropRightWhile(t *testing.T) {
+	is := assert.New(t)
+
+	is.Equal([]int{0, 1, 2, 3}, DropRightWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool {
+		return t != 3
+	}))
+
+	is.Equal([]int{0, 1}, DropRightWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool {
+		return t != 1
+	}))
+
+	is.Equal([]int{0, 1, 2, 3, 4, 5, 6}, DropRightWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool {
+		return t == 10
+	}))
+
+	is.Equal([]int{}, DropRightWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool {
+		return t != 10
+	}))
+}