refactor: apply execution error to All,, Parallel, and Race.

Author: ghosind

all.go

@@ -6,31 +6,31 @@ import (
 )
 
 // All executes the functions asynchronously until all functions have been finished. If some
-// function returns an error or panic, it will immediately return the index of the function and the
-// error, and send a cancel signal to all other functions by context.
+// function returns an error or panic, it will immediately return an execution error, and send a
+// cancel signal to all other functions by context.
 //
 // The index of the function will be -1 if all functions have been completed without error or
 // panic.
-func All(funcs ...AsyncFn) ([][]any, int, error) {
+func All(funcs ...AsyncFn) ([][]any, error) {
 	return all(context.Background(), funcs...)
 }
 
 // AllWithContext executes the functions asynchronously until all functions have been finished, or
 // the context is done (canceled or timeout). If some function returns an error or panic, it will
-// immediately return the index of the index and the error and send a cancel signal to all other
-// functions by context.
+// immediately return an execution error and send a cancel signal to all other functions by
+// context.
 //
 // The index of the function will be -1 if all functions have been completed without error or
 // panic, or the context has been canceled (or timeout) before all functions finished.
-func AllWithContext(ctx context.Context, funcs ...AsyncFn) ([][]any, int, error) {
+func AllWithContext(ctx context.Context, funcs ...AsyncFn) ([][]any, error) {
 	return all(ctx, funcs...)
 }
 
 // all executes the functions asynchronously until all functions have been finished, or the context
 // is done (canceled or timeout).
-func all(parent context.Context, funcs ...AsyncFn) ([][]any, int, error) {
+func all(parent context.Context, funcs ...AsyncFn) ([][]any, error) {
 	if len(funcs) == 0 {
-		return nil, -1, nil
+		return nil, nil
 	}
 	validateAsyncFuncs(funcs...)
 
@@ -51,17 +51,20 @@ func all(parent context.Context, funcs ...AsyncFn) ([][]any, int, error) {
 	for finished < len(funcs) {
 		select {
 		case <-parent.Done():
-			return out, -1, ErrContextCanceled
+			return out, ErrContextCanceled
 		case ret := <-ch:
 			out[ret.Index] = ret.Out
 			if ret.Error != nil {
-				return out, ret.Index, ret.Error
+				return out, &executionError{
+					index: ret.Index,
+					err:   ret.Error,
+				}
 			}
 			finished++
 		}
 	}
 
-	return out, -1, nil
+	return out, nil
 }
 
 // runTaskInAll runs the specified function for All / AllWithContext.

all_test.go

@@ -12,9 +12,8 @@ import (
 func TestAllWithoutFuncs(t *testing.T) {
 	a := assert.New(t)
 
-	out, index, err := All()
+	out, err := All()
 	a.NilNow(err)
-	a.EqualNow(index, -1)
 	a.NilNow(out)
 }
 
@@ -32,9 +31,8 @@ func TestAllSuccess(t *testing.T) {
 		})
 	}
 
-	out, index, err := All(funcs...)
+	out, err := All(funcs...)
 	a.NilNow(err)
-	a.EqualNow(index, -1)
 	a.EqualNow(data, []bool{true, true, true, true, true})
 	a.EqualNow(out, [][]any{{0, nil}, {1, nil}, {2, nil}, {3, nil}, {4, nil}})
 }
@@ -57,10 +55,9 @@ func TestAllFailure(t *testing.T) {
 		})
 	}
 
-	out, index, err := All(funcs...)
+	out, err := All(funcs...)
 	a.NotNilNow(err)
-	a.EqualNow(index, 2)
-	a.EqualNow(err, expectedErr)
+	a.EqualNow(err.Error(), "function 2 error: n = 2")
 	a.EqualNow(data, []bool{true, true, false, false, false})
 	a.EqualNow(out, [][]any{{nil}, {nil}, {expectedErr}, nil, nil})
 }
@@ -69,12 +66,11 @@ func TestAllWithNilContext(t *testing.T) {
 	a := assert.New(t)
 
 	//lint:ignore SA1012 for test case only
-	out, index, err := AllWithContext(nil, func(ctx context.Context) error {
+	out, err := AllWithContext(nil, func(ctx context.Context) error {
 		time.Sleep(100 * time.Millisecond)
 		return nil
 	})
 	a.NilNow(err)
-	a.EqualNow(index, -1)
 	a.EqualNow(out, [][]any{{nil}})
 }
 
@@ -95,9 +91,8 @@ func TestAllWithTimeoutContext(t *testing.T) {
 	ctx, canFunc := context.WithTimeout(context.Background(), 150*time.Millisecond)
 	defer canFunc()
 
-	out, index, err := AllWithContext(ctx, funcs...)
+	out, err := AllWithContext(ctx, funcs...)
 	a.NotNilNow(err)
-	a.EqualNow(index, -1)
 	a.TrueNow(errors.Is(err, ErrContextCanceled))
 	a.EqualNow(data, []bool{true, true, false, false, false})
 	a.EqualNow(out, [][]any{{nil}, {nil}, nil, nil, nil})

parallel.go

@@ -7,33 +7,32 @@ import (
 
 // Parallel runs the functions asynchronously with the specified concurrency limitation. It will
 // send a cancel sign to context and terminate immediately if any function returns an error or
-// panic, and also returns the index of the error function in the parameters list.
+// panic, and also returns an execution error to indicate the error.
 //
 // The number of concurrency must be greater than or equal to 0, and it means no concurrency
 // limitation if the number is 0.
-func Parallel(concurrency int, funcs ...AsyncFn) ([][]any, int, error) {
+func Parallel(concurrency int, funcs ...AsyncFn) ([][]any, error) {
 	return parallel(context.Background(), concurrency, funcs...)
 }
 
 // ParallelWithContext runs the functions asynchronously with the specified concurrency limitation.
 // It will send a cancel sign to context and terminate immediately if any function returns an error
-// or panic, and also returns the index of the error function in the parameters list. If the
-// context was canceled or timed out before all functions finished executing, it will send a cancel
-// sign to all uncompleted functions, and return the value of the index as -1 with a `context
-// canceled` error.
+// or panic, and also returns an execution error to indicate the error. If the context was canceled
+// or timed out before all functions finished executing, it will send a cancel sign to all
+// uncompleted functions, and return a context canceled error.
 //
 // The number of concurrency must be greater than or equal to 0, and it means no concurrency
 // limitation if the number is 0.
 func ParallelWithContext(
 	ctx context.Context,
 	concurrency int,
 	funcs ...AsyncFn,
-) ([][]any, int, error) {
+) ([][]any, error) {
 	return parallel(ctx, concurrency, funcs...)
 }
 
 // parallel runs the functions asynchronously with the specified concurrency.
-func parallel(parent context.Context, concurrency int, funcs ...AsyncFn) ([][]any, int, error) {
+func parallel(parent context.Context, concurrency int, funcs ...AsyncFn) ([][]any, error) {
 	// the number of concurrency should be 0 (no limitation) or greater than 0.
 	if concurrency < 0 {
 		panic(ErrInvalidConcurrency)
@@ -42,7 +41,7 @@ func parallel(parent context.Context, concurrency int, funcs ...AsyncFn) ([][]an
 
 	out := make([][]any, len(funcs))
 	if len(funcs) == 0 {
-		return out, -1, nil
+		return out, nil
 	}
 
 	parent = getContext(parent)
@@ -71,17 +70,20 @@ func parallel(parent context.Context, concurrency int, funcs ...AsyncFn) ([][]an
 	for finished < len(funcs) {
 		select {
 		case <-parent.Done():
-			return out, -1, ErrContextCanceled
+			return out, ErrContextCanceled
 		case ret := <-ch:
 			out[ret.Index] = ret.Out
 			if ret.Error != nil {
-				return out, ret.Index, ret.Error
+				return out, &executionError{
+					index: ret.Index,
+					err:   ret.Error,
+				}
 			}
 			finished++
 		}
 	}
 
-	return out, -1, nil
+	return out, nil
 }
 
 // runTaskInParallel runs the specified function for Parallel / ParallelWithContext.

parallel_test.go

@@ -12,9 +12,8 @@ import (
 func TestParallel(t *testing.T) {
 	a := assert.New(t)
 
-	out, index, err := Parallel(0)
+	out, err := Parallel(0)
 	a.NilNow(err)
-	a.EqualNow(index, -1)
 	a.EqualNow(out, [][]any{})
 
 	a.PanicNow(func() {
@@ -35,10 +34,9 @@ func TestParallelWithoutConcurrencyLimit(t *testing.T) {
 	}
 
 	start := time.Now()
-	out, index, err := Parallel(0, funcs...)
+	out, err := Parallel(0, funcs...)
 	dur := time.Since(start)
 	a.NilNow(err)
-	a.EqualNow(index, -1)
 	a.TrueNow(dur-100*time.Millisecond < 30*time.Millisecond) // allow 30ms deviation
 	a.EqualNow(out, [][]any{{0, nil}, {1, nil}, {2, nil}, {3, nil}, {4, nil}})
 }
@@ -56,10 +54,9 @@ func TestParallelWithConcurrencyLimit(t *testing.T) {
 	}
 
 	start := time.Now()
-	out, index, err := Parallel(2, funcs...)
+	out, err := Parallel(2, funcs...)
 	dur := time.Since(start)
 	a.NilNow(err)
-	a.EqualNow(index, -1)
 	a.TrueNow(dur-300*time.Millisecond < 30*time.Millisecond) // allow 30ms deviation
 	a.EqualNow(out, [][]any{{0, nil}, {1, nil}, {2, nil}, {3, nil}, {4, nil}})
 }
@@ -84,10 +81,10 @@ func TestParallelWithFailedTask(t *testing.T) {
 	}
 
 	start := time.Now()
-	out, index, err := Parallel(2, funcs...)
+	out, err := Parallel(2, funcs...)
 	dur := time.Since(start)
-	a.EqualNow(err, expectedErr)
-	a.EqualNow(index, 2)
+	a.NotNilNow(err)
+	a.EqualNow(err.Error(), "function 2 error: expected error")
 	a.TrueNow(dur-150*time.Millisecond < 30*time.Millisecond) // allow 30ms deviation
 	a.EqualNow(out, [][]any{{0, nil}, {1, nil}, {2, expectedErr}, nil, nil})
 }
@@ -106,9 +103,8 @@ func TestParallelWithContext(t *testing.T) {
 		})
 	}
 
-	out, index, err := ParallelWithContext(context.Background(), 2, funcs...)
+	out, err := ParallelWithContext(context.Background(), 2, funcs...)
 	a.NilNow(err)
-	a.EqualNow(index, -1)
 	a.EqualNow(out, [][]any{{0, nil}, {1, nil}, {2, nil}, {3, nil}, {4, nil}})
 
 	finishedNum := 0
@@ -137,9 +133,9 @@ func TestParallelWithTimedOutContext(t *testing.T) {
 	ctx, canFunc := context.WithTimeout(context.Background(), 150*time.Millisecond)
 	defer canFunc()
 
-	out, index, err := ParallelWithContext(ctx, 2, funcs...)
+	out, err := ParallelWithContext(ctx, 2, funcs...)
+	a.NotNilNow(err)
 	a.TrueNow(errors.Is(err, ErrContextCanceled))
-	a.EqualNow(index, -1)
 	a.EqualNow(res, []bool{true, true, false, false, false})
 	a.EqualNow(out, [][]any{{0, nil}, {1, nil}, nil, nil, nil})
 }

race.go

@@ -49,6 +49,12 @@ func race(ctx context.Context, funcs ...AsyncFn) ([]any, int, error) {
 	}
 
 	ret := <-ch
+	if ret.Error != nil {
+		return ret.Out, ret.Index, &executionError{
+			index: ret.Index,
+			err:   ret.Error,
+		}
+	}
 
-	return ret.Out, ret.Index, ret.Error
+	return ret.Out, ret.Index, nil
 }

race_test.go

@@ -42,6 +42,37 @@ func TestRace(t *testing.T) {
 	a.EqualNow(data, []bool{true, true, true, true, true})
 }
 
+func TestRaceWithFailed(t *testing.T) {
+	a := assert.New(t)
+
+	data := make([]bool, 5)
+	funcs := make([]AsyncFn, 0, 5)
+	expectedErr := errors.New("expected error")
+	for i := 0; i < 5; i++ {
+		n := i
+		funcs = append(funcs, func(ctx context.Context) (int, error) {
+			if n == 2 {
+				time.Sleep(25 * time.Millisecond)
+				return n, expectedErr
+			} else {
+				time.Sleep(time.Duration((n+1)*50) * time.Millisecond)
+				data[n] = true
+				return n, nil
+			}
+		})
+	}
+
+	out, index, err := Race(funcs...)
+	a.NotNilNow(err)
+	a.EqualNow(err.Error(), "function 2 error: expected error")
+	a.EqualNow(index, 2)
+	a.EqualNow(data, []bool{false, false, false, false, false})
+	a.EqualNow(out, []any{2, expectedErr})
+
+	time.Sleep(300 * time.Millisecond)
+	a.EqualNow(data, []bool{true, true, false, true, true})
+}
+
 func TestRaceWithNilContext(t *testing.T) {
 	a := assert.New(t)