feat: return the index of the first completed function for Race.

Author: ghosind

race.go

@@ -7,48 +7,59 @@ import (
 	"github.com/ghosind/utils"
 )
 
-// Race executes the functions asynchronously, it will return the result of the first of the
-// finished function (including panic), and it will not send a cancel signal to other functions.
-func Race(funcs ...func(context.Context) error) error {
+// Race executes the functions asynchronously, it will return the index and the result of the first
+// of the finished function (including panic), and it will not send a cancel signal to other
+// functions.
+func Race(funcs ...func(context.Context) error) (int, error) {
 	return race(context.Background(), funcs...)
 }
 
-// RaceWithContext executes the functions asynchronously, it will return the result of the first of
-// the finished function (including panic), and it will not send a cancel signal to other
-// functions.
-func RaceWithContext(ctx context.Context, funcs ...func(context.Context) error) error {
+// RaceWithContext executes the functions asynchronously, it will return the index and the result
+// of the first of the finished function (including panic), and it will not send a cancel signal
+// to other functions.
+func RaceWithContext(ctx context.Context, funcs ...func(context.Context) error) (int, error) {
 	return race(ctx, funcs...)
 }
 
-// race executes the functions asynchronously, it will return the result of the first of the
-// finished function (including panic).
-func race(ctx context.Context, funcs ...func(context.Context) error) error {
+// race executes the functions asynchronously, it will return the index and the result of the first
+// of the finished function (including panic).
+func race(ctx context.Context, funcs ...func(context.Context) error) (int, error) {
 	if len(funcs) == 0 {
-		return nil
+		return -1, nil
 	}
 
 	if ctx == nil {
 		ctx = context.Background()
 	}
 
 	finished := atomic.Bool{}
-	ch := make(chan error)
+	ch := make(chan struct {
+		Index int
+		Error error
+	})
 	defer close(ch)
 
 	for i := 0; i < len(funcs); i++ {
 		fn := funcs[i]
+		n := i
 
 		go func() {
 			err := utils.Try(func() error {
 				return fn(ctx)
 			})
 			if finished.CompareAndSwap(false, true) {
-				ch <- err
+				ch <- struct {
+					Index int
+					Error error
+				}{
+					Index: n,
+					Error: err,
+				}
 			}
 		}()
 	}
 
-	err := <-ch
+	ret := <-ch
 
-	return err
+	return ret.Index, ret.Error
 }

race_test.go

@@ -12,8 +12,9 @@ import (
 func TestRaceWithoutFuncs(t *testing.T) {
 	a := assert.New(t)
 
-	err := Race()
+	index, err := Race()
 	a.NilNow(err)
+	a.EqualNow(index, -1)
 }
 
 func TestRace(t *testing.T) {
@@ -30,8 +31,9 @@ func TestRace(t *testing.T) {
 		})
 	}
 
-	err := Race(funcs...)
+	index, err := Race(funcs...)
 	a.NilNow(err)
+	a.EqualNow(index, 0)
 	a.EqualNow(data, []bool{true, false, false, false, false})
 
 	time.Sleep(300 * time.Millisecond)
@@ -42,11 +44,12 @@ func TestRaceWithNilContext(t *testing.T) {
 	a := assert.New(t)
 
 	//lint:ignore SA1012 for test case only
-	err := RaceWithContext(nil, func(ctx context.Context) error {
+	index, err := RaceWithContext(nil, func(ctx context.Context) error {
 		time.Sleep(100 * time.Millisecond)
 		return nil
 	})
 	a.NilNow(err)
+	a.EqualNow(index, 0)
 }
 
 func TestRaceWithContext(t *testing.T) {
@@ -71,8 +74,9 @@ func TestRaceWithContext(t *testing.T) {
 	ctx, canFunc := context.WithTimeout(context.Background(), 170*time.Millisecond)
 	defer canFunc()
 
-	err := RaceWithContext(ctx, funcs...)
+	index, err := RaceWithContext(ctx, funcs...)
 	a.NilNow(err)
+	a.EqualNow(index, 0)
 	a.EqualNow(data, []bool{true, false, false, false, false})
 
 	time.Sleep(300 * time.Millisecond)