eduardbme / gasync

Set of utilities to handle concurrency tasks in Go. Inspired by 'yarn add async'.

gasync 🔥 👌

Set of utilities to handle different control flows in Go.

Inspired by yarn add async. 🙊

control flow

• parallel
• series
• tryEach
• times
• retry

parallel:

import (
    "github.com/eduardbcom/gasync/parallel"
)

ctx := context.TODO()

res, err := parallel.Do(
    // both functions run in parallel
    func() (interface{}, error) { return identity(ctx, "task1") },
    func() (interface{}, error) { return identity(ctx, "task2") },
)

// res == []interface{}{"task1", "task2"}
// err == nil

import (
    "github.com/eduardbcom/gasync/parallel"
)

ctx := context.TODO()

res, err := parallel.Do(
    // both functions run in parallel
    func() (interface{}, error) { return identity(ctx, "task1") },
    func() (interface{}, error) { return nil, errors.New("some error here") },
)

// res == nil
// err == errors.New("some error here")

import (
    "github.com/eduardbcom/gasync/parallel"
)

ctx := context.TODO()

res, err := parallel.DoWithLimit(
    2,
    // both functions run in parallel
    func() (interface{}, error) { return identity(ctx, "task1") },
    func() (interface{}, error) { return identity(ctx, "task2") },
)

// res == []interface{}{"task1", "task2"}
// err == nil

series:

import (
    "github.com/eduardbcom/gasync/series"
)

ctx := context.TODO()

res, err := series.Do(
    // functions run sequentially
    func() (interface{}, error) { return identity(ctx, "task1") },
    func() (interface{}, error) { return identity(ctx, "task2") },
)

// res == []interface{}{"task1", "task2"}
// err == nil

import (
    "github.com/eduardbcom/gasync/series"
)

ctx := context.TODO()

res, err := series.Do(
    // functions run sequentially
    func() (interface{}, error) { return identity(ctx, "task1") },
    func() (interface{}, error) { return nil, errors.New("some error here") },
)

// res == nil
// err == errors.New("some error here")

tryEach:

import (
    "github.com/eduardbcom/gasync/tryEach"
)

ctx := context.TODO()

res, err := tryEach.Do(
    // functions run sequentially
    func() (interface{}, error) { return identity(ctx, "task1") },
    func() (interface{}, error) { return identity(ctx, "task2") },
)

// res == "task1"
// err == nil

import (
    "github.com/eduardbcom/gasync/tryEach"
)

ctx := context.TODO()

res, err := tryEach.Do(
    // functions run sequentially
    func() (interface{}, error) { return nil, errors.New("some error here") },
    func() (interface{}, error) { return identity(ctx, "task2") },
)

// res == "task2"
// err == nil

import (
    "github.com/eduardbcom/gasync/tryEach"
)

ctx := context.TODO()

res, err := tryEach.Do(
    // functions run sequentially
    func() (interface{}, error) { return nil, errors.New("some error here") },
    func() (interface{}, error) { return nil, errors.New("some second error here") },
)

// res == nil
// err == errors.New("some second error here")

times:

import (
    "github.com/eduardbcom/gasync/times"
)

ctx := context.TODO()

res, err := times.Do(
    2,
    // both calls run in parallel
    func() (interface{}, error) { return identity(ctx, "task") },
)

// res == []interface{}{"task", "task"}
// err == nil

import (
    "github.com/eduardbcom/gasync/times"
)

ctx := context.TODO()

res, err := times.DoWithLimit(
    2,
    5,
    // 2 calls run in parallel
    // 2 calls run in parallel
    // 1 call
    func() (interface{}, error) { return identity(ctx, "task") },
)

// res == []interface{}{"task", "task", "task", "task", "task"}
// err == nil

import (
    "github.com/eduardbcom/gasync/times"
)

ctx := context.TODO()

res, err := times.DoSeries(
    2,
    // functions run in sequential way
    func() (interface{}, error) { return identity(ctx, "task") }
)

// res == []interface{}{"task", "task"}
// err == nil

retry:

import (
    "github.com/eduardbcom/gasync/retry"
)

ctx := context.TODO()

res, err := retry.Do(
    2,
    func() (interface{}, error) { return identity(ctx, "task") },
)

// res == "task1"
// err == nil

import (
    "github.com/eduardbcom/gasync/retry"
)

ctx := context.TODO()

res, err := retry.Do(
    2,
    func() (interface{}, error) { return nil, errors.New("some error here") },
)

// res == nil
// err == errors.New("some error here")

import (
    "github.com/eduardbcom/gasync/retry"
)

ctx := context.TODO()

intervalMs := 1000
res, err := retry.DoWithInterval(
    2,
    intervalMs,
    func() (interface{}, error) { return nil, errors.New("some error here") }
)

// res == nil
// err == errors.New("some error here")

TODO:

• fix TODOs
• use DDT for some tests
• add tests that covers panic in funcs