start {
                thread.blockUntil.dispatched
                instant.resultAvailable
                wrappedHandler.onComplete(result)
            }
        }
        handler.onComplete(result) >> {
            instant.resultReceived
        }

        when:
        async {
            executer.run(handler)
            instant.dispatched
            thread.blockUntil.resultReceived
        }

 */
public interface RemoteConnection<T> extends Connection<T> {
    /**
     * {@inheritDoc}
     *
     * @throws MessageIOException On failure to dispatch the message to the peer.
     */
    @Override
    void dispatch(T message) throws MessageIOException;

    void flush() throws MessageIOException;

    /**
     * {@inheritDoc}

call.executeAsync().use { response ->
  withContext(Dispatchers.IO) {
    println(response.body?.string())
  }
}
```

This is implemented using `suspendCancellableCoroutine`
but uses the standard Dispatcher in OkHttp. This means
that by default Kotlin's Dispatchers are not used.

Cancellation if implemented sensibly in both directions.
Cancelling a coroutine scope, will cancel the call.

import org.apache.maven.settings.building.SettingsProblem;
import org.apache.maven.settings.building.SettingsProblem.Severity;
import org.sonatype.plexus.components.sec.dispatcher.SecDispatcher;
import org.sonatype.plexus.components.sec.dispatcher.SecDispatcherException;

/**
 * Decrypts passwords in the settings.
 *
 */
@Named
@Singleton
public class DefaultSettingsDecrypter implements SettingsDecrypter {

    /**
     * The function or variable (property) declaration.
     */
    public val signature: C get() = withValidityAssertion { backingSignature }

    /**
     * The dispatch receiver for this symbol access. Dispatch receiver is available if the symbol is declared inside a class or object.
     */
    public val dispatchReceiver: KaReceiverValue? by validityAsserted(dispatchReceiver)

    /**

            start {
                thread.blockUntil.dispatched
                instant.resultAvailable
                wrappedHandler.onComplete(result)
            }
        }
        handler.onComplete(result) >> {
            instant.resultReceived
        }

        when:
        async {
            builder.get(handler)
            instant.dispatched
            thread.blockUntil.resultReceived
        }

Maven 4 API sisu plexus inject guice plexus core distribution sec-dispatcher commons-cli utils plugin-api artifact embedder settings-builder model-builder model cipher interpolation wagon-provider-api classworlds repository-metadata settings resolver api spi impl util resolver-provider builder-support jansi slf4j-api shared-utils slf4j-provider bom toolchain-builder toolchain-model meta di xml model plugin toolchain core spi xml-impl xml settings jline3 compat slf4j-wrapper jline woodstox api-impl...

        "no argument"   | "Groovy dynamic dispatch" | { test() }                    | true           | "test()"
        "one argument"  | "Groovy dynamic dispatch" | { test(it) }                  | true           | "test(InterceptorTestReceiver)"
        "null argument" | "Groovy dynamic dispatch" | { test(null) }                | true           | "test(InterceptorTestReceiver)"

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.dispatch;

import org.gradle.internal.concurrent.Stoppable;
import org.slf4j.Logger;

public class ExceptionTrackingFailureHandler implements DispatchFailureHandler<Object>, Stoppable {
    private final Logger logger;

    }

    @Override
    public void dispatch(Object message) {
        if (message instanceof StreamedValue) {
            StreamedValue value = (StreamedValue) message;
            Object deserializedValue = payloadSerializer.deserialize(value.getSerializedModel());
            providerParameters.onStreamedValue(deserializedValue);
        } else {
            delegate.dispatch(message);
        }
    }