A modern programming language that makes developers happier.

kotlinlang

Hi guys, quick question, does `async` executed inside a `coroutineScope` finishes before the block exits? (i mean, `coroutineScope` waits `async` , just like it does for `launch`)

but only if you start this async using scope of coroutineScope, not some external scope

now I was wondering of a compiler plugin or language feature for:
```val foo: Deffered&lt;Int&gt;
corotineScope {
   foo = async { bar() }
}
foo * 2 // foo is smart casted to Int```


I actually even not sure what you trying to achieve, your sample is redundand, you can just do this:
`bar() * 2`

also even in your example it’s incorrect, it should be like this:
```val foo: Deffered&lt;Int&gt;
corotineScope {
   foo = async { bar() }
}
foo.await() * 2```


the idea was `await` not being needed as `async`  was called in the block scope

why it’s not needed? I don’t understand why you think so

it cannot cast Deferred&lt;Int&gt; to Int

and as I said, I just don’t see why you need corotineScope or async for this example

.await() return immediately, because value of async already there

&gt; but only if you start this async using scope of coroutineScope, not some external scope
becaus eby your comment, at that stage the `async`  has finished, so it can actually be smart casted

&gt; and as I said, I just don’t see why you need corotineScope or async for this example
Sorry, could have been a better example, image `bar`takes a while, and there are more stuff in the `coroutineScope` block, including other coroutines being launch/async

If you provide such example, we can discuss it, existing example in isolation doesn’t look as something real what should be fixed with  a new language feature

one more concideration why such “smart cast” is impossible, because Deferred has more information that just value, it also may include Exception and it always has current state

even if corotineScope is returned it doesn’t mean that you have value inside