feat: add ConcatBy

docs/api/packages/slice.md

@@ -106,6 +106,9 @@ import (
 -   [RightPadding](#RightPadding)
 -   [LeftPadding](#LeftPadding)
 -   [Frequency](#Frequency)
+-   [JoinFunc](#JoinFunc)
+-   [ConcatBy](#ConcatBy)
+
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -2984,4 +2987,81 @@ func main() {
     // Output:
     // map[a:1 b:2 c:3]
 }
+```
+
+### <span id="JoinFunc">JoinFunc</span>
+
+<p>将切片元素用给定的分隔符连接成一个单一的字符串。</p>
+
+<b>函数签名:</b>
+
+```go
+func JoinFunc[T any](slice []T, sep string, transform func(T) T) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result := slice.JoinFunc([]string{"a", "b", "c"}, ", ", func(s string) string {
+        return strings.ToUpper(s)
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // A, B, C
+}
+```
+
+### <span id="ConcatBy">ConcatBy</span>
+
+<p>将切片中的元素连接成一个值，使用指定的分隔符和连接器函数。</p>
+
+<b>函数签名:</b>
+
+```go
+func ConcatBy[T any](slice []T, sep T, connector func(T, T) T) T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    type Person struct {
+        Name string
+        Age  int
+    }
+
+    people := []Person{
+        {Name: "Alice", Age: 30},
+        {Name: "Bob", Age: 25},
+        {Name: "Charlie", Age: 35},
+    }
+
+    sep := Person{Name: " | ", Age: 0}
+
+    personConnector := func(a, b Person) Person {
+        return Person{Name: a.Name + b.Name, Age: a.Age + b.Age}
+    }
+
+    result := slice.ConcatBy(people, sep, personConnector)
+
+    fmt.Println(result.Name)
+    fmt.Println(result.Age)
+
+    // Output:
+    // Alice | Bob | Charlie
+    // 90
+}
 ```

docs/en/api/packages/slice.md

@@ -106,6 +106,10 @@ import (
 -   [RightPadding](#RightPadding)
 -   [LeftPadding](#LeftPadding)
 -   [Frequency](#Frequency)
+-   [JoinFunc](#JoinFunc)
+-   [ConcatBy](#ConcatBy)
+
+
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -2979,4 +2983,81 @@ func main() {
     // Output:
     // map[a:1 b:2 c:3]
 }
+```
+
+### <span id="JoinFunc">JoinFunc</span>
+
+<p>Joins the slice elements into a single string with the given separator.</p>
+
+<b>Signature:</b>
+
+```go
+func JoinFunc[T any](slice []T, sep string, transform func(T) T) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    result := slice.JoinFunc([]string{"a", "b", "c"}, ", ", func(s string) string {
+        return strings.ToUpper(s)
+    })
+
+    fmt.Println(result)
+
+    // Output:
+    // A, B, C
+}
+```
+
+### <span id="ConcatBy">ConcatBy</span>
+
+<p>Concats the elements of a slice into a single value using the provided separator and connector function.</p>
+
+<b>Signature:</b>
+
+```go
+func ConcatBy[T any](slice []T, sep T, connector func(T, T) T) T
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    type Person struct {
+        Name string
+        Age  int
+    }
+
+    people := []Person{
+        {Name: "Alice", Age: 30},
+        {Name: "Bob", Age: 25},
+        {Name: "Charlie", Age: 35},
+    }
+
+    sep := Person{Name: " | ", Age: 0}
+
+    personConnector := func(a, b Person) Person {
+        return Person{Name: a.Name + b.Name, Age: a.Age + b.Age}
+    }
+
+    result := slice.ConcatBy(people, sep, personConnector)
+
+    fmt.Println(result.Name)
+    fmt.Println(result.Age)
+
+    // Output:
+    // Alice | Bob | Charlie
+    // 90
+}
 ```

slice/slice.go

@@ -1398,3 +1398,35 @@ func Frequency[T comparable](slice []T) map[T]int {
 
 	return result
 }
+
+// JoinFunc joins the slice elements into a single string with the given separator.
+// Play: todo
+func JoinFunc[T any](slice []T, sep string, transform func(T) T) string {
+	var buf strings.Builder
+	for i, v := range slice {
+		if i > 0 {
+			buf.WriteString(sep)
+		}
+		buf.WriteString(fmt.Sprint(transform(v)))
+	}
+	return buf.String()
+}
+
+// ConcatBy concats the elements of a slice into a single value using the provided separator and connector function.
+// Play: todo
+func ConcatBy[T any](slice []T, sep T, connector func(T, T) T) T {
+	var result T
+
+	if len(slice) == 0 {
+		return result
+	}
+
+	for i, v := range slice {
+		result = connector(result, v)
+		if i < len(slice)-1 {
+			result = connector(result, sep)
+		}
+	}
+
+	return result
+}

slice/slice_example_test.go

@@ -1261,3 +1261,42 @@ func ExampleFrequency() {
 	// Output:
 	// map[a:1 b:2 c:3]
 }
+
+func ExampleJoinFunc() {
+	result := JoinFunc([]string{"a", "b", "c"}, ", ", func(s string) string {
+		return strings.ToUpper(s)
+	})
+
+	fmt.Println(result)
+
+	// Output:
+	// A, B, C
+}
+
+func ExampleConcatBy() {
+	type Person struct {
+		Name string
+		Age  int
+	}
+
+	people := []Person{
+		{Name: "Alice", Age: 30},
+		{Name: "Bob", Age: 25},
+		{Name: "Charlie", Age: 35},
+	}
+
+	sep := Person{Name: " | ", Age: 0}
+
+	personConnector := func(a, b Person) Person {
+		return Person{Name: a.Name + b.Name, Age: a.Age + b.Age}
+	}
+
+	result := ConcatBy(people, sep, personConnector)
+
+	fmt.Println(result.Name)
+	fmt.Println(result.Age)
+
+	// Output:
+	// Alice | Bob | Charlie
+	// 90
+}

slice/slice_test.go

@@ -1816,3 +1816,81 @@ func TestFrequency(t *testing.T) {
 		assert.Equal(expected, result)
 	})
 }
+
+func TestJoinFunc(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestJoinFunc")
+
+	t.Run("basic case", func(t *testing.T) {
+		result := JoinFunc([]int{1, 2, 3}, ", ", func(i int) int {
+			return i * 2
+		})
+
+		expected := "2, 4, 6"
+		assert.Equal(expected, result)
+	})
+
+	t.Run("empty slice", func(t *testing.T) {
+		result := JoinFunc([]int{}, ", ", func(i int) int {
+			return i * 2
+		})
+
+		assert.Equal("", result)
+	})
+
+	t.Run("single element slice", func(t *testing.T) {
+		result := JoinFunc([]int{1}, ", ", func(i int) int {
+			return i * 2
+		})
+
+		assert.Equal("2", result)
+	})
+
+	t.Run("string slice", func(t *testing.T) {
+		result := JoinFunc([]string{"a", "b", "c"}, ", ", func(s string) string {
+			return strings.ToUpper(s)
+		})
+
+		expected := "A, B, C"
+		assert.Equal(expected, result)
+	})
+}
+
+func TestConcatBy(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestConcatBy")
+
+	t.Run("Join strings", func(t *testing.T) {
+		result := ConcatBy([]string{"Hello", "World"}, ", ", func(a, b string) string {
+			return a + b
+		})
+
+		expected := "Hello, World"
+		assert.Equal(expected, result)
+	})
+
+	t.Run("Join Person struct", func(t *testing.T) {
+		type Person struct {
+			Name string
+			Age  int
+		}
+
+		people := []Person{
+			{Name: "Alice", Age: 30},
+			{Name: "Bob", Age: 25},
+			{Name: "Charlie", Age: 35},
+		}
+		sep := Person{Name: " | ", Age: 0}
+
+		personConnector := func(a, b Person) Person {
+			return Person{Name: a.Name + b.Name, Age: a.Age + b.Age}
+		}
+
+		result := ConcatBy(people, sep, personConnector)
+
+		assert.Equal("Alice | Bob | Charlie", result.Name)
+		assert.Equal(90, result.Age)
+	})
+}