feat: accept multiple functions

Author: arsham

README.md

@@ -23,6 +23,16 @@ err := l.Do(func() error {
 })
 ```
 
+You can provide multiple functions:
+
+```go
+err := l.Do(func() error {
+    return nil
+}, func() error {
+    return nil
+}}
+```
+
 If you want to stop retrying you can return a special error:
 
 ```go

retry.go

@@ -42,25 +42,20 @@ type Retry struct {
 	Attempts int
 }
 
+type repeatFunc func() error
+
 // Do calls fn until it returns nil or a StopError. It delays and retries if
 // the fn returns any errors or panics. The value fo the returned error, or the
 // Err of a StopError, or an error with the panic message will be returned at
 // the last cycle.
-func (r Retry) Do(fn func() error) error {
+func (r Retry) Do(fn1 repeatFunc, fns ...repeatFunc) error {
 	method := r.Method
 	if method == nil {
 		method = StandardDelay
 	}
 	var err error
 	for i := 0; i < r.Attempts; i++ {
-		func() {
-			defer func() {
-				if e := recover(); e != nil {
-					err = fmt.Errorf("function caused a panic: %v", e)
-				}
-			}()
-			err = fn()
-		}()
+		err = r.do(fn1, fns...)
 		if err == nil {
 			return nil
 		}
@@ -79,6 +74,24 @@ func (r Retry) Do(fn func() error) error {
 	return err
 }
 
+func (r Retry) do(fn1 repeatFunc, fns ...repeatFunc) error {
+	var err error
+	for _, fn := range append([]repeatFunc{fn1}, fns...) {
+		func() {
+			defer func() {
+				if e := recover(); e != nil {
+					err = fmt.Errorf("function caused a panic: %v", e)
+				}
+			}()
+			err = fn()
+		}()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // StandardDelay always delays the same amount of time.
 func StandardDelay(_ int, delay time.Duration) time.Duration { return delay }
 

retry_example_test.go

@@ -136,3 +136,27 @@ func ExampleIncrementalDelay() {
 	// Output:
 	// Error: <nil>
 }
+
+func ExampleRetry_Do_multipleFuncs() {
+	l := &retry.Retry{
+		Attempts: 4,
+		Delay:    time.Nanosecond,
+	}
+	err := l.Do(func() error {
+		fmt.Println("Running func 1.")
+		return nil
+	}, func() error {
+		fmt.Println("Running func 2.")
+		return nil
+	}, func() error {
+		fmt.Println("Running func 3.")
+		return nil
+	})
+	fmt.Println("Error:", err)
+
+	// Output:
+	// Running func 1.
+	// Running func 2.
+	// Running func 3.
+	// Error: <nil>
+}

retry_test.go

@@ -17,6 +17,7 @@ func TestLoopDo(t *testing.T) {
 	t.Run("Stopping", testLoopDoStopping)
 	t.Run("Panic", testLoopDoPanic)
 	t.Run("Sleep", testLoopDoSleep)
+	t.Run("MultiFunc", testLoopDoMultiFunc)
 }
 
 func testLoopDoReturn(t *testing.T) {
@@ -256,3 +257,59 @@ func testLoopDoSleepIncrementalMethodZero(t *testing.T) {
 		fmt.Sprintf("take (%s) more than expected: %s", finished.Sub(started), time.Second),
 	)
 }
+
+func testLoopDoMultiFunc(t *testing.T) {
+	t.Parallel()
+	t.Run("FirstErrors", testLoopDoMultiFuncFirstErrors)
+	t.Run("SecondErrors", testLoopDoMultiFuncSecondErrors)
+	t.Run("NoErrors", testLoopDoMultiFuncNoErrors)
+}
+
+func testLoopDoMultiFuncFirstErrors(t *testing.T) {
+	t.Parallel()
+	l := &retry.Retry{
+		Attempts: 3,
+	}
+	err := l.Do(func() error {
+		return assert.AnError
+	}, func() error {
+		t.Error("should not be called")
+		return nil
+	})
+	assert.Equal(t, assert.AnError, errors.Cause(err))
+}
+
+func testLoopDoMultiFuncSecondErrors(t *testing.T) {
+	t.Parallel()
+	l := &retry.Retry{
+		Attempts: 3,
+	}
+
+	calls := 0
+	err := l.Do(func() error {
+		calls++
+		return nil
+	}, func() error {
+		return assert.AnError
+	})
+	assert.Equal(t, assert.AnError, errors.Cause(err))
+	assert.Equal(t, 3, calls)
+}
+
+func testLoopDoMultiFuncNoErrors(t *testing.T) {
+	t.Parallel()
+	l := &retry.Retry{
+		Attempts: 3,
+	}
+
+	calls := 0
+	err := l.Do(func() error {
+		calls++
+		return nil
+	}, func() error {
+		calls++
+		return nil
+	})
+	assert.NoError(t, err)
+	assert.Equal(t, 2, calls)
+}