I'm wondering:
- whether the proposed definition will result to the [Callback
Hell](https://en.wiktionary.org/wiki/callback_hell), many programming languages
tried to avoid **Callback Hell** such as `Future` in Java and `Promise` in
Javascript
- and the proposed definition seems make it difficult to synchronous calls (in
case that users need it, let's leave it possible for synchronous calls)
Can we borrow the design from The Netty Project, say returning a
`org.apache.dubbo.filter.Future` that is declared like below:
```java
class Future<T> {
T get(); // wait for the result synchronously
void onComplete(SomeContext c); // asynchronously
void onSend(SomeContext c); // asynchronously
void onError(SomeContext c); // asynchronously
// ... other callbacks
}
```
then users can do something like this:
```java
Filter filter = ...;
Future f = filter.invoke(...);
// if synchronous call is needed
f.get();
// if asynchronous call is needed
f.onSend(context -> { /* lambda */ });
f.onError(context -> { /* lambda */ });
// ... others
```
[ Full content available at:
https://github.com/apache/incubator-dubbo/issues/3585 ]
This message was relayed via gitbox.apache.org for
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
