A modern programming language that makes developers happier.

kotlinlang

hi guys, what type of programming feature that enables us to use `launch` and `delay` functions inside coroutine?
```fun main() = runBlocking { // this: CoroutineScope
    launch { // launch a new coroutine and continue
        delay(1000L) // non-blocking delay for 1 second (default time unit is ms)
        println("World!") // print after delay
    }
    println("Hello") // main coroutine continues while a previous one is delayed
}```

Which kinda name are you looking for? red/blue functions? `suspend`? Coroutines?

no, the `launch` and `delay` methods, why we can access them?

Ah, Kotlin allows you to set a scope for blocks, so `lauch` is basically
```kotlin
runBlocking { scope -&gt;
  scope.launch { ...```
AFAIK

Ah right, markdown in Slack is still barebones :disappointed:

isee, so it’s actually the property of the first parameter in lambda functions..
is it only for first parameter that we can refer its property or for any parameters? could u point me to some docs?

I think you gotta do some more than just first parameter, but don't have any docs at the ready.

it’s probably called extension function,,
which extends `CoroutineScope`
:thinking_face::man-shrugging:

I think you might be looking for the term <https://kotlinlang.org/docs/lambdas.html#function-literals-with-receiver|"function literal with receiver">.

The `runBlocking` function takes such an argument (the code block that you supply) in the form `block: suspend CoroutineScope.() -&gt; T`. So inside the code block you provide to the `runBlocking` function, `CoroutineScope` becomes the implicit `this`, meaning that you can call functions from the `CoroutineScope` class, like `launch` and `delay` . The `runBlocking` function then runs your code block, in the context of an instance of `CoroutineScope`.

Note that `delay` is just a regular suspend function.