Add DoValue, which requires generics and bumps to Go 1.21 (#26)

Closes #22

Author: sethvargo

.github/workflows/test.yml

@@ -3,12 +3,12 @@ name: 'Test'
 on:
   push:
     branches:
-    - 'main'
+      - 'main'
     tags:
-    - '*'
+      - '*'
   pull_request:
     branches:
-    - 'main'
+      - 'main'
   workflow_dispatch:
 
 concurrency:
@@ -20,11 +20,17 @@ jobs:
     runs-on: 'ubuntu-latest'
 
     steps:
-    - uses: 'actions/checkout@v3'
+      - uses: 'actions/checkout@v4'
 
-    - uses: actions/setup-go@v3
-      with:
-        go-version: '1.16'
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: 'go.mod'
 
-    - name: 'Test'
-      run: 'make test'
+      - name: 'Test'
+        run: |-
+          go test \
+            -count=1 \
+            -race \
+            -short \
+            -timeout=5m \
+            ./...

Makefile

@@ -1,6 +1,6 @@
 module github.com/sethvargo/go-retry
 
-go 1.16
+go 1.21
 
 // Something weird happened with the v0.2.0 tag where the commit in the module
 // registry doesn't match the commit on GitHub.

benchmark/benchmark_test.go

@@ -18,9 +18,12 @@ import (
 	"time"
 )
 
-// RetryFunc is a function passed to retry.
+// RetryFunc is a function passed to [Do].
 type RetryFunc func(ctx context.Context) error
 
+// RetryFuncValue is a function passed to [Do] which returns a value.
+type RetryFuncValue[T any] func(ctx context.Context) (T, error)
+
 type retryableError struct {
 	err error
 }
@@ -46,47 +49,56 @@ func (e *retryableError) Error() string {
 	return "retryable: " + e.err.Error()
 }
 
-// Do wraps a function with a backoff to retry. The provided context is the same
-// context passed to the RetryFunc.
-func Do(ctx context.Context, b Backoff, f RetryFunc) error {
+func DoValue[T any](ctx context.Context, b Backoff, f RetryFuncValue[T]) (T, error) {
+	var nilT T
+
 	for {
 		// Return immediately if ctx is canceled
 		select {
 		case <-ctx.Done():
-			return ctx.Err()
+			return nilT, ctx.Err()
 		default:
 		}
 
-		err := f(ctx)
+		v, err := f(ctx)
 		if err == nil {
-			return nil
+			return v, nil
 		}
 
 		// Not retryable
 		var rerr *retryableError
 		if !errors.As(err, &rerr) {
-			return err
+			return nilT, err
 		}
 
 		next, stop := b.Next()
 		if stop {
-			return rerr.Unwrap()
+			return nilT, rerr.Unwrap()
 		}
 
 		// ctx.Done() has priority, so we test it alone first
 		select {
 		case <-ctx.Done():
-			return ctx.Err()
+			return nilT, ctx.Err()
 		default:
 		}
 
 		t := time.NewTimer(next)
 		select {
 		case <-ctx.Done():
 			t.Stop()
-			return ctx.Err()
+			return nilT, ctx.Err()
 		case <-t.C:
 			continue
 		}
 	}
 }
+
+// Do wraps a function with a backoff to retry. The provided context is the same
+// context passed to the [RetryFunc].
+func Do(ctx context.Context, b Backoff, f RetryFunc) error {
+	_, err := DoValue(ctx, b, func(ctx context.Context) (*struct{}, error) {
+		return nil, f(ctx)
+	})
+	return err
+}

benchmark/go.mod

@@ -22,6 +22,30 @@ func TestRetryableError(t *testing.T) {
 	}
 }
 
+func TestDoValue(t *testing.T) {
+	t.Parallel()
+
+	t.Run("returns_value", func(t *testing.T) {
+		t.Parallel()
+
+		ctx := context.Background()
+		b := retry.WithMaxRetries(3, retry.BackoffFunc(func() (time.Duration, bool) {
+			return 1 * time.Nanosecond, false
+		}))
+
+		v, err := retry.DoValue(ctx, b, func(_ context.Context) (string, error) {
+			return "foo", nil
+		})
+		if err != nil {
+			t.Fatal("expected err")
+		}
+
+		if got, want := v, "foo"; got != want {
+			t.Errorf("expected %v to be %v", got, want)
+		}
+	})
+}
+
 func TestDo(t *testing.T) {
 	t.Parallel()
 
@@ -175,6 +199,34 @@ func ExampleDo_customRetry() {
 	}
 }
 
+func ExampleDoValue() {
+	ctx := context.Background()
+
+	b := retry.NewFibonacci(1 * time.Nanosecond)
+
+	body, err := retry.DoValue(ctx, retry.WithMaxRetries(3, b), func(ctx context.Context) ([]byte, error) {
+		resp, err := http.Get("https://google.com/")
+		if err != nil {
+			return nil, err
+		}
+		defer resp.Body.Close()
+
+		switch resp.StatusCode / 100 {
+		case 4:
+			return nil, fmt.Errorf("bad response: %v", resp.StatusCode)
+		case 5:
+			return nil, retry.RetryableError(fmt.Errorf("bad response: %v", resp.StatusCode))
+		default:
+			b, _ := io.ReadAll(resp.Body)
+			return b, nil
+		}
+	})
+	if err != nil {
+		// handle error
+	}
+	_ = body
+}
+
 func TestCancel(t *testing.T) {
 	for i := 0; i < 100000; i++ {
 		ctx, cancel := context.WithCancel(context.Background())