feat: add Promise.try functionality

Author: fupengl

examples_test.go

@@ -358,3 +358,78 @@ func ExamplePromisify() {
 	fmt.Println(result)
 	// Output: data from database
 }
+
+// ExampleTry demonstrates basic usage of Try
+func ExampleTry() {
+	// Basic usage
+	promise := Try(func() string {
+		return "Hello, World!"
+	})
+
+	result, err := promise.Await()
+	if err != nil {
+		fmt.Printf("Error: %v\n", err)
+		return
+	}
+	fmt.Println(result)
+	// Output: Hello, World!
+}
+
+// ExampleTryWithError demonstrates usage of TryWithError
+func ExampleTryWithError() {
+	// With Go's standard error pattern
+	promise := TryWithError(func() (int, error) {
+		// Simulate some operation that might fail
+		if time.Now().Second()%2 == 0 {
+			return 42, nil
+		}
+		return 0, errors.New("operation failed")
+	})
+
+	result, err := promise.Await()
+	if err != nil {
+		fmt.Printf("Error: %v\n", err)
+		return
+	}
+	fmt.Printf("Result: %d\n", result)
+}
+
+// ExampleTryWithMgr demonstrates usage of TryWithMgr with custom manager
+func ExampleTryWithMgr() {
+	// Create a custom manager
+	manager := NewPromiseMgr(2)
+	defer manager.Close()
+
+	// Use TryWithMgr with custom manager
+	promise := TryWithMgr(manager, func() string {
+		return "Hello from custom manager!"
+	})
+
+	result, err := promise.Await()
+	if err != nil {
+		fmt.Printf("Error: %v\n", err)
+		return
+	}
+	fmt.Println(result)
+	// Output: Hello from custom manager!
+}
+
+// ExampleTryWithErrorAndMgr demonstrates usage of TryWithErrorAndMgr
+func ExampleTryWithErrorAndMgr() {
+	// Create a custom manager
+	manager := NewPromiseMgr(2)
+	defer manager.Close()
+
+	// Use TryWithErrorAndMgr with custom manager
+	promise := TryWithErrorAndMgr(manager, func() (string, error) {
+		return "Success with custom manager!", nil
+	})
+
+	result, err := promise.Await()
+	if err != nil {
+		fmt.Printf("Error: %v\n", err)
+		return
+	}
+	fmt.Println(result)
+	// Output: Success with custom manager!
+}

promise_static.go

@@ -187,3 +187,48 @@ func Reduce[T any, R any](items []T, fn func(R, T) *Promise[R], initial R) *Prom
 
 	return Resolve(result)
 }
+
+// Try executes a function and returns a Promise that resolves with the result
+// or rejects with any error/panic that occurs during execution
+// This is similar to Node.js's Promise.try()
+func Try[T any](fn func() T) *Promise[T] {
+	return New(func(resolve func(T), reject func(error)) {
+		result := fn()
+		resolve(result)
+	})
+}
+
+// TryWithMgr executes a function using the specified manager and returns a Promise
+// that resolves with the result or rejects with any error/panic that occurs during execution
+func TryWithMgr[T any](manager *PromiseMgr, fn func() T) *Promise[T] {
+	return NewWithMgr(manager, func(resolve func(T), reject func(error)) {
+		result := fn()
+		resolve(result)
+	})
+}
+
+// TryWithError executes a function that returns (T, error) and returns a Promise
+// This is useful for Go functions that follow the standard (value, error) return pattern
+func TryWithError[T any](fn func() (T, error)) *Promise[T] {
+	return New(func(resolve func(T), reject func(error)) {
+		result, err := fn()
+		if err != nil {
+			reject(err)
+		} else {
+			resolve(result)
+		}
+	})
+}
+
+// TryWithErrorAndMgr executes a function that returns (T, error) using the specified manager
+// and returns a Promise. This is useful for Go functions that follow the standard (value, error) return pattern
+func TryWithErrorAndMgr[T any](manager *PromiseMgr, fn func() (T, error)) *Promise[T] {
+	return NewWithMgr(manager, func(resolve func(T), reject func(error)) {
+		result, err := fn()
+		if err != nil {
+			reject(err)
+		} else {
+			resolve(result)
+		}
+	})
+}

promise_test.go

@@ -1223,3 +1223,114 @@ func TestErrorHandlingOptimization(t *testing.T) {
 		t.Errorf("Expected cause to be original error, but got: %v", promiseErr2.Cause)
 	}
 }
+
+// TestTry tests the Try function
+func TestTry(t *testing.T) {
+	t.Run("Try with successful function", func(t *testing.T) {
+		promise := Try(func() string {
+			return "success"
+		})
+
+		result, err := promise.Await()
+		if err != nil {
+			t.Errorf("Expected no error, got %v", err)
+		}
+		if result != "success" {
+			t.Errorf("Expected 'success', got %s", result)
+		}
+	})
+
+	t.Run("Try with panic", func(t *testing.T) {
+		promise := Try(func() string {
+			panic("test panic")
+		})
+
+		_, err := promise.Await()
+		if err == nil {
+			t.Error("Expected error for panic, got nil")
+		}
+
+		var promiseErr *PromiseError
+		if !errors.As(err, &promiseErr) {
+			t.Error("Expected PromiseError type")
+		}
+		if promiseErr.Type != PanicError {
+			t.Errorf("Expected PanicError type, got %v", promiseErr.Type)
+		}
+	})
+
+	t.Run("Try with error panic", func(t *testing.T) {
+		testErr := errors.New("test error")
+		promise := Try(func() string {
+			panic(testErr)
+		})
+
+		_, err := promise.Await()
+		if err == nil {
+			t.Error("Expected error for panic, got nil")
+		}
+
+		var promiseErr *PromiseError
+		if !errors.As(err, &promiseErr) {
+			t.Error("Expected PromiseError type")
+		}
+		if promiseErr.Type != PanicError {
+			t.Errorf("Expected PanicError type, got %v", promiseErr.Type)
+		}
+		if promiseErr.Cause != testErr {
+			t.Errorf("Expected cause to be testErr, got %v", promiseErr.Cause)
+		}
+	})
+}
+
+// TestTryWithError tests the TryWithError function
+func TestTryWithError(t *testing.T) {
+	t.Run("TryWithError with successful function", func(t *testing.T) {
+		promise := TryWithError(func() (string, error) {
+			return "success", nil
+		})
+
+		result, err := promise.Await()
+		if err != nil {
+			t.Errorf("Expected no error, got %v", err)
+		}
+		if result != "success" {
+			t.Errorf("Expected 'success', got %s", result)
+		}
+	})
+
+	t.Run("TryWithError with error return", func(t *testing.T) {
+		testErr := errors.New("test error")
+		promise := TryWithError(func() (string, error) {
+			return "", testErr
+		})
+
+		_, err := promise.Await()
+		if err == nil {
+			t.Error("Expected error, got nil")
+		}
+		// The error might be wrapped, so check if it contains the original error
+		if !errors.Is(err, testErr) && !strings.Contains(err.Error(), testErr.Error()) {
+			t.Errorf("Expected error to contain testErr, got %v", err)
+		}
+	})
+
+	t.Run("TryWithError with panic", func(t *testing.T) {
+		promise := TryWithError(func() (string, error) {
+			panic("test panic")
+		})
+
+		_, err := promise.Await()
+		if err == nil {
+			t.Error("Expected error for panic, got nil")
+		}
+
+		var promiseErr *PromiseError
+		if !errors.As(err, &promiseErr) {
+			t.Error("Expected PromiseError type")
+		}
+		if promiseErr.Type != PanicError {
+			t.Errorf("Expected PanicError type, got %v", promiseErr.Type)
+		}
+	})
+}