Go submits a task to be run in the pool. If all goroutines in the pool are busy, a call to Go() will block until the task can be started.

Wait cleans up spawned goroutines, propagating any panics that were raised by a tasks.

New creates a new Pool.

WithContext converts the pool to a ContextPool for tasks that should run under the same context, such that they each respect shared cancellation. For

WithMaxGoroutines limits the number of goroutines in a pool. Defaults to unlimited. Panics if n < 1.

WithErrors converts the pool to an ErrorPool so the submitted tasks can return errors.

Go spawns a new goroutine in the WaitGroup.

Try executes f, catching any panic it might spawn. It is safe to call from multiple goroutines simultaneously.

Recovered returns the value of the first panic caught by Try, or nil if no calls to Try panicked.

Go schedules a task to be run in the stream's pool. All submitted tasks will be executed concurrently in worker goroutines. Then, the callbacks return

AsError casts the panic into an error implementation. The implementation is unwrappable with the cause of the panic, if the panic was provided one.

New creates a new Stream with default settings.

String renders a human-readable formatting of the panic.

Map applies f to each element of input, returning the mapped result. Map always uses at most runtime.GOMAXPROCS goroutines. For a configurable gorout

MapErr applies f to each element of the input, returning the mapped result and a combined error of all returned errors. Map always uses at most runti

WithCancelOnError configures the pool to cancel its context as soon as any task returns an error or panics. By default, the pool's context is not canc

ForEach executes f in parallel over each element in input. It is safe to mutate the input parameter, which makes it possible to map in place. ForEac

ForEachIdx is the same as ForEach except it also provides the index of the element to the callback.

Wait will block until all goroutines spawned with Go exit and will propagate any panics spawned in a child goroutine.

Wait signals to the stream that all tasks have been submitted. Wait will not return until all tasks and callbacks have been run.

ForEachIdx is the same as ForEach except it also provides the index of the element to the callback.

WaitAndRecover will block until all goroutines spawned with Go exit and will return a *panics.Recovered if one of the child goroutines panics.

WithFirstError configures the pool to only return the first error returned by a task. By default, Wait() will return a combined error.

panicIfInitialized will trigger a panic if a configuration method is called after the pool has started any goroutines for the first time. In the case

ForEach executes f in parallel over each element in input, using up to the Iterator's configured maximum number of goroutines. It is safe to mutate t

Map applies f to each element of input, returning the mapped result. Map uses up to the configured Mapper's maximum number of goroutines.

MaxGoroutines returns the maximum size of the pool.

Repanic panics if any calls to Try caught a panic. It will panic with the value of the first panic caught, wrapped in a panics.Recovered with caller i

Try executes f, catching and returning any panic it might spawn. The recovered panic can be propagated with panic(), or handled as a normal error wit

WithCollectErrored configures the pool to still collect the result of a task even if the task returned an error. By default, the result of tasks that

defaultMaxGoroutines returns the default maximum number of goroutines to use within this package.

deref is a helper that creates a shallow copy of the pool with the same settings. We don't want to just dereference the pointer because that makes the

init ensures that the pool is initialized before use. This makes the zero value of the pool usable.

MapErr applies f to each element of the input, returning the mapped result and a combined error of all returned errors. Map uses up to the configured

NewRecovered creates a panics.Recovered from a panic value and a collected stacktrace. The skip parameter allows the caller to skip stack frames when

NewWaitGroup creates a new WaitGroup.

deref is a helper that creates a shallow copy of the pool with the same settings. We don't want to just dereference the pointer because that makes the

Go submits a task to the pool. If all goroutines in the pool are busy, a call to Go() will block until the task can be started.

Go submits a task to the pool. If all goroutines in the pool are busy, a call to Go() will block until the task can be started.

Go submits a task. If it returns an error, the error will be collected and returned by Wait(). If all goroutines in the pool are busy, a call to Go()

Go submits a task to the pool. If all goroutines in the pool are busy, a call to Go() will block until the task can be started.

Go submits a task to the pool. If all goroutines in the pool are busy, a call to Go() will block until the task can be started.

MaxGoroutines returns the maximum size of the pool.

NewWithResults creates a new ResultPool for tasks with a result of type T. The configuration methods (With*) will panic if they are used after callin

Wait cleans up all spawned goroutines, propagates any panics, and returns an error if any of the tasks errored.

Wait cleans up all spawned goroutines, propagating any panics, and returning a slice of results from tasks that did not panic.

Wait cleans up all spawned goroutines, propagates any panics, and returns an error if any of the tasks errored.

Wait cleans up any spawned goroutines, propagating any panics and returning any errors from tasks.

Wait cleans up any spawned goroutines, propagating any panics and returning the results and any errors from tasks.

WithCancelOnError configures the pool to cancel its context as soon as any task returns an error. By default, the pool's context is not canceled until

WithCollectErrored configures the pool to still collect the result of a task even if the task returned an error. By default, the result of tasks that

WithContext converts the pool to a ResultContextPool for tasks that should run under the same context, such that they each respect shared cancellation

WithContext converts the pool to a ContextPool for tasks that should run under the same context, such that they each respect shared cancellation. For