Minor tweaks

Author: daniellansun

src/main/java/groovy/concurrent/Awaitable.java

@@ -233,20 +233,18 @@ default <U> Awaitable<U> handle(BiFunction<? super T, Throwable, ? extends U> fn
 
     /**
      * Returns a new {@code Awaitable} that fails with {@link TimeoutException}
-     * if this computation does not complete within the specified duration.
+     * if this computation does not complete within the specified milliseconds.
      * <p>
      * Unlike {@link #get(long, TimeUnit)}, this is a non-blocking, composable
      * timeout combinator: it returns another {@code Awaitable} that can itself
      * be awaited, chained, or passed to {@link #all(Object...)} / {@link #any(Object...)}.
-     * This plays a role similar to Kotlin's {@code withTimeout} while
-     * preserving Groovy's awaitable abstraction.
      *
-     * @param duration the timeout duration in milliseconds
+     * @param timeoutMillis the timeout duration in milliseconds
      * @return a new awaitable with timeout semantics
      * @since 6.0.0
      */
-    default Awaitable<T> orTimeout(long duration) {
-        return Awaitable.timeout(this, duration, TimeUnit.MILLISECONDS);
+    default Awaitable<T> orTimeoutMillis(long timeoutMillis) {
+        return Awaitable.orTimeout(this, timeoutMillis, TimeUnit.MILLISECONDS);
     }
 
     /**
@@ -259,20 +257,20 @@ default Awaitable<T> orTimeout(long duration) {
      * @since 6.0.0
      */
     default Awaitable<T> orTimeout(long duration, TimeUnit unit) {
-        return Awaitable.timeout(this, duration, unit);
+        return Awaitable.orTimeout(this, duration, unit);
     }
 
     /**
      * Returns a new {@code Awaitable} that completes with the supplied fallback
      * value if this computation does not finish before the timeout expires.
      *
      * @param fallback the value to use when the timeout expires
-     * @param duration the timeout duration in milliseconds
+     * @param timeoutMillis the timeout duration in milliseconds
      * @return a new awaitable that yields either the original result or the fallback
      * @since 6.0.0
      */
-    default Awaitable<T> completeOnTimeout(T fallback, long duration) {
-        return Awaitable.timeoutOr(this, fallback, duration, TimeUnit.MILLISECONDS);
+    default Awaitable<T> completeOnTimeoutMillis(T fallback, long timeoutMillis) {
+        return Awaitable.completeOnTimeout(this, fallback, timeoutMillis, TimeUnit.MILLISECONDS);
     }
 
     /**
@@ -286,7 +284,7 @@ default Awaitable<T> completeOnTimeout(T fallback, long duration) {
      * @since 6.0.0
      */
     default Awaitable<T> completeOnTimeout(T fallback, long duration, TimeUnit unit) {
-        return Awaitable.timeoutOr(this, fallback, duration, unit);
+        return Awaitable.completeOnTimeout(this, fallback, duration, unit);
     }
 
     /**
@@ -406,68 +404,74 @@ static Awaitable<Void> delay(long duration, TimeUnit unit) {
         return AsyncSupport.delay(duration, unit);
     }
 
+    // ---- Timeout combinators ----
+
     /**
      * Adapts the given source to an {@code Awaitable} and applies a non-blocking
-     * timeout to it.
+     * fail-fast timeout.  Returns a new awaitable that fails with
+     * {@link TimeoutException} if the source does not complete before the
+     * deadline elapses.
      * <p>
      * The source may be a Groovy {@link Awaitable}, a JDK
      * {@link CompletableFuture}/{@link java.util.concurrent.CompletionStage},
      * or any type supported by {@link AwaitableAdapterRegistry}.  This provides
      * a concise timeout combinator analogous to Kotlin's {@code withTimeout},
      * but as a value-level operation that returns another awaitable.
      *
-     * @param source the async source to time out
-     * @param duration the timeout duration in milliseconds
-     * @return a new awaitable that fails with {@link TimeoutException} on timeout
+     * @param source        the async source to time out
+     * @param timeoutMillis the timeout duration in milliseconds
+     * @param <T>           the result type
+     * @return a new awaitable with timeout semantics
      * @since 6.0.0
      */
-    static <T> Awaitable<T> timeout(Object source, long duration) {
-        return AsyncSupport.timeout(source, duration, TimeUnit.MILLISECONDS);
+    static <T> Awaitable<T> orTimeoutMillis(Object source, long timeoutMillis) {
+        return AsyncSupport.orTimeout(source, timeoutMillis, TimeUnit.MILLISECONDS);
     }
 
     /**
-     * Adapts the given source to an {@code Awaitable} and applies a non-blocking
-     * timeout to it.
+     * Adapts the given source and applies a non-blocking fail-fast timeout
+     * with explicit {@link TimeUnit}.
      *
-     * @param source the async source to time out
+     * @param source   the async source to time out
      * @param duration the timeout duration
-     * @param unit the time unit
-     * @return a new awaitable that fails with {@link TimeoutException} on timeout
+     * @param unit     the time unit
+     * @param <T>      the result type
+     * @return a new awaitable with timeout semantics
      * @since 6.0.0
      */
-    static <T> Awaitable<T> timeout(Object source, long duration, TimeUnit unit) {
-        return AsyncSupport.timeout(source, duration, unit);
+    static <T> Awaitable<T> orTimeout(Object source, long duration, TimeUnit unit) {
+        return AsyncSupport.orTimeout(source, duration, unit);
     }
 
     /**
-     * Adapts the given source to an {@code Awaitable} and returns a new
-     * awaitable that yields the supplied fallback value if the timeout expires
-     * first.
+     * Adapts the given source and returns a new awaitable that yields the
+     * supplied fallback value if the timeout expires first.
      *
-     * @param source the async source to wait for
-     * @param fallback the fallback value to use on timeout
-     * @param duration the timeout duration in milliseconds
+     * @param source        the async source to wait for
+     * @param fallback      the fallback value to use on timeout
+     * @param timeoutMillis the timeout duration in milliseconds
+     * @param <T>           the result type
      * @return a new awaitable yielding either the original result or the fallback
      * @since 6.0.0
      */
-    static <T> Awaitable<T> timeoutOr(Object source, T fallback, long duration) {
-        return AsyncSupport.timeoutOr(source, fallback, duration, TimeUnit.MILLISECONDS);
+    static <T> Awaitable<T> completeOnTimeoutMillis(Object source, T fallback, long timeoutMillis) {
+        return AsyncSupport.completeOnTimeout(source, fallback, timeoutMillis, TimeUnit.MILLISECONDS);
     }
 
     /**
-     * Adapts the given source to an {@code Awaitable} and returns a new
-     * awaitable that yields the supplied fallback value if the timeout expires
-     * first.
+     * Adapts the given source and returns a new awaitable that yields the
+     * supplied fallback value if the timeout expires first.
      *
-     * @param source the async source to wait for
+     * @param source   the async source to wait for
      * @param fallback the fallback value to use on timeout
      * @param duration the timeout duration
-     * @param unit the time unit
+     * @param unit     the time unit
+     * @param <T>      the result type
      * @return a new awaitable yielding either the original result or the fallback
      * @since 6.0.0
      */
-    static <T> Awaitable<T> timeoutOr(Object source, T fallback, long duration, TimeUnit unit) {
-        return AsyncSupport.timeoutOr(source, fallback, duration, unit);
+    static <T> Awaitable<T> completeOnTimeout(Object source, T fallback, long duration, TimeUnit unit) {
+        return AsyncSupport.completeOnTimeout(source, fallback, duration, unit);
     }
 
     // ---- Executor configuration ----