feat: add ContainBy function

docs/slice.md

@@ -24,6 +24,7 @@ import (
 
 -   [AppendIfAbsent](#AppendIfAbsent)
 -   [Contain](#Contain)
+-   [ContainBy](#ContainBy)
 -   [ContainSubSlice](#ContainSubSlice)
 -   [Chunk](#Chunk)
 -   [Compact](#Compact)
@@ -56,6 +57,8 @@ import (
 -   [IndexOf](#IndexOf)
 -   [LastIndexOf](#LastIndexOf)
 -   [Map](#Map)
+-   [FilterMap](#FilterMap)
+-   [FlatMap](#FlatMap)
 -   [Merge](#Merge)
 -   [Reverse](#Reverse)
 -   [Reduce](#Reduce)
@@ -149,6 +152,51 @@ func main() {
 }
 ```
 
+### <span id="ContainBy">ContainBy</span>
+
+<p>returns true if predicate function return true.</p>
+
+<b>Signature:</b>
+
+```go
+func ContainBy[T any](slice []T, predicate func(item T) bool) bool
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    type foo struct {
+		A string
+		B int
+	}
+
+	array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}}
+	result1 := slice.ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 })
+	result2 := slice.ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 })
+
+	array2 := []string{"a", "b", "c"}
+	result3 := slice.ContainBy(array2, func(t string) bool { return t == "a" })
+	result4 := slice.ContainBy(array2, func(t string) bool { return t == "d" })
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// true
+	// false
+	// true
+	// false
+}
+```
+
 ### <span id="ContainSubSlice">ContainSubSlice</span>
 
 <p>Check if the slice contain subslice or not.</p>
@@ -1252,6 +1300,76 @@ func main() {
 }
 ```
 
+### <span id="FilterMap">FilterMap</span>
+
+<p>Returns a slice which apply both filtering and mapping to the given slice. iteratee callback function should returntwo values: 1, mapping result. 2, whether the result element should be included or not.</p>
+
+<b>Signature:</b>
+
+```go
+func FilterMap[T any, U any](slice []T, iteratee func(index int, item T) (U, bool)) []U
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+	getEvenNumStr := func(i, num int) (string, bool) {
+		if num%2 == 0 {
+			return strconv.FormatInt(int64(num), 10), true
+		}
+		return "", false
+	}
+
+	result := slice.FilterMap(nums, getEvenNumStr)
+
+	fmt.Printf("%#v", result)
+
+	// Output:
+	// []string{"2", "4"}
+}
+```
+
+### <span id="FlatMap">FlatMap</span>
+
+<p>Manipulates a slice and transforms and flattens it to a slice of another type.</p>
+
+<b>Signature:</b>
+
+```go
+func FlatMap[T any, U any](slice []T, iteratee func(index int, item T) []U) []U
+```
+
+<b>Example:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4}
+
+	result := slice.FlatMap(nums, func(i int, num int) []string {
+		s := "hi-" + strconv.FormatInt(int64(num), 10)
+		return []string{s}
+	})
+
+	fmt.Printf("%#v", result)
+
+	// Output:
+	// []string{"hi-1", "hi-2", "hi-3", "hi-4"}
+}
+```
+
 ### <span id="Merge">Merge</span>
 
 <p>Merge all given slices into one slice.</p>
@@ -1467,8 +1585,8 @@ func main() {
     nums := []int{1, 2, 3, 4, 5}
     result := slice.Shuffle(nums)
 
-    fmt.Println(res) 
-    
+    fmt.Println(res)
+
     // Output:
     // [3 1 5 4 2] (random order)
 }

docs/slice_zh-CN.md

@@ -24,6 +24,7 @@ import (
 
 -   [AppendIfAbsent](#AppendIfAbsent)
 -   [Contain](#Contain)
+-   [ContainBy](#ContainBy)
 -   [ContainSubSlice](#ContainSubSlice)
 -   [Chunk](#Chunk)
 -   [Compact](#Compact)
@@ -56,6 +57,8 @@ import (
 -   [IndexOf](#IndexOf)
 -   [LastIndexOf](#LastIndexOf)
 -   [Map](#Map)
+-   [FilterMap](#FilterMap)
+-   [FlatMap](#FlatMap)
 -   [Merge](#Merge)
 -   [Reverse](#Reverse)
 -   [Reduce](#Reduce)
@@ -149,6 +152,51 @@ func main() {
 }
 ```
 
+### <span id="ContainBy">ContainBy</span>
+
+<p>根据predicate函数判断切片是否包含某个值。</p>
+
+<b>函数签名:</b>
+
+```go
+func ContainBy[T any](slice []T, predicate func(item T) bool) bool
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    type foo struct {
+		A string
+		B int
+	}
+
+	array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}}
+	result1 := slice.ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 })
+	result2 := slice.ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 })
+
+	array2 := []string{"a", "b", "c"}
+	result3 := slice.ContainBy(array2, func(t string) bool { return t == "a" })
+	result4 := slice.ContainBy(array2, func(t string) bool { return t == "d" })
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// true
+	// false
+	// true
+	// false
+}
+```
+
 ### <span id="ContainSubSlice">ContainSubSlice</span>
 
 <p>判断slice是否包含subslice</p>
@@ -1254,6 +1302,76 @@ func main() {
 }
 ```
 
+### <span id="FilterMap">FilterMap</span>
+
+<p>返回一个将filter和map操作应用于给定切片的切片。 iteratee回调函数应该返回两个值：1，结果值。2，结果值是否应该被包含在返回的切片中。</p>
+
+<b>函数签名:</b>
+
+```go
+func FilterMap[T any, U any](slice []T, iteratee func(index int, item T) (U, bool)) []U
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+	getEvenNumStr := func(i, num int) (string, bool) {
+		if num%2 == 0 {
+			return strconv.FormatInt(int64(num), 10), true
+		}
+		return "", false
+	}
+
+	result := slice.FilterMap(nums, getEvenNumStr)
+
+	fmt.Printf("%#v", result)
+
+	// Output:
+	// []string{"2", "4"}
+}
+```
+
+### <span id="FlatMap">FlatMap</span>
+
+<p>将切片转换为其它类型切片。</p>
+
+<b>函数签名:</b>
+
+```go
+func FlatMap[T any, U any](slice []T, iteratee func(index int, item T) []U) []U
+```
+
+<b>示例:</b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4}
+
+	result := slice.FlatMap(nums, func(i int, num int) []string {
+		s := "hi-" + strconv.FormatInt(int64(num), 10)
+		return []string{s}
+	})
+
+	fmt.Printf("%#v", result)
+
+	// Output:
+	// []string{"hi-1", "hi-2", "hi-3", "hi-4"}
+}
+```
+
 ### <span id="Merge">Merge</span>
 
 <p>合并多个切片（不会消除重复元素).</p>

slice/slice.go

@@ -22,7 +22,7 @@ var (
 )
 
 // Contain check if the target value is in the slice or not.
-// Play: https://go.dev/play/p/_454yEHcNjf
+// Play: todo
 func Contain[T comparable](slice []T, target T) bool {
 	for _, item := range slice {
 		if item == target {
@@ -33,6 +33,17 @@ func Contain[T comparable](slice []T, target T) bool {
 	return false
 }
 
+// ContainBy returns true if predicate function return true.
+func ContainBy[T any](slice []T, predicate func(item T) bool) bool {
+	for _, item := range slice {
+		if predicate(item) {
+			return true
+		}
+	}
+
+	return false
+}
+
 // ContainSubSlice check if the slice contain a given subslice or not.
 // Play: https://go.dev/play/p/bcuQ3UT6Sev
 func ContainSubSlice[T comparable](slice, subSlice []T) bool {
@@ -421,6 +432,35 @@ func Map[T any, U any](slice []T, iteratee func(index int, item T) U) []U {
 	return result
 }
 
+// FilterMap returns a slice which apply both filtering and mapping to the given slice.
+// iteratee callback function should returntwo values:
+// 1, mapping result.
+// 2, whether the result element should be included or not
+// Play: todo
+func FilterMap[T any, U any](slice []T, iteratee func(index int, item T) (U, bool)) []U {
+	result := []U{}
+
+	for i, v := range slice {
+		if a, ok := iteratee(i, v); ok {
+			result = append(result, a)
+		}
+	}
+
+	return result
+}
+
+// FlatMap manipulates a slice and transforms and flattens it to a slice of another type.
+// Play: todo
+func FlatMap[T any, U any](slice []T, iteratee func(index int, item T) []U) []U {
+	result := make([]U, 0, len(slice))
+
+	for i, v := range slice {
+		result = append(result, iteratee(i, v)...)
+	}
+
+	return result
+}
+
 // Reduce creates an slice of values by running each element of slice thru iteratee function.
 // Play: https://go.dev/play/p/_RfXJJWIsIm
 func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initial T) T {

slice/slice_example_test.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"math"
 	"reflect"
+	"strconv"
 )
 
 func ExampleContain() {
@@ -18,6 +19,32 @@ func ExampleContain() {
 	// false
 }
 
+func ExampleContainBy() {
+	type foo struct {
+		A string
+		B int
+	}
+
+	array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}}
+	result1 := ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 })
+	result2 := ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 })
+
+	array2 := []string{"a", "b", "c"}
+	result3 := ContainBy(array2, func(t string) bool { return t == "a" })
+	result4 := ContainBy(array2, func(t string) bool { return t == "d" })
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// true
+	// false
+	// true
+	// false
+}
+
 func ExampleContainSubSlice() {
 	result1 := ContainSubSlice([]string{"a", "b", "c"}, []string{"a", "b"})
 	result2 := ContainSubSlice([]string{"a", "b", "c"}, []string{"a", "d"})
@@ -367,6 +394,38 @@ func ExampleMap() {
 	// [2 3 4]
 }
 
+func ExampleFilterMap() {
+	nums := []int{1, 2, 3, 4, 5}
+
+	getEvenNumStr := func(i, num int) (string, bool) {
+		if num%2 == 0 {
+			return strconv.FormatInt(int64(num), 10), true
+		}
+		return "", false
+	}
+
+	result := FilterMap(nums, getEvenNumStr)
+
+	fmt.Printf("%#v", result)
+
+	// Output:
+	// []string{"2", "4"}
+}
+
+func ExampleFlatMap() {
+	nums := []int{1, 2, 3, 4}
+
+	result := FlatMap(nums, func(i int, num int) []string {
+		s := "hi-" + strconv.FormatInt(int64(num), 10)
+		return []string{s}
+	})
+
+	fmt.Printf("%#v", result)
+
+	// Output:
+	// []string{"hi-1", "hi-2", "hi-3", "hi-4"}
+}
+
 func ExampleReduce() {
 	nums := []int{1, 2, 3}
 

slice/slice_test.go

@@ -3,6 +3,7 @@ package slice
 import (
 	"fmt"
 	"math"
+	"strconv"
 	"testing"
 
 	"github.com/duke-git/lancet/v2/internal"
@@ -19,6 +20,28 @@ func TestContain(t *testing.T) {
 	assert.Equal(true, Contain([]int{1, 2, 3}, 1))
 }
 
+func TestContainBy(t *testing.T) {
+	assert := internal.NewAssert(t, "TestContainBy")
+
+	type foo struct {
+		A string
+		B int
+	}
+
+	array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}}
+	result1 := ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 })
+	result2 := ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 })
+
+	array2 := []string{"a", "b", "c"}
+	result3 := ContainBy(array2, func(t string) bool { return t == "a" })
+	result4 := ContainBy(array2, func(t string) bool { return t == "d" })
+
+	assert.Equal(true, result1)
+	assert.Equal(false, result2)
+	assert.Equal(true, result3)
+	assert.Equal(false, result4)
+}
+
 func TestContainSubSlice(t *testing.T) {
 	assert := internal.NewAssert(t, "TestContainSubSlice")
 	assert.Equal(true, ContainSubSlice([]string{"a", "a", "b", "c"}, []string{"a", "a"}))
@@ -315,6 +338,36 @@ func TestMap(t *testing.T) {
 	assert.Equal(studentsOfAdd10Aage, Map(students, mapFunc))
 }
 
+func TestFilterMap(t *testing.T) {
+	assert := internal.NewAssert(t, "TestFilterMap")
+
+	nums := []int{1, 2, 3, 4, 5}
+
+	getEvenNumStr := func(i, num int) (string, bool) {
+		if num%2 == 0 {
+			return strconv.FormatInt(int64(num), 10), true
+		}
+		return "", false
+	}
+
+	result := FilterMap(nums, getEvenNumStr)
+
+	assert.Equal([]string{"2", "4"}, result)
+}
+
+func TestFlatMap(t *testing.T) {
+	assert := internal.NewAssert(t, "TestFlatMap")
+
+	nums := []int{1, 2, 3, 4}
+
+	result := FlatMap(nums, func(i int, num int) []string {
+		s := "hi-" + strconv.FormatInt(int64(num), 10)
+		return []string{s}
+	})
+
+	assert.Equal([]string{"hi-1", "hi-2", "hi-3", "hi-4"}, result)
+}
+
 func TestReduce(t *testing.T) {
 	cases := [][]int{
 		{},