doc: add examples.

Author: ghosind

all_test.go

@@ -3,6 +3,7 @@ package async
 import (
 	"context"
 	"errors"
+	"fmt"
 	"testing"
 	"time"
 
@@ -109,6 +110,20 @@ func BenchmarkAll(b *testing.B) {
 	All(tasks...)
 }
 
+func ExampleAll() {
+	out, err := All(func() int {
+		time.Sleep(100 * time.Millisecond)
+		return 1
+	}, func() int {
+		return 2
+	})
+	fmt.Println(out)
+	fmt.Println(err)
+	// Output:
+	// [[1] [2]]
+	// <nil>
+}
+
 func TestAllCompletedWithoutFuncs(t *testing.T) {
 	a := assert.New(t)
 
@@ -218,3 +233,17 @@ func BenchmarkAllCompleted(b *testing.B) {
 
 	AllCompleted(tasks...)
 }
+
+func ExampleAllCompleted() {
+	out, err := AllCompleted(func() (int, error) {
+		time.Sleep(100 * time.Millisecond)
+		return 1, nil
+	}, func() error {
+		return errors.New("expected error")
+	})
+	fmt.Println(out)
+	fmt.Println(err)
+	// Outputs:
+	// [[1 <nil>] [expected error]]
+	// function 1 error: expected error
+}

forever_test.go

@@ -3,6 +3,7 @@ package async
 import (
 	"context"
 	"errors"
+	"fmt"
 	"testing"
 
 	"github.com/ghosind/go-assert"
@@ -64,3 +65,22 @@ func TestForeverWithContext(t *testing.T) {
 	a.EqualNow(i, 5)
 	a.EqualNow(v, []int{0, 0, 1, 1})
 }
+
+func ExampleForever() {
+	err := Forever(func(ctx context.Context, next func(context.Context)) error {
+		val := ctx.Value("key")
+		if val == nil {
+			//lint:ignore SA1029 for test case only
+			next(context.WithValue(ctx, "key", 1))
+		} else if v := val.(int); v < 5 {
+			//lint:ignore SA1029 for test case only
+			next(context.WithValue(ctx, "key", v+1))
+		} else {
+			return errors.New("value is 5")
+		}
+
+		return nil
+	})
+	fmt.Println(err)
+	// value is 5
+}

parallel_test.go

@@ -3,6 +3,7 @@ package async
 import (
 	"context"
 	"errors"
+	"fmt"
 	"testing"
 	"time"
 
@@ -154,6 +155,27 @@ func BenchmarkParallel(b *testing.B) {
 	Parallel(5, tasks...)
 }
 
+func ExampleParallel() {
+	start := time.Now()
+	out, err := Parallel(2, func() int {
+		time.Sleep(50 * time.Millisecond)
+		return 1
+	}, func() int {
+		time.Sleep(50 * time.Millisecond)
+		return 2
+	}, func() int {
+		time.Sleep(50 * time.Millisecond)
+		return 3
+	})
+	fmt.Println(time.Since(start))
+	fmt.Println(out)
+	fmt.Println(err)
+	// Outputs:
+	// 101.210974ms
+	// [[1] [2] [3]]
+	// <nil>
+}
+
 func TestParallelCompleted(t *testing.T) {
 	a := assert.New(t)
 
@@ -311,3 +333,24 @@ func BenchmarkParallelCompleted(b *testing.B) {
 
 	ParallelCompleted(5, tasks...)
 }
+
+func ExampleParallelCompleted() {
+	start := time.Now()
+	out, err := ParallelCompleted(2, func() int {
+		time.Sleep(50 * time.Millisecond)
+		return 1
+	}, func() error {
+		time.Sleep(50 * time.Millisecond)
+		return errors.New("expected error")
+	}, func() int {
+		time.Sleep(50 * time.Millisecond)
+		return 3
+	})
+	fmt.Println(time.Since(start))
+	fmt.Println(out)
+	fmt.Println(err)
+	// Outputs:
+	// 101.210974ms
+	// [[1] [expected error] [3]]
+	// function 1 error: expected error
+}

race_test.go

@@ -3,6 +3,7 @@ package async
 import (
 	"context"
 	"errors"
+	"fmt"
 	"testing"
 	"time"
 
@@ -128,3 +129,23 @@ func BenchmarkRace(b *testing.B) {
 
 	Race(tasks...)
 }
+
+func ExampleRace() {
+	start := time.Now()
+	out, index, err := Race(func() int {
+		time.Sleep(50 * time.Millisecond)
+		return 1
+	}, func() int {
+		time.Sleep(20 * time.Millisecond)
+		return 2
+	})
+	fmt.Println(time.Since(start))
+	fmt.Println(out)
+	fmt.Println(index)
+	fmt.Println(err)
+	// Outputs:
+	// 20.678486ms
+	// [2]
+	// 1
+	// <nil>
+}