Use generics for typesafe API

README.md

@@ -10,7 +10,7 @@ task in parallel only after some initial timeout has elapsed:
 
 ```go
 // An example task that will wait for a random amount of time before returning
-task := func(ctx context.Context) (interface{}, error) {
+task := func(ctx context.Context) (string, error) {
     delay := time.Duration(float64(250*time.Millisecond) * rand.Float64())
     select {
     case <-time.After(delay):

example_test.go

@@ -73,14 +73,13 @@ func Example() {
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
-	result, err := speculatively.Do(ctx, patience, func(ctx context.Context) (interface{}, error) {
+	successfulCall, err := speculatively.Do(ctx, patience, func(ctx context.Context) (interface{}, error) {
 		return expensiveTask.Execute(ctx)
 	})
 	if err != nil {
 		fmt.Printf("unexpected error: %s\n", err)
 		return
 	}
-	successfulCall := result.(int)
 	fmt.Printf("succeeded on call number %d\n", successfulCall)
 
 	// Output:

go.mod

@@ -1,3 +1,3 @@
 module github.com/mccutchen/speculatively
 
-go 1.12
+go 1.18

speculatively.go

@@ -10,18 +10,18 @@ import (
 )
 
 // Thunk is a computation to be speculatively executed
-type Thunk func(context.Context) (interface{}, error)
+type Thunk[T any] func(context.Context) (T, error)
 
 // Do speculatively executes a Thunk one or more times in parallel, waiting for
 // the given patience duration between subsequent executions.
 //
 // Note that for Do to respect context cancelations, the given Thunk must
 // respect them.
-func Do(ctx context.Context, patience time.Duration, thunk Thunk) (interface{}, error) {
+func Do[T any](ctx context.Context, patience time.Duration, thunk Thunk[T]) (T, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
-	out := make(chan result)
+	out := make(chan result[T])
 	go runThunk(ctx, thunk, out)
 
 	ticker := time.NewTicker(patience)
@@ -32,20 +32,21 @@ func Do(ctx context.Context, patience time.Duration, thunk Thunk) (interface{},
 		case r := <-out:
 			return r.val, r.err
 		case <-ctx.Done():
-			return nil, ctx.Err()
+			var zero T
+			return zero, ctx.Err()
 		case <-ticker.C:
 			go runThunk(ctx, thunk, out)
 		}
 	}
 }
 
-type result struct {
-	val interface{}
+type result[T any] struct {
+	val T
 	err error
 }
 
-func runThunk(ctx context.Context, thunk Thunk, out chan result) {
-	var r result
+func runThunk[T any](ctx context.Context, thunk Thunk[T], out chan result[T]) {
+	var r result[T]
 	r.val, r.err = thunk(ctx)
 	select {
 	case out <- r:

speculatively_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 type testThunk struct {
-	results []result
+	results []result[int]
 	delays  []time.Duration
 	count   int
 	mu      sync.Mutex
@@ -22,7 +22,7 @@ func (t *testThunk) callCount() int {
 	return t.count
 }
 
-func (t *testThunk) call(ctx context.Context) (interface{}, error) {
+func (t *testThunk) call(ctx context.Context) (int, error) {
 	t.mu.Lock()
 	id := t.count
 	d := t.delays[id%len(t.delays)]
@@ -34,19 +34,19 @@ func (t *testThunk) call(ctx context.Context) (interface{}, error) {
 	case <-time.After(d):
 		return r.val, r.err
 	case <-ctx.Done():
-		return nil, ctx.Err()
+		return 0, ctx.Err()
 	}
 }
 
-func newTestThunk(results []result, delays []time.Duration) *testThunk {
+func newTestThunk(results []result[int], delays []time.Duration) *testThunk {
 	return &testThunk{
 		results: results,
 		delays:  delays,
 	}
 }
 
-func newSimpleTestThunk(val interface{}, err error, delay time.Duration) *testThunk {
-	results := []result{
+func newSimpleTestThunk(val int, err error, delay time.Duration) *testThunk {
+	results := []result[int]{
 		{val: val, err: err},
 	}
 	delays := []time.Duration{delay}
@@ -59,11 +59,10 @@ func TestSingleThunk(t *testing.T) {
 	thunk := newSimpleTestThunk(1, nil, 5*time.Millisecond)
 	patience := 20 * time.Millisecond
 
-	result, err := Do(context.Background(), patience, thunk.call)
+	val, err := Do(context.Background(), patience, thunk.call)
 	if err != nil {
 		t.Errorf("unexpected error: %s", err)
 	}
-	val := result.(int)
 	if val != 1 {
 		t.Errorf("expected val = %d, got %d", 1, val)
 	}
@@ -82,11 +81,10 @@ func TestSpeculativeThunkStarted(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
-	result, err := Do(ctx, patience, thunk.call)
+	val, err := Do(ctx, patience, thunk.call)
 	if err != nil {
 		t.Fatalf("unexpected error: %s", err)
 	}
-	val := result.(int)
 	if val != 1 {
 		t.Errorf("expected val = %d, got %d", 1, val)
 	}
@@ -98,7 +96,7 @@ func TestSpeculativeThunkStarted(t *testing.T) {
 func TestSpeculativeThunkFinishesFirst(t *testing.T) {
 	t.Parallel()
 
-	results := []result{
+	results := []result[int]{
 		{val: 1, err: nil},
 		{val: 2, err: nil},
 	}
@@ -118,11 +116,10 @@ func TestSpeculativeThunkFinishesFirst(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
-	result, err := Do(ctx, patience, thunk.call)
+	val, err := Do(ctx, patience, thunk.call)
 	if err != nil {
 		t.Fatalf("unexpected error: %s", err)
 	}
-	val := result.(int)
 	if val != expectedValue {
 		t.Errorf("expected val = %d, got %d", expectedValue, val)
 	}
@@ -135,7 +132,7 @@ func TestSpeculativeErrors(t *testing.T) {
 	t.Run("first task finishes first with error", func(t *testing.T) {
 		t.Parallel()
 
-		results := []result{
+		results := []result[int]{
 			{val: 1, err: errors.New("error")},
 			{val: 2, err: nil},
 		}
@@ -162,7 +159,7 @@ func TestSpeculativeErrors(t *testing.T) {
 	t.Run("first task finishes second with error", func(t *testing.T) {
 		t.Parallel()
 
-		results := []result{
+		results := []result[int]{
 			{val: 0, err: errors.New("error")},
 			{val: 2, err: nil},
 		}
@@ -182,12 +179,10 @@ func TestSpeculativeErrors(t *testing.T) {
 		ctx, cancel := context.WithTimeout(context.Background(), timeout)
 		defer cancel()
 
-		result, err := Do(ctx, patience, thunk.call)
+		val, err := Do(ctx, patience, thunk.call)
 		if err != nil {
 			t.Fatalf("unexpected error: %q", err)
 		}
-
-		val := result.(int)
 		if val != expectedVal {
 			t.Errorf("expected val = %#v, got %#v", expectedVal, val)
 		}