feat: add While.

Author: ghosind

while.go

@@ -0,0 +1,80 @@
+package async
+
+import (
+	"context"
+	"reflect"
+)
+
+// While repeatedly calls the function while the test function returns true. A valid test function
+// must match the following requirements.
+//
+// - The first return value of the test function must be a boolean value.
+// - It should have no parameters or accept a context only.
+//
+//	c := 0
+//	While(func() bool {
+//	  return c == 5
+//	}, func() {
+//	  c++
+//	})
+func While(testFn, fn AsyncFn) ([]any, error) {
+	return while(context.Background(), testFn, fn)
+}
+
+// WhileWithContext repeatedly calls the function with the specified context while the test
+// function returns true.
+func WhileWithContext(ctx context.Context, testFn, fn AsyncFn) ([]any, error) {
+	return while(ctx, testFn, fn)
+}
+
+// while repeatedly calls the function while the test function returns true.
+func while(parent context.Context, testFn, fn AsyncFn) ([]any, error) {
+	validateWhileFuncs(testFn, fn)
+
+	ctx := getContext(parent)
+	var out []any
+	var err error
+
+	for {
+		testOut, testErr := invokeAsyncFn(testFn, ctx, nil)
+		if testErr != nil {
+			return out, testErr
+		}
+
+		isDone := testOut[0].(bool)
+		if isDone {
+			return out, nil
+		}
+
+		out, err = invokeAsyncFn(fn, ctx, nil)
+		if err != nil {
+			break
+		}
+	}
+
+	return out, err
+}
+
+// validateWhileFuncs validates the test function and the execution function for while.
+func validateWhileFuncs(testFn, fn AsyncFn) {
+	if testFn == nil || fn == nil {
+		panic(ErrNotFunction)
+	}
+	tft := reflect.TypeOf(testFn) // reflect.Type of the test function
+	if tft.Kind() != reflect.Func || reflect.TypeOf(fn).Kind() != reflect.Func {
+		panic(ErrNotFunction)
+	}
+
+	if tft.NumOut() <= 0 || tft.Out(0).Kind() != reflect.Bool {
+		panic(ErrInvalidTestFunc)
+	}
+
+	numIn := tft.NumIn()
+	isTakeContext := isFuncTakesContext(tft)
+	if isTakeContext {
+		numIn--
+	}
+	if numIn != 0 {
+		panic(ErrInvalidTestFunc)
+	}
+}

while_test.go

@@ -0,0 +1,100 @@
+package async
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/ghosind/go-assert"
+)
+
+func TestWhile(t *testing.T) {
+	a := assert.New(t)
+	count := 0
+
+	out, err := While(func() bool {
+		return count == 5
+	}, func() int {
+		count++
+		return count
+	})
+	a.NilNow(err)
+	a.EqualNow(out, []any{5})
+}
+
+func TestWhileInvalidParameters(t *testing.T) {
+	a := assert.New(t)
+
+	a.PanicOfNow(func() {
+		While(nil, func() {})
+	}, ErrNotFunction)
+	a.PanicOfNow(func() {
+		While(func() {}, nil)
+	}, ErrNotFunction)
+	a.PanicOfNow(func() {
+		While(1, "hello")
+	}, ErrNotFunction)
+	a.PanicOfNow(func() {
+		While(func() {}, func() {})
+	}, ErrInvalidTestFunc)
+	a.NotPanicNow(func() {
+		While(func() bool { return true }, func() {})
+	})
+	a.NotPanicNow(func() {
+		While(func(ctx context.Context) bool { return true }, func() {})
+	})
+	a.PanicOfNow(func() {
+		While(func(ctx context.Context, i int) bool { return true }, func() {})
+	}, ErrInvalidTestFunc)
+}
+
+func TestWhileWithTestFunctionError(t *testing.T) {
+	a := assert.New(t)
+	expectedErr := errors.New("expected error")
+
+	out, err := While(func() bool {
+		panic(expectedErr)
+	}, func() int {
+		return 0
+	})
+	a.NotNilNow(err)
+	a.EqualNow(err, expectedErr)
+	a.EqualNow(out, []any{})
+}
+
+func TestWhileWithFunctionError(t *testing.T) {
+	a := assert.New(t)
+	expectedErr := errors.New("expected error")
+
+	out, err := While(func() bool {
+		return false
+	}, func() (int, error) {
+		return 0, expectedErr
+	})
+	a.NotNilNow(err)
+	a.EqualNow(err, expectedErr)
+	a.EqualNow(out, []any{0, expectedErr})
+}
+
+func TestWhileWithContext(t *testing.T) {
+	a := assert.New(t)
+	ctx, canFunc := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer canFunc()
+
+	start := time.Now()
+	out, err := WhileWithContext(ctx, func(ctx context.Context) bool {
+		select {
+		case <-ctx.Done():
+			return true
+		default:
+			return false
+		}
+	}, func() {
+	})
+	a.NilNow(err)
+	a.EqualNow(out, []any{})
+	dur := time.Since(start)
+	a.GteNow(dur, 100*time.Millisecond)
+	a.LteNow(dur, 150*time.Millisecond)
+}