A safe way to execute functions asynchronously, recovering them in case of panic. It also provides an error stack aiming to facilitate fail causes discovery.

It shoudle add defer safePanic(cerr) in wrapperChannel to handle panic

// runner.go
func wrapperChannel(ctx context.Context, task Task) chan error {
	cerr := make(chan error, 1)
	go func() {
		defer safePanic(cerr)

		cerr <- task(ctx)
		close(cerr)
	}()
	return cerr
}

// runner_test.go
func TestRunner_Panic(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	runner := NewRunner(func(context.Context) error {
		panic(errors.New("test panic"))
		return nil
	})
	err := runner.Run(ctx)

	require.Contains(t, err.Error(), "async.Run: panic test panic")
}

Example of usage:

runner := NewRunner(tasks...).WithLimit(3)
err := runner.Run(ctx) 

Closes https://github.com/StudioSol/async/issues/2 Closes https://github.com/StudioSol/async/issues/3

In the current version, if 3 functions is given and one of the fail, the async run will stop and return this error. The feature consists in include a flag to wait all functions finish and return all erros.

Suggestion of signature:

runner := async.NewRunner(tasks...).WaitErrors(true)
err := runner.Do(ctx)

The erros can be merged with the new errors package: https://golang.org/pkg/errors/#New The option %w will stack all errors in a single one.

The async.Run execute all functions in the same time. Maybe a limit parameter can help with limited asynchronous tasks.

Suggestion of signature:

runner := async.NewRunner(tasks...).WithLimit(5).OtherOption(foo, bar)
err := runner.Do(ctx)