feat: adding RepeatByErr helpers

Author: samber

README.md

@@ -980,6 +980,15 @@ slice := lo.RepeatBy(5, func(i int) string {
 
 [[play](https://go.dev/play/p/ozZLCtX_hNU)]
 
+With error handling:
+
+```go
+slice, err := lo.RepeatByErr(3, func(i int) (string, error) {
+    return fmt.Sprintf("item-%d", i), nil
+})
+// []string{"item-0", "item-1", "item-2"}, <nil>
+```
+
 ### KeyBy
 
 Transforms a slice or a slice of structs to a map based on a pivot callback.

docs/data/core-repeatby.md

@@ -7,6 +7,7 @@ subCategory: slice
 playUrl: https://go.dev/play/p/ozZLCtX_hNU
 variantHelpers:
   - core#slice#repeatby
+  - core#slice#repeatbyerr
 similarHelpers:
   - core#slice#times
   - core#slice#repeat

docs/data/core-repeatbyerr.md

@@ -0,0 +1,37 @@
+---
+name: RepeatByErr
+slug: repeatbyerr
+sourceRef: slice.go#L564
+category: core
+subCategory: slice
+signatures:
+  - "func RepeatByErr[T any](count int, callback func(index int) (T, error)) ([]T, error)"
+variantHelpers:
+  - core#slice#repeatbyerr
+similarHelpers:
+  - core#slice#repeatby
+  - core#slice#times
+  - core#slice#repeat
+position: 225
+---
+
+Builds a slice by calling the callback N times with the current index. The callback can return an error to stop iteration immediately.
+
+```go
+result, err := lo.RepeatByErr(5, func(i int) (int, error) {
+    return i * i, nil
+})
+// []int{0, 1, 4, 9, 16}, <nil>
+```
+
+Example with error:
+
+```go
+result, err := lo.RepeatByErr(5, func(i int) (int, error) {
+    if i == 3 {
+        return 0, fmt.Errorf("number 3 is not allowed")
+    }
+    return i * i, nil
+})
+// []int(nil), error("number 3 is not allowed")
+```

lo_example_test.go

@@ -2781,6 +2781,15 @@ func ExampleRepeatBy() {
 	// Output: [0 1 4 9 16]
 }
 
+func ExampleRepeatByErr() {
+	result, err := RepeatByErr(3, func(i int) (string, error) {
+		return fmt.Sprintf("item-%d", i), nil
+	})
+
+	fmt.Printf("%d %v", len(result), err)
+	// Output: 3 <nil>
+}
+
 func ExampleKeyBy() {
 	list := []string{"a", "aa", "aaa"}
 

slice.go

@@ -562,6 +562,22 @@ func RepeatBy[T any](count int, callback func(index int) T) []T {
 	return result
 }
 
+// RepeatByErr builds a slice with values returned by N calls of callback.
+// It returns the first error returned by the callback function.
+func RepeatByErr[T any](count int, callback func(index int) (T, error)) ([]T, error) {
+	result := make([]T, 0, count)
+
+	for i := 0; i < count; i++ {
+		r, err := callback(i)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, r)
+	}
+
+	return result, nil
+}
+
 // KeyBy transforms a slice or a slice of structs to a map based on a pivot callback.
 // Play: https://go.dev/play/p/ccUiUL_Lnel
 func KeyBy[K comparable, V any](collection []V, iteratee func(item V) K) map[K]V {

slice_test.go

@@ -1560,6 +1560,120 @@ func TestRepeatBy(t *testing.T) {
 	is.Equal([]int{0, 1, 4, 9, 16}, result3)
 }
 
+func TestRepeatByErr(t *testing.T) {
+	t.Parallel()
+	is := assert.New(t)
+
+	testErr := errors.New("test error")
+
+	// Table-driven tests
+	tests := []struct {
+		name                 string
+		count                int
+		callback             func(index int) (int, error)
+		wantResult           []int
+		wantErr              bool
+		expectedCallbackCount int
+	}{
+		{
+			name:  "successful completion",
+			count: 5,
+			callback: func(i int) (int, error) {
+				return i * i, nil
+			},
+			wantResult:           []int{0, 1, 4, 9, 16},
+			wantErr:              false,
+			expectedCallbackCount: 5,
+		},
+		{
+			name:  "error at first iteration",
+			count: 5,
+			callback: func(i int) (int, error) {
+				if i == 0 {
+					return 0, testErr
+				}
+				return i * i, nil
+			},
+			wantResult:           nil,
+			wantErr:              true,
+			expectedCallbackCount: 1,
+		},
+		{
+			name:  "error at third iteration",
+			count: 5,
+			callback: func(i int) (int, error) {
+				if i == 2 {
+					return 0, testErr
+				}
+				return i * i, nil
+			},
+			wantResult:           nil,
+			wantErr:              true,
+			expectedCallbackCount: 3,
+		},
+		{
+			name:  "error at last iteration",
+			count: 5,
+			callback: func(i int) (int, error) {
+				if i == 4 {
+					return 0, testErr
+				}
+				return i * i, nil
+			},
+			wantResult:           nil,
+			wantErr:              true,
+			expectedCallbackCount: 5,
+		},
+		{
+			name:  "zero count - empty result",
+			count: 0,
+			callback: func(i int) (int, error) {
+				return i * i, nil
+			},
+			wantResult:           []int{},
+			wantErr:              false,
+			expectedCallbackCount: 0,
+		},
+		{
+			name:  "single item success",
+			count: 1,
+			callback: func(i int) (int, error) {
+				return 42, nil
+			},
+			wantResult:           []int{42},
+			wantErr:              false,
+			expectedCallbackCount: 1,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			// Track callback count to verify early return
+			callbackCount := 0
+			wrappedCallback := func(i int) (int, error) {
+				callbackCount++
+				return tt.callback(i)
+			}
+
+			result, err := RepeatByErr(tt.count, wrappedCallback)
+
+			if tt.wantErr {
+				is.ErrorIs(err, testErr)
+				is.Nil(result)
+			} else {
+				is.NoError(err)
+				is.Equal(tt.wantResult, result)
+			}
+
+			// Verify callback count matches expected (tests early return)
+			is.Equal(tt.expectedCallbackCount, callbackCount, "callback count should match expected")
+		})
+	}
+}
+
 func TestKeyBy(t *testing.T) {
 	t.Parallel()
 	is := assert.New(t)