chore: remove anonymous form function override

Author: hsilan

examples/src/main/java/software/amazon/lambda/durable/examples/callback/RetryWaitForCallbackExample.java

@@ -17,7 +17,7 @@
  * each time.
  *
  * <p>Each attempt uses a unique callback name ({@code "approval-1"}, {@code "approval-2"}, etc.) so the execution
- * history stays clean and replay-safe. The anonymous form is used, so attempts are grouped under a default-named child
+ * history stays clean and replay-safe. A {@code null} name is used, so attempts are grouped under a default-named child
  * context.
  */
 public class RetryWaitForCallbackExample extends DurableHandler<ApprovalRequest, String> {
@@ -34,6 +34,7 @@ public String handleRequest(ApprovalRequest input, DurableContext context) {
 
         // Step 2: waitForCallback with retry — if the external system fails, try again with a fresh callback
         var approvalResult = context.withRetry(
+                null,
                 (ctx, attempt) -> ctx.waitForCallback(
                         "approval-" + attempt, String.class, (callbackId, stepCtx) -> stepCtx.getLogger()
                                 .info("Attempt {}: sending callback {} to approval system", attempt, callbackId)),

examples/src/main/java/software/amazon/lambda/durable/examples/invoke/RetryInvokeExample.java

@@ -16,7 +16,7 @@
  * uses a unique operation name ({@code "call-greeting-1"}, {@code "call-greeting-2"}, etc.) so the execution history
  * stays clean and replay-safe.
  *
- * <p>The anonymous form is used, so attempts are grouped under a default-named child context.
+ * <p>A {@code null} name is used, so attempts are grouped under a default-named child context.
  */
 public class RetryInvokeExample extends DurableHandler<GreetingRequest, String> {
 
@@ -25,6 +25,7 @@ public class RetryInvokeExample extends DurableHandler<GreetingRequest, String>
     @Override
     public String handleRequest(GreetingRequest input, DurableContext context) {
         return context.withRetry(
+                null,
                 (ctx, attempt) -> ctx.invoke(
                         "call-greeting-" + attempt,
                         "simple-step-example" + input.getName() + ":$LATEST",

sdk-integration-tests/src/test/java/software/amazon/lambda/durable/RetryInvokeIntegrationTest.java

@@ -21,6 +21,7 @@ void invokeSucceedsOnFirstAttempt() {
         var runner = LocalDurableTestRunner.create(
                 String.class,
                 (input, context) -> context.withRetry(
+                        null,
                         (ctx, attempt) -> ctx.invoke("invoke-" + attempt, "target-fn", "{}", String.class),
                         WithRetryConfig.builder()
                                 .retryStrategy(RetryStrategies.fixedDelay(3, Duration.ofSeconds(2)))
@@ -41,6 +42,7 @@ void invokeRetriesAfterFailure() {
         var runner = LocalDurableTestRunner.create(
                 String.class,
                 (input, context) -> context.withRetry(
+                        null,
                         (ctx, attempt) -> ctx.invoke("invoke-" + attempt, "target-fn", "{}", String.class),
                         WithRetryConfig.builder()
                                 .retryStrategy(RetryStrategies.fixedDelay(3, Duration.ofSeconds(2)))
@@ -78,6 +80,7 @@ void invokeFailsAfterAllRetriesExhausted() {
         var runner = LocalDurableTestRunner.create(
                 String.class,
                 (input, context) -> context.withRetry(
+                        null,
                         (ctx, attempt) -> ctx.invoke("invoke-" + attempt, "target-fn", "{}", String.class),
                         WithRetryConfig.builder()
                                 .retryStrategy((error, attempt) ->
@@ -111,6 +114,7 @@ void invokeRetryWithCustomBackoffDelay() {
         var runner = LocalDurableTestRunner.create(
                 String.class,
                 (input, context) -> context.withRetry(
+                        null,
                         (ctx, attempt) -> ctx.invoke("invoke-" + attempt, "target-fn", "{}", String.class),
                         WithRetryConfig.builder()
                                 .retryStrategy((error, attempt) -> attempt < 3
@@ -144,6 +148,7 @@ void invokeRetryWithStepsBeforeAndAfter() {
             var prefix = context.step("prepare", String.class, stepCtx -> "prepared");
 
             var invokeResult = context.withRetry(
+                    null,
                     (ctx, attempt) -> ctx.invoke("invoke-" + attempt, "target-fn", "{}", String.class),
                     WithRetryConfig.builder()
                             .retryStrategy(RetryStrategies.fixedDelay(3, Duration.ofSeconds(1)))
@@ -169,6 +174,7 @@ void invokeRetryPreservesOriginalExceptionType() {
         var runner = LocalDurableTestRunner.create(String.class, (input, context) -> {
             try {
                 return context.withRetry(
+                        null,
                         (ctx, attempt) -> ctx.invoke("invoke-" + attempt, "target-fn", "{}", String.class),
                         WithRetryConfig.builder()
                                 .retryStrategy(RetryStrategies.Presets.NO_RETRY)

sdk-integration-tests/src/test/java/software/amazon/lambda/durable/RetryWaitForCallbackIntegrationTest.java

@@ -20,6 +20,7 @@ void waitForCallbackSucceedsOnFirstAttempt() {
         var runner = LocalDurableTestRunner.create(
                 String.class,
                 (input, context) -> context.withRetry(
+                        null,
                         (ctx, attempt) -> ctx.waitForCallback(
                                 "approval-" + attempt, String.class, (callbackId, stepCtx) -> stepCtx.getLogger()
                                         .info("Submitting callback {}", callbackId)),
@@ -46,6 +47,7 @@ void waitForCallbackRetriesAfterFailure() {
         var runner = LocalDurableTestRunner.create(
                 String.class,
                 (input, context) -> context.withRetry(
+                        null,
                         (ctx, attempt) -> ctx.waitForCallback(
                                 "approval-" + attempt, String.class, (callbackId, stepCtx) -> stepCtx.getLogger()
                                         .info("Attempt {} callback {}", attempt, callbackId)),
@@ -92,6 +94,7 @@ void waitForCallbackFailsAfterAllRetriesExhausted() {
         var runner = LocalDurableTestRunner.create(
                 String.class,
                 (input, context) -> context.withRetry(
+                        null,
                         (ctx, attempt) ->
                                 ctx.waitForCallback("approval-" + attempt, String.class, (callbackId, stepCtx) -> {}),
                         WithRetryConfig.builder()
@@ -129,6 +132,7 @@ void waitForCallbackRetryWithStepsBeforeAndAfter() {
             var prefix = context.step("prepare", String.class, stepCtx -> "prepared");
 
             var callbackResult = context.withRetry(
+                    null,
                     (ctx, attempt) ->
                             ctx.waitForCallback("approval-" + attempt, String.class, (callbackId, stepCtx) -> {}),
                     WithRetryConfig.builder()
@@ -157,6 +161,7 @@ void waitForCallbackRetryMultipleFailuresThenSuccess() {
         var runner = LocalDurableTestRunner.create(
                 String.class,
                 (input, context) -> context.withRetry(
+                        null,
                         (ctx, attempt) ->
                                 ctx.waitForCallback("cb-" + attempt, String.class, (callbackId, stepCtx) -> {}),
                         WithRetryConfig.builder()
@@ -202,6 +207,7 @@ void waitForCallbackRetryWithSubmitterLogic() {
         var runner = LocalDurableTestRunner.create(
                 String.class,
                 (input, context) -> context.withRetry(
+                        null,
                         (ctx, attempt) ->
                                 ctx.waitForCallback("approval-" + attempt, String.class, (callbackId, stepCtx) -> {
                                     // Submitter runs each attempt — in a real scenario this would

sdk/src/main/java/software/amazon/lambda/durable/DurableContext.java

@@ -732,7 +732,7 @@ <T> DurableFuture<T> waitForConditionAsync(
     // =============== withRetry ================
 
     /**
-     * Replay-safe retry loop for any durable operation (named form, sync).
+     * Replay-safe retry loop for any durable operation (sync).
      *
      * <p>Provides the same retry-with-backoff pattern that {@code step()} has built in, but for operations that cannot
      * live inside a step ({@code waitForCallback}, {@code invoke}, {@code waitForCondition}, etc.).
@@ -746,7 +746,8 @@ <T> DurableFuture<T> waitForConditionAsync(
      * used — no checkpointing overhead, but the child re-executes on replay.
      *
      * @param <T> the result type
-     * @param name operation name (used for backoff wait names, and as the child context name when wrapping)
+     * @param name operation name (used for backoff wait names, and as the child context name when wrapping); pass
+     *     {@code null} for an anonymous retry whose backoff waits use default names
      * @param operation the retryable operation — receives the context and 1-based attempt number
      * @param config retry configuration including the retry strategy and child context wrapping
      * @return the operation result
@@ -756,53 +757,22 @@ default <T> T withRetry(String name, WithRetry<T> operation, WithRetryConfig con
     }
 
     /**
-     * Replay-safe retry loop for any durable operation (anonymous form, sync).
+     * Replay-safe retry loop for any durable operation (async).
      *
      * <p>The retry loop always runs in a child context to provide an isolated operation ID namespace. If
      * {@link WithRetryConfig#wrapInChildContext()} is enabled, the child context is checkpointed (persisted) so all
      * attempts are grouped under a single named operation in execution history. Otherwise, a virtual child context is
      * used — no checkpointing overhead, but the child re-executes on replay.
      *
      * @param <T> the result type
-     * @param operation the retryable operation — receives the context and 1-based attempt number
-     * @param config retry configuration including the retry strategy and child context wrapping
-     * @return the operation result
-     */
-    default <T> T withRetry(WithRetry<T> operation, WithRetryConfig config) {
-        return withRetryAsync(operation, config).get();
-    }
-
-    /**
-     * Replay-safe retry loop for any durable operation (named form, async).
-     *
-     * <p>The retry loop always runs in a child context to provide an isolated operation ID namespace. If
-     * {@link WithRetryConfig#wrapInChildContext()} is enabled, the child context is checkpointed (persisted) so all
-     * attempts are grouped under a single named operation in execution history. Otherwise, a virtual child context is
-     * used — no checkpointing overhead, but the child re-executes on replay.
-     *
-     * @param <T> the result type
-     * @param name operation name (used for child context and backoff wait names)
+     * @param name operation name (used for child context and backoff wait names); pass {@code null} for an anonymous
+     *     retry whose backoff waits use default names
      * @param operation the retryable operation — receives the context and 1-based attempt number
      * @param config retry configuration including the retry strategy
      * @return a future representing the operation result
      */
     <T> DurableFuture<T> withRetryAsync(String name, WithRetry<T> operation, WithRetryConfig config);
 
-    /**
-     * Replay-safe retry loop for any durable operation (anonymous form, async).
-     *
-     * <p>The retry loop always runs in a child context to provide an isolated operation ID namespace. If
-     * {@link WithRetryConfig#wrapInChildContext()} is enabled, the child context is checkpointed (persisted) so all
-     * attempts are grouped under a single named operation in execution history. Otherwise, a virtual child context is
-     * used — no checkpointing overhead, but the child re-executes on replay.
-     *
-     * @param <T> the result type
-     * @param operation the retryable operation — receives the context and 1-based attempt number
-     * @param config retry configuration including the retry strategy
-     * @return a future representing the operation result
-     */
-    <T> DurableFuture<T> withRetryAsync(WithRetry<T> operation, WithRetryConfig config);
-
     /**
      * Function applied to each item in a map operation.
      *

sdk/src/main/java/software/amazon/lambda/durable/context/DurableContextImpl.java

@@ -238,25 +238,6 @@ private <T> DurableFuture<T> runInChildContextAsync(
             Function<DurableContext, T> func,
             RunInChildContextConfig config,
             OperationSubType subType) {
-        return runInChildContextAsync(name, resultType, func, config, subType, false);
-    }
-
-    private <T> DurableFuture<T> runInVirtualChildContextAsync(
-            String name,
-            TypeToken<T> resultType,
-            Function<DurableContext, T> func,
-            RunInChildContextConfig config,
-            OperationSubType subType) {
-        return runInChildContextAsync(name, resultType, func, config, subType, true);
-    }
-
-    private <T> DurableFuture<T> runInChildContextAsync(
-            String name,
-            TypeToken<T> resultType,
-            Function<DurableContext, T> func,
-            RunInChildContextConfig config,
-            OperationSubType subType,
-            boolean isVirtual) {
         Objects.requireNonNull(resultType, "resultType cannot be null");
         Objects.requireNonNull(config, "RunInChildContextConfig cannot be null");
         ParameterValidator.validateOperationName(name);
@@ -272,9 +253,7 @@ private <T> DurableFuture<T> runInChildContextAsync(
                 func,
                 resultType,
                 config,
-                this,
-                isVirtual,
-                null);
+                this);
 
         operation.execute();
         return operation;
@@ -402,45 +381,18 @@ public <T> DurableFuture<T> waitForConditionAsync(
     @Override
     @SuppressWarnings("unchecked")
     public <T> DurableFuture<T> withRetryAsync(String name, WithRetry<T> operation, WithRetryConfig config) {
-        Objects.requireNonNull(name, "name cannot be null");
         Objects.requireNonNull(operation, "operation cannot be null");
         Objects.requireNonNull(config, "config cannot be null");
 
-        if (config.wrapInChildContext()) {
-            return (DurableFuture<T>) runInChildContextAsync(
-                    name,
-                    new TypeToken<Object>() {},
-                    childCtx -> executeRetryLoop(childCtx, name, operation, config),
-                    RunInChildContextConfig.builder().build(),
-                    OperationSubType.WITH_RETRY);
-        }
-        return (DurableFuture<T>) runInVirtualChildContextAsync(
-                name,
-                new TypeToken<Object>() {},
-                childCtx -> executeRetryLoop(childCtx, name, operation, config),
-                RunInChildContextConfig.builder().build(),
-                OperationSubType.WITH_RETRY);
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public <T> DurableFuture<T> withRetryAsync(WithRetry<T> operation, WithRetryConfig config) {
-        Objects.requireNonNull(operation, "operation cannot be null");
-        Objects.requireNonNull(config, "config cannot be null");
+        var childContextName = name != null ? name : ANONYMOUS_CHILD_CONTEXT_NAME;
 
-        if (config.wrapInChildContext()) {
-            return (DurableFuture<T>) runInChildContextAsync(
-                    ANONYMOUS_CHILD_CONTEXT_NAME,
-                    new TypeToken<Object>() {},
-                    childCtx -> executeRetryLoop(childCtx, null, operation, config),
-                    RunInChildContextConfig.builder().build(),
-                    OperationSubType.WITH_RETRY);
-        }
-        return (DurableFuture<T>) runInVirtualChildContextAsync(
-                ANONYMOUS_CHILD_CONTEXT_NAME,
+        return (DurableFuture<T>) runInChildContextAsync(
+                childContextName,
                 new TypeToken<Object>() {},
-                childCtx -> executeRetryLoop(childCtx, null, operation, config),
-                RunInChildContextConfig.builder().build(),
+                childCtx -> executeRetryLoop(childCtx, name, operation, config),
+                RunInChildContextConfig.builder()
+                        .isVirtual(!config.wrapInChildContext())
+                        .build(),
                 OperationSubType.WITH_RETRY);
     }