Is there any simple way to implement `Deferred` interface I was trying to delegate that interface to an instance returned by `async` function but it doesn t work well ``` class MyDeferred lt T gt val original Deferred lt T gt Deferred lt T gt by original MyDeferred async ``` I want to be able to call some code on async completition or execption maybe there is another way

why not just ``` suspend fun lt T R gt Deferred lt T gt and body suspend T gt R = async body await ```

Is there any simple way to implement `Deferred` interface I kotlinlang #coroutines

Channels

100daysofcode

androidgithubprojects

cincinnati-user-group

competitive-programming

event21-community-content

java-to-kotlin-refactoring

jvm-ir-backend-feedback

kotlin-multiplatform-contest

kotlinultimatechallenge

myndocs-oauth2-server

naming

navigation-architecture-component

practical-functional-programming

proguard

prozis-android-backup

refactoring-to-kotlin

russian-kotlinasfirst

skia-wasm-interop-temp

stayhungrystayfoolish

swagger-gradle-codegen

tricity-kotlin-user-group

Title

tapac

10/20/2019, 6:47 PM

Is there any simple way to implement

Deferred

interface? I was trying to delegate that interface to an instance returned by

async

function, but it doesn't work well.

class MyDeferred<T>(val original: Deferred<T>) : Deferred<T> by original

MyDeferred(async{ ...} )

I want to be able to call some code on async completition or execption, maybe there is another way?

Adam Powell

10/20/2019, 7:08 PM

what are you trying to do more specifically?

if you control the code inside the

async {}

block,

async {
  try {
    stuff()
  } finally {
    codeToRunOnCompletion()
  }
}

if you don't,

try {
  theDeferred.await()
} catch (e: TheExceptionThrown) {
  doStuffWith(e)
}

since many things may

.await()

on a Deferred and respond when the underlying async is done

tapac

10/20/2019, 8:41 PM

I want to make function which will return Deferred with provided fcuntion. That deferred should execute function and then do some additional work on complete or another code on exception. Like

fun <T>  executeAsync(body: ()->T) : MyDeferred<T> {
}

I want to allow users to use all standard functions which works with Deferred like

awaitAll

octylFractal

10/20/2019, 8:53 PM

just do the above, and if you need to wrap it in another

async {}

block, do so.

tapac

10/20/2019, 9:15 PM

I want to have

special

extension for

MyDeferred

which will chain executions and execute additional code only once.

fun <T, R> MyDeferred<T>.and(body: (T) -> R) : MyDeferred<R>

octylFractal

10/20/2019, 9:40 PM

why not just:

suspend fun <T, R> Deferred<T>.and(body: suspend (T) -> R) = async { body(await()) }

really sounds like you want a Flow though

Dico

10/21/2019, 2:20 AM

You can also just do

deferred.invokeOnCompletion { .... }

Doesn't seem like the right tool for your use case

Coroutines are designed explicitly to avoid the pattern that you're trying to create and use

If you want to have

map

and all those operators, you can indeed use

Flow

or you can even use Java's

CompletableFuture

. You can add the

kotlinx-coroutines-jdk8

as a dependency and call

Deferred.asCompletableFuture()

I think.

4 Views

#coroutines Join Slack