From 78fa7e6e54e1e535d69f11b1ac5c94992276c8d4 Mon Sep 17 00:00:00 2001
From: Mattias Reichel <mattias.reichel@gmail.com>
Date: Tue, 21 Nov 2023 14:50:22 +0100
Subject: [PATCH] Add back generic types to Promise onComplete(), onError() and
 then()

---
 .../src/main/groovy/grails/async/Promise.groovy     |  6 +++---
 .../main/groovy/grails/async/PromiseFactory.groovy  |  4 ++--
 .../src/main/groovy/grails/async/PromiseList.groovy |  6 +++---
 .../src/main/groovy/grails/async/PromiseMap.groovy  | 11 +++++++----
 .../src/main/groovy/grails/async/Promises.groovy    |  2 +-
 .../org/grails/async/factory/BoundPromise.groovy    |  8 ++++----
 .../grails/async/factory/SynchronousPromise.groovy  |  8 ++++----
 .../async/factory/SynchronousPromiseFactory.groovy  |  6 ++++--
 .../future/CachedThreadPoolPromiseFactory.groovy    | 13 ++++++++-----
 .../factory/future/FutureTaskChildPromise.groovy    |  6 +++---
 .../async/factory/future/FutureTaskPromise.groovy   |  6 +++---
 .../grails/async/factory/gpars/GparsPromise.groovy  |  8 ++++----
 .../async/factory/gpars/GparsPromiseFactory.groovy  | 10 +++++-----
 .../async/factory/rxjava/RxPromiseFactory.groovy    |  8 ++++----
 .../grails/async/factory/rxjava2/RxPromise.groovy   |  6 +++---
 .../async/factory/rxjava2/RxPromiseFactory.groovy   | 12 ++++++------
 .../main/groovy/grails/async/web/WebPromises.groovy |  4 ++--
 17 files changed, 66 insertions(+), 58 deletions(-)

diff --git a/grails-async-core/src/main/groovy/grails/async/Promise.groovy b/grails-async-core/src/main/groovy/grails/async/Promise.groovy
index cfc15eef..cf6b20af 100644
--- a/grails-async-core/src/main/groovy/grails/async/Promise.groovy
+++ b/grails-async-core/src/main/groovy/grails/async/Promise.groovy
@@ -38,7 +38,7 @@ interface Promise<T> extends Future<T> {
      * @param callable
      * @return The Promise
      */
-    Promise<?> onComplete(Closure<?> callable)
+    Promise<T> onComplete(Closure<T> callable)
 
     /**
      * Execute the given closure when an error occurs
@@ -46,10 +46,10 @@ interface Promise<T> extends Future<T> {
      * @param callable
      * @return The Promise
      */
-    Promise<?> onError(Closure<?> callable)
+    Promise<T> onError(Closure<T> callable)
 
     /**
      * Same as #onComplete
      */
-    Promise<?> then(Closure<?> callable)
+    Promise<T> then(Closure<T> callable)
 }
diff --git a/grails-async-core/src/main/groovy/grails/async/PromiseFactory.groovy b/grails-async-core/src/main/groovy/grails/async/PromiseFactory.groovy
index 8a88d1f5..033c396b 100644
--- a/grails-async-core/src/main/groovy/grails/async/PromiseFactory.groovy
+++ b/grails-async-core/src/main/groovy/grails/async/PromiseFactory.groovy
@@ -42,7 +42,7 @@ interface PromiseFactory {
      * @param decorators The decorators
      * @return The decorated closure
      */
-    <T> Closure<T> applyDecorators(Closure<?> c, List<PromiseDecorator> decorators)
+    <T> Closure<T> applyDecorators(Closure<T> c, List<PromiseDecorator> decorators)
 
     /**
      * Creates a promise with a value pre-bound to it
@@ -152,7 +152,7 @@ interface PromiseFactory {
      * @param promises The promises
      * @param callable The callback to execute
      */
-    <T> Promise<List<T>> onComplete(List<Promise<T>> promises, Closure<?> callable)
+    <T> Promise<List<T>> onComplete(List<Promise<T>> promises, Closure<T> callable)
 
     /**
      * Executes the given callback if an error occurs for the list of promises
diff --git a/grails-async-core/src/main/groovy/grails/async/PromiseList.groovy b/grails-async-core/src/main/groovy/grails/async/PromiseList.groovy
index da2c5cc4..b2b43a9f 100644
--- a/grails-async-core/src/main/groovy/grails/async/PromiseList.groovy
+++ b/grails-async-core/src/main/groovy/grails/async/PromiseList.groovy
@@ -105,17 +105,17 @@ class PromiseList<T> implements Promise<List<T>> {
      * @param callable The closure
      */
     @Override
-    Promise<?> onComplete(Closure<?> callable) {
+    Promise<List<T>> onComplete(Closure callable) {
         return Promises.onComplete(promises, callable)
     }
 
     @Override
-    Promise<?> onError(Closure<?> callable) {
+    Promise<List<T>> onError(Closure callable) {
         return Promises.onError(promises, callable)
     }
 
     @Override
-    Promise<?> then(Closure<?> callable) {
+    Promise<List<T>> then(Closure callable) {
         return Promises.onComplete(promises, { List<T> values -> return values }).then(callable)
     }
 
diff --git a/grails-async-core/src/main/groovy/grails/async/PromiseMap.groovy b/grails-async-core/src/main/groovy/grails/async/PromiseMap.groovy
index d20206cc..a3cbc41c 100644
--- a/grails-async-core/src/main/groovy/grails/async/PromiseMap.groovy
+++ b/grails-async-core/src/main/groovy/grails/async/PromiseMap.groovy
@@ -236,7 +236,8 @@ class PromiseMap<K,V> implements Promise<Map<K,V>> {
         return resultMap
     }
 
-    Promise<Map<K,V>> onComplete(Closure<?> callable) {
+    @Override
+    Promise<Map<K,V>> onComplete(Closure<Map<K,V>> callable) {
         List<Promise<V>> promises = new ArrayList<Promise<V>>(promises.values())
         Promises.onComplete(promises) { List<V> values ->
             Map<K,V> resultMap = [:]
@@ -253,16 +254,18 @@ class PromiseMap<K,V> implements Promise<Map<K,V>> {
         return this
     }
 
-    Promise<Map<K,V>> onError(Closure<?> callable) {
+    @Override
+    Promise<Map<K,V>> onError(Closure<Map<K,V>> callable) {
         Promises.onError(new ArrayList<Promise<V>>(promises.values()), callable)
         return this
     }
 
-    Promise<Map<K, V>> then(Closure<?> callable) {
+    @Override
+    Promise<Map<K, V>> then(Closure<Map<K,V>> callable) {
         return onComplete(callable)
     }
 
-    Promise<Map<K, V>> leftShift(Closure<?> callable) {
+    Promise<Map<K, V>> leftShift(Closure callable) {
         return then(callable)
     }
 }
diff --git a/grails-async-core/src/main/groovy/grails/async/Promises.groovy b/grails-async-core/src/main/groovy/grails/async/Promises.groovy
index e9947a30..a55e1f56 100644
--- a/grails-async-core/src/main/groovy/grails/async/Promises.groovy
+++ b/grails-async-core/src/main/groovy/grails/async/Promises.groovy
@@ -71,7 +71,7 @@ class Promises {
     /**
      * @see PromiseFactory#onComplete(java.util.List, groovy.lang.Closure)
      */
-    static<T> Promise<List<T>> onComplete(List<Promise<T>> promises, Closure<?> callable) {
+    static<T> Promise<List<T>> onComplete(List<Promise<T>> promises, Closure<T> callable) {
         return getPromiseFactory().onComplete(promises, callable)
     }
     /**
diff --git a/grails-async-core/src/main/groovy/org/grails/async/factory/BoundPromise.groovy b/grails-async-core/src/main/groovy/org/grails/async/factory/BoundPromise.groovy
index ffae5ccf..5aa9a4b5 100644
--- a/grails-async-core/src/main/groovy/org/grails/async/factory/BoundPromise.groovy
+++ b/grails-async-core/src/main/groovy/org/grails/async/factory/BoundPromise.groovy
@@ -67,21 +67,21 @@ class BoundPromise<T> implements Promise<T> {
         return this
     }
 
-    Promise<?> onComplete(Closure<?> callable) {
+    Promise<T> onComplete(Closure<T> callable) {
         if (!(value instanceof Throwable)) {
             return new BoundPromise(callable.call(value))
         }
         return this
     }
 
-    Promise<?> onError(Closure<?> callable) {
+    Promise<T> onError(Closure<T> callable) {
         if (value instanceof Throwable) {
             return new BoundPromise(callable.call(value))
         }
         return this
     }
 
-    Promise<?> then(Closure<?> callable) {
+    Promise<T> then(Closure<T> callable) {
         if (!(value instanceof Throwable)) {
             try {
                 return new BoundPromise(callable.call(value))
@@ -94,7 +94,7 @@ class BoundPromise<T> implements Promise<T> {
         }
     }
 
-    Promise<?> leftShift(Closure<?> callable) {
+    Promise<T> leftShift(Closure<T> callable) {
         then(callable)
     }
 }
diff --git a/grails-async-core/src/main/groovy/org/grails/async/factory/SynchronousPromise.groovy b/grails-async-core/src/main/groovy/org/grails/async/factory/SynchronousPromise.groovy
index 6c3d38b0..3410bd6a 100644
--- a/grails-async-core/src/main/groovy/org/grails/async/factory/SynchronousPromise.groovy
+++ b/grails-async-core/src/main/groovy/org/grails/async/factory/SynchronousPromise.groovy
@@ -74,24 +74,24 @@ class SynchronousPromise<T> implements Promise<T> {
         return this
     }
 
-    Promise<?> onComplete(Closure<?> callable) {
+    Promise<T> onComplete(Closure<T> callable) {
         try { callable.call(get()) }
         catch (Throwable ignored) {}
         return this
     }
 
-    Promise<?> onError(Closure<?> callable) {
+    Promise<T> onError(Closure<T> callable) {
         try { get() }
         catch (Throwable e) { callable.call(e) }
         return this
     }
 
-    Promise<?> then(Closure<?> callable) {
+    Promise<T> then(Closure<T> callable) {
         final value = get()
         return new SynchronousPromise(callable.curry(value))
     }
 
-    Promise<?> leftShift(Closure<?> callable) {
+    Promise<T> leftShift(Closure<T> callable) {
         then(callable)
     }
 }
diff --git a/grails-async-core/src/main/groovy/org/grails/async/factory/SynchronousPromiseFactory.groovy b/grails-async-core/src/main/groovy/org/grails/async/factory/SynchronousPromiseFactory.groovy
index 2ac5a11e..9b162af9 100644
--- a/grails-async-core/src/main/groovy/org/grails/async/factory/SynchronousPromiseFactory.groovy
+++ b/grails-async-core/src/main/groovy/org/grails/async/factory/SynchronousPromiseFactory.groovy
@@ -73,7 +73,8 @@ class SynchronousPromiseFactory extends AbstractPromiseFactory {
         return promises.collect { Promise<T> p -> p.get() }
     }
 
-    <T> Promise<?> onComplete(List<Promise<T>> promises, Closure<?> callable) {
+    @Override
+    <T> Promise<T> onComplete(List<Promise<T>> promises, Closure<T> callable) {
         try {
             List<T> values = promises.collect { Promise<T> p -> p.get() }
             return new BoundPromise(callable.call(values))
@@ -82,7 +83,8 @@ class SynchronousPromiseFactory extends AbstractPromiseFactory {
         }
     }
 
-    <T> Promise<?> onError(List<Promise<T>> promises, Closure<?> callable) {
+    @Override
+    <T> Promise<List<T>> onError(List<Promise<T>> promises, Closure<?> callable) {
         try {
             List<T> values = promises.collect() { Promise<T> p -> p.get() }
             return new BoundPromise<List<T>>(values)
diff --git a/grails-async-core/src/main/groovy/org/grails/async/factory/future/CachedThreadPoolPromiseFactory.groovy b/grails-async-core/src/main/groovy/org/grails/async/factory/future/CachedThreadPoolPromiseFactory.groovy
index fba0dc0a..813d2ace 100644
--- a/grails-async-core/src/main/groovy/org/grails/async/factory/future/CachedThreadPoolPromiseFactory.groovy
+++ b/grails-async-core/src/main/groovy/org/grails/async/factory/future/CachedThreadPoolPromiseFactory.groovy
@@ -73,25 +73,28 @@ class CachedThreadPoolPromiseFactory extends AbstractPromiseFactory implements C
     }
 
     @Override
-    <T> Promise<?> onComplete(List<Promise<T>> promises, Closure<?> callable) {
+    <T> Promise<List<T>> onComplete(List<Promise<T>> promises, Closure<T> callable) {
         return executorService.submit({
             while (promises.every { Promise promise -> !promise.isDone() }) {
                 // wait (is this hogging the cpu?)
             }
             List<T> values = promises.collect { Promise<T> promise -> promise.get() }
             callable.call(values)
-        }) as Promise<?>
+        }) as Promise<List<T>>
     }
 
     @Override
-    <T> Promise<?> onError(List<Promise<T>> promises, Closure<?> callable) {
+    <T> Promise<List<T>> onError(List<Promise<T>> promises, Closure<?> callable) {
         return executorService.submit({
             while (promises.every { Promise promise -> !promise.isDone() }) {
                 // wait (is this hogging the cpu?)
             }
             try { for (Promise<T> promise : promises) { promise.get() } }
-            catch (Throwable e) { callable.call(e) }
-        }) as Promise<?>
+            catch (Throwable e) {
+                callable.call(e)
+                return e
+            }
+        }) as Promise<List<T>>
     }
 
     @Override
diff --git a/grails-async-core/src/main/groovy/org/grails/async/factory/future/FutureTaskChildPromise.groovy b/grails-async-core/src/main/groovy/org/grails/async/factory/future/FutureTaskChildPromise.groovy
index 3356229c..5fd1ad18 100644
--- a/grails-async-core/src/main/groovy/org/grails/async/factory/future/FutureTaskChildPromise.groovy
+++ b/grails-async-core/src/main/groovy/org/grails/async/factory/future/FutureTaskChildPromise.groovy
@@ -57,21 +57,21 @@ class FutureTaskChildPromise<T> implements Promise<T> {
     }
 
     @Override
-    Promise<?> onComplete(Closure<?> callable) {
+    Promise<T> onComplete(Closure<T> callable) {
         def newPromise = new FutureTaskChildPromise(promiseFactory, this, callable)
         successCallbacks.add(newPromise)
         return newPromise
     }
 
     @Override
-    Promise<?> onError(Closure<?> callable) {
+    Promise<T> onError(Closure<T> callable) {
         def newPromise = new FutureTaskChildPromise(promiseFactory, this, callable)
         failureCallbacks.add(newPromise)
         return newPromise
     }
 
     @Override
-    Promise<?> then(Closure<?> callable) {
+    Promise<T> then(Closure<T> callable) {
         return onComplete(callable)
     }
 
diff --git a/grails-async-core/src/main/groovy/org/grails/async/factory/future/FutureTaskPromise.groovy b/grails-async-core/src/main/groovy/org/grails/async/factory/future/FutureTaskPromise.groovy
index 32e9d129..12b48f82 100644
--- a/grails-async-core/src/main/groovy/org/grails/async/factory/future/FutureTaskPromise.groovy
+++ b/grails-async-core/src/main/groovy/org/grails/async/factory/future/FutureTaskPromise.groovy
@@ -82,7 +82,7 @@ class FutureTaskPromise<T> extends FutureTask<T> implements Promise<T> {
     }
 
     @Override
-    Promise<?> onComplete(Closure<?> callable) {
+    Promise<T> onComplete(Closure<T> callable) {
         synchronized (successCallbacks) {
             if (isDone()) {
                 try {
@@ -101,7 +101,7 @@ class FutureTaskPromise<T> extends FutureTask<T> implements Promise<T> {
     }
 
     @Override
-    Promise<?> onError(Closure<?> callable) {
+    Promise<T> onError(Closure<T> callable) {
         synchronized (failureCallbacks) {
             if (isDone()) {
                 try {
@@ -120,7 +120,7 @@ class FutureTaskPromise<T> extends FutureTask<T> implements Promise<T> {
     }
 
     @Override
-    Promise<?> then(Closure callable) {
+    Promise<T> then(Closure<T> callable) {
         return onComplete(callable)
     }
 }
diff --git a/grails-async-gpars/src/main/groovy/org/grails/async/factory/gpars/GparsPromise.groovy b/grails-async-gpars/src/main/groovy/org/grails/async/factory/gpars/GparsPromise.groovy
index 27feaa2f..1c977eaa 100644
--- a/grails-async-gpars/src/main/groovy/org/grails/async/factory/gpars/GparsPromise.groovy
+++ b/grails-async-gpars/src/main/groovy/org/grails/async/factory/gpars/GparsPromise.groovy
@@ -78,12 +78,12 @@ class GparsPromise<T> implements Promise<T> {
         return this
     }
 
-    Promise<?> leftShift(Closure<?> callable) {
+    Promise<T> leftShift(Closure<T> callable) {
         then(callable)
     }
 
     @Override
-    Promise<?> onComplete(Closure<?> callable) {
+    Promise<T> onComplete(Closure<T> callable) {
         def decoratedCallable= promiseFactory.applyDecorators(callable, null)
         internalPromise.whenBound { T value ->
             if (!(value instanceof Throwable)) {
@@ -95,7 +95,7 @@ class GparsPromise<T> implements Promise<T> {
     }
 
     @Override
-    Promise<?> onError(Closure<?> callable) {
+    Promise<T> onError(Closure<T> callable) {
         def decoratedCallable = promiseFactory.applyDecorators(callable, null)
         internalPromise.whenBound { T value ->
             if (value instanceof Throwable) {
@@ -107,7 +107,7 @@ class GparsPromise<T> implements Promise<T> {
     }
 
     @Override
-    Promise<?> then(Closure<?> callable) {
+    Promise<T> then(Closure<T> callable) {
         def decoratedCallable = promiseFactory.applyDecorators(callable, null)
         return new GparsPromise(promiseFactory, internalPromise.then(decoratedCallable))
     }
diff --git a/grails-async-gpars/src/main/groovy/org/grails/async/factory/gpars/GparsPromiseFactory.groovy b/grails-async-gpars/src/main/groovy/org/grails/async/factory/gpars/GparsPromiseFactory.groovy
index 0e433513..a8f27bac 100644
--- a/grails-async-gpars/src/main/groovy/org/grails/async/factory/gpars/GparsPromiseFactory.groovy
+++ b/grails-async-gpars/src/main/groovy/org/grails/async/factory/gpars/GparsPromiseFactory.groovy
@@ -100,18 +100,18 @@ class GparsPromiseFactory extends AbstractPromiseFactory {
     }
 
     @Override
-    <T> Promise<?> onComplete(List<Promise<T>> promises, Closure<?> callable) {
-        return new GparsPromise<?>(
+    <T> Promise<T> onComplete(List<Promise<T>> promises, Closure<T> callable) {
+        return new GparsPromise<T>(
             this,
             Dataflow.whenAllBound(toGparsPromises(promises), callable as Closure)
         )
     }
 
     @Override
-    <T> Promise<?> onError(List<Promise<T>> promises, Closure<?> callable) {
-        return new GparsPromise<?>(
+    <T> Promise<List<T>> onError(List<Promise<T>> promises, Closure<?> callable) {
+        return new GparsPromise<List<T>>(
             this,
-            Dataflow.whenAllBound(toGparsPromises(promises), {} as Closure<T>, callable as Closure)
+            Dataflow.whenAllBound(toGparsPromises(promises), {} as Closure<T>, callable as Closure<T>)
         )
     }
 }
diff --git a/grails-async-rxjava/src/main/groovy/org/grails/async/factory/rxjava/RxPromiseFactory.groovy b/grails-async-rxjava/src/main/groovy/org/grails/async/factory/rxjava/RxPromiseFactory.groovy
index af18ccef..04935278 100644
--- a/grails-async-rxjava/src/main/groovy/org/grails/async/factory/rxjava/RxPromiseFactory.groovy
+++ b/grails-async-rxjava/src/main/groovy/org/grails/async/factory/rxjava/RxPromiseFactory.groovy
@@ -57,8 +57,8 @@ class RxPromiseFactory extends AbstractPromiseFactory {
     }
 
     @Override
-    <T> Promise<?> onComplete(List<Promise<T>> promises, Closure<?> callable) {
-        new RxPromise<>(this, Observable.concat(
+    <T> Promise<T> onComplete(List<Promise<T>> promises, Closure<T> callable) {
+        new RxPromise<T>(this, Observable.concat(
                 promises.collect() { Promise p ->
                     if(p instanceof BoundPromise) {
                         return Observable.just(((BoundPromise)p).value)
@@ -72,8 +72,8 @@ class RxPromiseFactory extends AbstractPromiseFactory {
     }
 
     @Override
-    <T> Promise<?> onError(List<Promise<T>> promises, Closure<?> callable) {
-        new RxPromise<>(this, Observable.concat(
+    <T> Promise<T> onError(List<Promise<T>> promises, Closure<?> callable) {
+        new RxPromise<T>(this, Observable.concat(
                 promises.collect() { Promise p -> ((RxPromise)p).subject as Observable<T> }
         ).toList())
         .onError(callable)
diff --git a/grails-async-rxjava2/src/main/groovy/org/grails/async/factory/rxjava2/RxPromise.groovy b/grails-async-rxjava2/src/main/groovy/org/grails/async/factory/rxjava2/RxPromise.groovy
index a60c7f1c..78d36222 100644
--- a/grails-async-rxjava2/src/main/groovy/org/grails/async/factory/rxjava2/RxPromise.groovy
+++ b/grails-async-rxjava2/src/main/groovy/org/grails/async/factory/rxjava2/RxPromise.groovy
@@ -100,19 +100,19 @@ class RxPromise<T>  implements Promise<T> {
     }
 
     @Override
-    Promise<?> onComplete(Closure callable) {
+    Promise<T> onComplete(Closure<T> callable) {
         def decoratedCallable = promiseFactory.applyDecorators(callable, null)
         return new RxPromise<T>(promiseFactory, subject.map(decoratedCallable as Function<T, T>))
     }
 
     @Override
-    Promise<?> onError(Closure callable) {
+    Promise<T> onError(Closure<T> callable) {
         def decoratedCallable = promiseFactory.applyDecorators(callable, null)
         return new RxPromise<T>(promiseFactory, subject.doOnError(decoratedCallable as Consumer<Throwable>))
     }
 
     @Override
-    Promise<?> then(Closure callable) {
+    Promise<T> then(Closure<T> callable) {
         return onComplete(callable)
     }
 
diff --git a/grails-async-rxjava2/src/main/groovy/org/grails/async/factory/rxjava2/RxPromiseFactory.groovy b/grails-async-rxjava2/src/main/groovy/org/grails/async/factory/rxjava2/RxPromiseFactory.groovy
index d1ceb8f9..94c80649 100644
--- a/grails-async-rxjava2/src/main/groovy/org/grails/async/factory/rxjava2/RxPromiseFactory.groovy
+++ b/grails-async-rxjava2/src/main/groovy/org/grails/async/factory/rxjava2/RxPromiseFactory.groovy
@@ -57,8 +57,8 @@ class RxPromiseFactory extends AbstractPromiseFactory {
     }
 
     @Override
-    <T> Promise<?> onComplete(List<Promise<T>> promises, Closure<?> callable) {
-        new RxPromise<>(this, Observable.concat(
+    <T> Promise<T> onComplete(List<Promise<T>> promises, Closure<T> callable) {
+        new RxPromise<T>(this, Observable.concat(
             promises.collect { Promise p ->
                 if(p instanceof BoundPromise) {
                     return Observable.just(((BoundPromise)p).value) as Observable<T>
@@ -72,10 +72,10 @@ class RxPromiseFactory extends AbstractPromiseFactory {
     }
 
     @Override
-    <T> Promise<?> onError(List<Promise<T>> promises, Closure<?> callable) {
-        new RxPromise<>(this, Observable.concat(
-                promises.collect { Promise p -> ((RxPromise)p).toObservable() as Observable<T> }
+    <T> Promise<List<T>> onError(List<Promise<T>> promises, Closure<?> callable) {
+        new RxPromise(this, Observable.concat(
+                promises.collect { ((RxPromise<T>)it).toObservable() }
         ).toList())
-        .onError(callable)
+        .onError(callable) as Promise<List<T>>
     }
 }
diff --git a/grails-plugin-async/src/main/groovy/grails/async/web/WebPromises.groovy b/grails-plugin-async/src/main/groovy/grails/async/web/WebPromises.groovy
index 5b069020..5124debf 100644
--- a/grails-plugin-async/src/main/groovy/grails/async/web/WebPromises.groovy
+++ b/grails-plugin-async/src/main/groovy/grails/async/web/WebPromises.groovy
@@ -61,13 +61,13 @@ class WebPromises {
     /**
      * @see grails.async.PromiseFactory#onComplete(java.util.List, groovy.lang.Closure)
      */
-    static<T> Promise<List<T>> onComplete(List<Promise<T>> promises, Closure<?> callable ) {
+    static<T> Promise<List<T>> onComplete(List<Promise<T>> promises, Closure<T> callable) {
         return getPromiseFactory().onComplete(promises, callable)
     }
     /**
      * @see grails.async.PromiseFactory#onError(java.util.List, groovy.lang.Closure)
      */
-    static<T> Promise<List<T>> onError(List<Promise<T>> promises, Closure<?> callable ) {
+    static<T> Promise<List<T>> onError(List<Promise<T>> promises, Closure<?> callable) {
         return getPromiseFactory().onError(promises, callable)
     }
     /**