concurrentloop

README

concurrentloop

concurrentloop provides a function to call a function concurrently powered by generics, channels, and goroutines.

Install

$ go get github.com/thalesfsp/concurrentloop

Specific version

Example: $ go get github.com/thalesfsp/concurrentloop@v1.2.0

Usage

See example_test.go, and concurrentloop_test.go file.

Documentation

Run $ make doc or check out online.

Development

Check out CONTRIBUTION.

Release

1. Update CHANGELOG accordingly.
2. Once changes from MR are merged.
3. Tag and release.

Roadmap

Check out CHANGELOG.

Documentation

Overview

Package concurrentloop provides a function to call a function concurrently powered by generics, channels, and goroutines.

Index

• func RunCh[T any, Result any](ctx context.Context, sl []T, f Func[T, Result]) chan ResultCh[Result]
• type Errors
  • func Run[T any, Result any](ctx context.Context, sl []T, f Func[T, Result]) ([]Result, Errors)
  • func (e Errors) Error() string
• type Func
• type ResultCh

Functions

func RunCh

func RunCh[T any, Result any](ctx context.Context, sl []T, f Func[T, Result]) chan ResultCh[Result]

RunCh calls the `Func` concurrently on each element of `sl`, and returns a channel that receives the results. The results are returned as a `resultCh` struct, which contains the output value and an error value if the function call failed.

Example usage:

resultsCh := RunCh(ctx, sl, f)
defer close(resultsCh)

var (
    results []Result
    errs    []error
)

for range sl {
    result := <-resultsCh

    if result.Error != nil {
        errs = append(errs, result.Error)
    } else {
        results = append(results, result.Output)
    }
}

// Process any errors that were returned.
if len(errs) > 0 {
    // Handle errors.
}

// Process the results.
// ...

NOTE: It's the caller's responsibility to close the channel.

Types

type Errors

type Errors []error

Errors is a slice of errors.

func Run

func Run[T any, Result any](ctx context.Context, sl []T, f Func[T, Result]) ([]Result, Errors)

Run calls the `Func` concurrently on each element of `sl`, and returns the results and any errors that occurred. The function blocks until all executions have completed.

Example usage:

results, errs := Run(ctx, sl, f)

// Process any errors that were returned.
if len(errs) > 0 {
    // Handle errors.
}

// Process the results.
// ...

func (Errors) Error

func (e Errors) Error() string

Error returns a string representation of the combined errors in the `Errors` slice, separated by commas. This method satisfies the `error` interface.

type Func

type Func[T any, Result any] func(context.Context, T) (Result, error)

Func is the type of the function that will be executed concurrently for each element in a slice of type `T`. The function takes a `context.Context` and a value of type `T`, and returns a value of type `Result` and an error value.

Example usage:

func myFunc(ctx context.Context, s string) (int, error) {
    // Perform some computation using the input `s`.
    ...
    return result, err
}

var sl []string
// Add strings to `sl`.
...

results, errs := Run(ctx, sl, myFunc)

type ResultCh

type ResultCh[T any] struct {
	Output T
	Error  error
}

ResultCh receives the result from the channel.