Method Detail

• <T> public static List<T> all(Object sources)

  Waits for all given sources to complete, returning their results in order. Multi-arg await(a, b, c) desugars to this.

• public static Awaitable<List<Object>> allAsync(Object sources)

  Non-blocking variant of all — returns an Awaitable.

• public static List<AwaitResult<Object>> allSettled(Object sources)

  Waits for all sources to settle (succeed or fail), returning a list of AwaitResult without throwing.

• public static Awaitable<List<AwaitResult<Object>>> allSettledAsync(Object sources)

  Non-blocking variant of allSettled — returns an Awaitable.

• <T> public static T any(Object sources)

  Returns the result of the first source to complete (success or failure).

• <T> public static Awaitable<T> anyAsync(Object sources)

  Non-blocking variant of any — returns an Awaitable.

• <T> public static Awaitable<T> async(Closure<T> closure)

  Executes the given closure asynchronously using the default executor.

• <T> public static Iterable<T> asyncGenerator(Closure<?> closure)

  Starts a generator immediately, returning an Iterable backed by a GeneratorBridge. This is the runtime entry point for async { ... yield return ... } expressions.

  Parameters:

  closure - the generator closure; receives a GeneratorBridge as first parameter

  Type Parameters:

  T - the element type

  Returns:

  an Iterable that yields values from the generator

• <T> public static T await(Awaitable<T> awaitable)

  Awaits the result of an Awaitable. Blocks the calling thread until the computation completes. The original exception is rethrown transparently.

• <T> public static T await(CompletableFuture<T> future)

  Awaits a CompletableFuture using non-interruptible join().

• <T> public static T await(CompletionStage<T> stage)

  Awaits a CompletionStage by converting to CompletableFuture.

• <T> public static T await(Future<T> future)

  Awaits a Future. Delegates to the CF overload if applicable.

• <T> public static T await(Object source)

  Awaits an arbitrary object by adapting it via Awaitable.from. This is the fallback overload called by compiler-generated await expressions.

• public static void closeIterable(Object source)

  Closes a source if it implements Closeable or AutoCloseable. Called by compiler-generated finally block in for await loops.

• <T> public static Awaitable<T> completeOnTimeout(Object source, T fallback, long timeout, TimeUnit unit)

  Wraps a source with a timeout that uses a fallback value instead of throwing.

• <T> public static Awaitable<T> completeOnTimeoutMillis(Object source, T fallback, long millis)

  Convenience: timeout in milliseconds.

• public static Deque<Closure<?>> createDeferScope()

  Creates a new defer scope (LIFO stack of cleanup actions). Called by compiler-generated code at the start of closures containing defer statements.

• public static void defer(Deque<Closure<?>> scope, Closure<?> action)

  Registers a deferred action in the given scope. Actions execute in LIFO order when executeDeferScope is called (in the finally block).

• public static Awaitable<Void> delay(long millis)

  Returns an Awaitable that completes after the specified delay.

• public static Awaitable<Void> delay(long duration, TimeUnit unit)

  Delay with explicit time unit.

• public Awaitable<T> doCall(Object args)

• public Iterable<T> doCall(Object args)

• <T> public static Awaitable<T> executeAsync(Closure<T> closure, Executor executor)

  Executes the given closure asynchronously on the specified executor, returning an Awaitable.

• public static void executeDeferScope(Deque<Closure<?>> scope)

  Executes all deferred actions in LIFO order. If multiple actions throw, subsequent exceptions are added as suppressed. If a deferred action returns a Future/Awaitable, the result is awaited before continuing.

• <T> public static T first(Object sources)

  Returns the result of the first source to complete successfully. Only fails when all sources fail.

• <T> public static Awaitable<T> firstAsync(Object sources)

  Non-blocking variant of first — returns an Awaitable.

• public static Executor getExecutor()

  Returns the current executor used for async tasks.

• <T> public static Awaitable<T> go(Closure<T> closure)

  Lightweight task spawn. Executes the closure asynchronously using the default executor.

• public static boolean isVirtualThreadsAvailable()

  Returns true if running on JDK 21+ with virtual thread support.

• <T> public static Awaitable<T> orTimeout(Object source, long timeout, TimeUnit unit)

  Wraps a source with a timeout. If the source does not complete within the specified time, the returned Awaitable fails with TimeoutException.

• <T> public static Awaitable<T> orTimeoutMillis(Object source, long millis)

  Convenience: timeout in milliseconds.

• public static void resetExecutor()

  Resets the executor to the default (virtual threads on JDK 21+, cached pool otherwise).

• public static void setExecutor(Executor executor)

  Sets the executor used for async tasks.

• <T> public static Iterable<T> toIterable(Object source)

  Converts an arbitrary source to an Iterable for use in for await loops. Handles arrays, collections, iterables, iterators, and adapter-supported types. The returned iterable may block on next() for async sources.

  Parameters:

  source - the source to convert

  Type Parameters:

  T - the element type

  Returns:

  an iterable

• public static Throwable unwrap(Throwable t)

• <T> public static Closure<Awaitable<T>> wrapAsync(Closure<T> closure)

  Wraps a closure so that each invocation executes the body asynchronously and returns an Awaitable. This is the runtime entry point for the async { ... } expression syntax.

  
   def task = async { expensiveWork() }
   def result = await task()  // explicit call required
   

• <T> public static Closure<Iterable<T>> wrapAsyncGenerator(Closure<?> closure)

  Wraps a generator closure so that each invocation returns an Iterable backed by a GeneratorBridge. The generator runs on a background thread and yields values via the bridge.

  This is the runtime entry point for async { ... yield return ... } expressions that contain yield return.

  Parameters:

  closure - the generator closure; receives a GeneratorBridge as first parameter

  Type Parameters:

  T - the element type

  Returns:

  a closure that produces an Iterable when called

• public static void yieldReturn(Object bridge, Object value)

  Called by compiler-generated code for yield return expr inside an async generator closure. Delegates to the bridge's yield method.

  Parameters:

  bridge - the GeneratorBridge instance (injected as synthetic parameter)

  value - the value to yield