So these are the definitions of the 5 kotlin scopi...

# announcements

[Nezteb]

So these are the definitions of the 5 kotlin scoping functions

inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    return receiver.block()
}
inline fun <T> T.also(block: (T) -> Unit): T {
    block(this)
    return this
}
inline fun <T> T.apply(block: T.() -> Unit): T {
    block()
    return this
}
inline fun <T, R> T.let(block: (T) -> R): R {
    return block(this)
}
inline fun <T, R> T.run(block: T.() -> R): R {
    return block()
}

What does the T.() -> R imply? I know (T) -> R is a function that takes a T and returns an R, but what does T.() mean?

[LeoColman]

It means you'll pass an extension function

[artem_zin]

It’s a so called lambda with receiver https://kotlinlang.org/docs/reference/lambdas.html#function-literals-with-receiver

[LeoColman]

It will be accessible with this

[Shawn]

literally explained, T.() -> R refers to a function that can be treated as a member of T (and thus has this defined in its scope as type T), takes no arguments, and returns R

[Nezteb]

excellent info, thank you all! 😄

[dave]

@Nezteb you've come across one of the hardest (IMHO) to grok concepts from the core language, but it is very useful once you get used to it.

For the scoping functions, we teach people to just concentrate on using let() and also() initially, and then more into run/apply/with later.

[dave]

Remember : let == transformation, also = side effects

[Nezteb]

ooo i found a good medium post about it https://medium.com/@elye.project/mastering-kotlin-standard-functions-run-with-let-also-and-apply-9cd334b0ef84

[streetsofboston]

@Nezteb Here's my take on these functions...

“Let’s also apply a run with Kotlin on our minds” by Anton Spaans https://medium.com/the-kotlin-chronicle/lets-also-apply-a-run-with-kotlin-on-our-minds-56f12eaef5e3

[Animesh Sahu]

Its a reciever, you guarentee the compiler that the lambda will execute on that T object, and hence the lambda has access to all the functions of that object T.