Add groovy-reactor and groovy-rxjava adapter modules for async/await

Author: daniellansun

build.gradle

@@ -118,8 +118,6 @@ dependencies {
     testImplementation "com.thoughtworks.qdox:qdox:${versions.qdox}"
     testImplementation "com.fasterxml.jackson.core:jackson-databind:${versions.jackson}"
     testImplementation "com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:${versions.jackson}"
-    testImplementation "io.reactivex.rxjava3:rxjava:${versions.rxjava3}"
-    testImplementation "io.projectreactor:reactor-core:${versions.reactor}"
 
     testFixturesImplementation projects.groovyXml
     testFixturesImplementation projects.groovyTest

settings.gradle

@@ -66,6 +66,8 @@ def subprojects = [
         'groovy-macro',
         'groovy-macro-library',
         'groovy-nio',
+        'groovy-reactor',
+        'groovy-rxjava',
         'groovy-servlet',
         'groovy-sql',
         'groovy-swing',

src/spec/doc/core-async-await.adoc

@@ -43,7 +43,8 @@ Key capabilities include:
 * **`Awaitable.go`, `AsyncChannel`, and `Awaitable.any`** — task spawning and channel-based communication primitives
 * **Framework integration** — built-in adapters for `CompletableFuture` and `Future`;
 `Flow.Publisher` support via an auto-discovered runtime adapter;
-extensible to RxJava, Reactor, and Spring via the adapter registry
+drop-in Reactor and RxJava 3 modules (`groovy-reactor`, `groovy-rxjava`) with
+`ServiceLoader`-based auto-discovery; extensible to any framework via the adapter registry
 
 On JDK 21+, async methods automatically leverage
 {jdk}/java.base/java/lang/Thread.html#ofVirtual()[virtual threads] for optimal scalability.
@@ -133,11 +134,12 @@ The `await` keyword natively understands `CompletableFuture`, `CompletionStage`,
 include::../test/AsyncAwaitSpecTest.groovy[tags=motivation_interop,indent=0]
 ----
 
-For third-party frameworks like RxJava, Reactor, or Spring, the
-`AwaitableAdapterRegistry` SPI allows registering custom adapters so that
-`await` works transparently with _any_ asynchronous type — a single
-`await` keyword is all the application code needs, regardless of the
-underlying async library.
+For third-party frameworks like RxJava, Reactor, or Spring, Groovy provides
+dedicated adapter modules — `groovy-reactor` and `groovy-rxjava` — that are
+auto-discovered via `ServiceLoader` when placed on the classpath.
+No manual registration is required: simply add the dependency and `await`
+works transparently with `Mono`, `Flux`, `Single`, `Maybe`, `Observable`,
+and `Flowable`.
 
 === Virtual Threads: Free Scalability
 
@@ -798,18 +800,67 @@ include::../test/AsyncAwaitSpecTest.groovy[tags=adapter_registration,indent=0]
 
 === Framework Integration
 
-With appropriate adapters registered, `await` works transparently with any async type.
-Adapter implementations for frameworks such as RxJava 3, Project Reactor, and Spring
-should delegate to the framework's native blocking or conversion methods:
+Groovy ships dedicated adapter modules for the two most popular JVM reactive frameworks.
+Adding either module to the classpath enables zero-configuration `async`/`await` support
+for that framework's types — no manual adapter registration is needed.
+
+==== Project Reactor (`groovy-reactor`)
+
+The `groovy-reactor` module bridges Reactor's `Mono` and `Flux` into Groovy's async system:
+
+* `Mono<T>` → `Awaitable<T>` — use `await(mono)` to resolve the single emitted value
+* `Flux<T>` → `AsyncStream<T>` — use `for await (item in flux)` to iterate over all values
+
+[source,groovy]
+----
+// Add to classpath — adapters are auto-discovered via ServiceLoader
+// Gradle:  implementation "org.apache.groovy:groovy-reactor:${groovyVersion}"
+
+async {
+    def result = await Mono.just("hello")                // single value
+    for await (item in Flux.range(1, 5)) { use(item) }   // multi-value
+}
+----
+
+For comprehensive documentation including operators, Spring WebFlux integration, and
+`Awaitable` combinators, see the <<reactor-userguide,Project Reactor Integration>> guide.
+
+==== RxJava 3 (`groovy-rxjava`)
+
+The `groovy-rxjava` module bridges RxJava 3's types into Groovy's async system:
+
+* `Single<T>` / `Maybe<T>` → `Awaitable<T>` — use `await(single)` or `await(maybe)`
+* `Observable<T>` / `Flowable<T>` → `AsyncStream<T>` — use `for await (item in source)`
+
+[source,groovy]
+----
+// Add to classpath — adapters are auto-discovered via ServiceLoader
+// Gradle:  implementation "org.apache.groovy:groovy-rxjava:${groovyVersion}"
+
+async {
+    def result = await Single.just("hello")                   // single value
+    for await (item in Observable.range(1, 5)) { use(item) }  // multi-value
+}
+----
+
+For comprehensive documentation including `Maybe`, `Flowable`, back-pressure, and
+`Awaitable` combinators, see the <<rxjava-userguide,RxJava 3 Integration>> guide.
+
+==== Custom Adapters for Other Frameworks
+
+For frameworks not covered by the built-in modules, implement the `AwaitableAdapter` interface
+and delegate to the framework's native blocking or conversion methods:
 
-* **RxJava 3**: `Single.blockingGet()`, `Observable.blockingIterable()` (for `AsyncStream`)
-* **Reactor**: `Mono.block()`, `Flux.toIterable()` (for `AsyncStream`)
 * **Spring**: Return `Awaitable` from `@Async` service methods; adapt `ListenableFuture` via `toCompletableFuture()`
+* **Vert.x**: Adapt `io.vertx.core.Future` via `toCompletionStage()`
 
 === Automatic Discovery
 
-Adapters can also be discovered automatically via `java.util.ServiceLoader` by placing a
+Adapters are discovered automatically via `java.util.ServiceLoader` by placing a
 provider configuration file at `META-INF/services/groovy.concurrent.AwaitableAdapter`.
+The `groovy-reactor` and `groovy-rxjava` modules use this mechanism — adding them to the
+classpath is sufficient for transparent integration.
+
 SPI-discovered adapters are loaded at class-initialization time and take priority over
 the built-in adapters. Runtime-registered adapters (via `register()`) take highest
 priority, allowing application code to override any default.
@@ -1356,7 +1407,7 @@ JavaScript, C#, Kotlin, and Swift, for developers familiar with those languages.
 
 | **Async iteration**
 | `for await (x in src) { }` +
-_(supports `AsyncStream`, `Flow.Publisher`, `AsyncChannel`, `Iterable`)_
+_(supports `AsyncStream`, `Flow.Publisher`, `AsyncChannel`, `Iterable`, Reactor `Flux`, RxJava `Observable`/`Flowable`)_
 | `for await (x of src) { }`
 | `await foreach (x in src) { }`
 | _(manual via `Flow`, `AsyncChannel`, or `Flow.collect`)_
@@ -1452,7 +1503,8 @@ _(supports `AsyncStream`, `Flow.Publisher`, `AsyncChannel`, `Iterable`)_
 
 | **Third-party support**
 | `AwaitableAdapterRegistry` SPI +
-`Awaitable.from()` / `AsyncStream.from()`
+`Awaitable.from()` / `AsyncStream.from()` +
+Built-in modules: `groovy-reactor`, `groovy-rxjava`
 | _(native `thenable` protocol)_
 | Custom awaiters via `GetAwaiter()`
 | coroutine adapters / bridges
@@ -2029,4 +2081,10 @@ For full javadoc, see the API documentation for the `groovy.concurrent` package.
 
 | Executor configuration
 | `Awaitable.setExecutor(myExecutor)` / system property `groovy.async.parallelism`
+
+| Reactor integration
+| Add `groovy-reactor` to classpath; `await(mono)` / `for await (x in flux)`
+
+| RxJava 3 integration
+| Add `groovy-rxjava` to classpath; `await(single)` / `for await (x in observable)`
 |===