feat: All return the error and the index of the function.

Author: ghosind

all.go

@@ -9,24 +9,31 @@ import (
 )
 
 // All executes the functions asynchronously until all functions have been finished. If some
-// function returns an error or panic, it will return the error immediately and send a cancel
-// signal to all other functions by context.
-func All(funcs ...func(context.Context) error) error {
+// 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.
+//
+// The index of the function will be -1 if all functions have been completed without error or
+// panic.
+func All(funcs ...func(context.Context) error) (int, 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
-// return the error immediately and send a cancel signal to all other functions by context.
-func AllWithContext(ctx context.Context, funcs ...func(context.Context) error) error {
+// immediately return the index of the index and the 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 ...func(context.Context) error) (int, 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 ...func(context.Context) error) error {
+func all(parent context.Context, funcs ...func(context.Context) error) (int, error) {
 	if len(funcs) == 0 {
-		return nil
+		return -1, nil
 	}
 
 	if parent == nil {
@@ -36,11 +43,12 @@ func all(parent context.Context, funcs ...func(context.Context) error) error {
 	ctx, canFunc := context.WithCancel(parent)
 	defer canFunc()
 
-	errCh := make(chan error)
-	defer close(errCh)
+	ch := make(chan executeResult)
+	defer close(ch)
 
 	for i := 0; i < len(funcs); i++ {
 		fn := funcs[i]
+		n := i
 		go func() {
 			childCtx, childCanFunc := context.WithCancel(ctx)
 			defer childCanFunc()
@@ -53,7 +61,10 @@ func all(parent context.Context, funcs ...func(context.Context) error) error {
 			case <-ctx.Done():
 				return
 			default:
-				errCh <- err
+				ch <- executeResult{
+					Error: err,
+					Index: n,
+				}
 			}
 		}()
 	}
@@ -62,16 +73,16 @@ func all(parent context.Context, funcs ...func(context.Context) error) error {
 	for finished < len(funcs) {
 		select {
 		case <-parent.Done():
-			return errors.New("context canceled")
-		case err := <-errCh:
-			if err != nil {
-				return err
+			return -1, errors.New("context canceled")
+		case ret := <-ch:
+			if ret.Error != nil {
+				return ret.Index, ret.Error
 			}
 			finished++
 		}
 	}
 
-	return nil
+	return -1, nil
 }
 
 // AllCompleted executes the functions asynchronously until all functions have been finished. It

all_test.go

@@ -12,8 +12,9 @@ import (
 func TestAllWithoutFuncs(t *testing.T) {
 	a := assert.New(t)
 
-	err := All()
+	index, err := All()
 	a.NilNow(err)
+	a.EqualNow(index, -1)
 }
 
 func TestAllSuccess(t *testing.T) {
@@ -30,8 +31,9 @@ func TestAllSuccess(t *testing.T) {
 		})
 	}
 
-	err := All(funcs...)
+	index, err := All(funcs...)
 	a.NilNow(err)
+	a.EqualNow(index, -1)
 	a.EqualNow(data, []bool{true, true, true, true, true})
 }
 
@@ -52,8 +54,9 @@ func TestAllFailure(t *testing.T) {
 		})
 	}
 
-	err := All(funcs...)
+	index, err := All(funcs...)
 	a.NotNilNow(err)
+	a.EqualNow(index, 2)
 	a.EqualNow(err.Error(), "n = 2")
 	a.EqualNow(data, []bool{true, true, false, false, false})
 }
@@ -62,11 +65,12 @@ func TestAllWithNilContext(t *testing.T) {
 	a := assert.New(t)
 
 	//lint:ignore SA1012 for test case only
-	err := AllWithContext(nil, func(ctx context.Context) error {
+	index, err := AllWithContext(nil, func(ctx context.Context) error {
 		time.Sleep(100 * time.Millisecond)
 		return nil
 	})
 	a.NilNow(err)
+	a.EqualNow(index, -1)
 }
 
 func TestAllWithTimeoutContext(t *testing.T) {
@@ -86,8 +90,9 @@ func TestAllWithTimeoutContext(t *testing.T) {
 	ctx, canFunc := context.WithTimeout(context.Background(), 150*time.Millisecond)
 	defer canFunc()
 
-	err := AllWithContext(ctx, funcs...)
+	index, err := AllWithContext(ctx, funcs...)
 	a.NotNilNow(err)
+	a.EqualNow(index, -1)
 	a.Equal(err.Error(), "context canceled")
 	a.EqualNow(data, []bool{true, true, false, false, false})
 }