--- title: "Receivers" url: "https://www.bekk.christmas/post/2019/21/receivers" authors: ["Vegard Veiset"] published: "2019-12-21" updated: "2024-11-07T13:05:28Z" language: "en-US" type: "article" tags: ["Kotlin"] --- # Receivers ## In short Kotlin receivers let lambdas run in the scope of an object, so properties and functions on that object can be used directly through this. Combined with extension functions, this makes it possible to build apply-like APIs and other concise, domain-specific syntax. - **For:** Kotlin developers working with lambdas - **Good to know beforehand:** Basic knowledge of lambdas _AI-generated_ Did you know that you can change the scope of lambdas? It’s pretty awesome. In Kotlin you can change the scope of lambdas by using a concept called receivers, and the Kotlin standard library does it all the time. Let's take a closer look at the familiar `apply` function. ```kotlin data class User(var username: String, val id: Int) val user = User("Kris Kringle", 1234) user.apply { username = "Santa" } ``` With `apply` you don't have to reference the object you are working with, and instead, you can use properties such as `username` directly. Cool! So how can we implement our own `apply`? Lambdas with receiver types is the answer! _This post assumes basic knowledge about lambdas. Head over to_ [_On wavelength with lambdas_](https://kotlin.christmas/2019/18) _for a short introduction._ ```kotlin fun caps(user: User, text: User.() -> String): String = user.text().capitalize() val user = User(username = "Santa", id = 1) caps(user) { "$username!" } // result: SANTA! ``` Ok, so let's take a closer look at whats happening in the example above. The `caps` function takes in a user and a lambda with some unusual syntax: `text: User.() -> String`. What's happening here? We have a lambda function type prefixed with a type! The prefix is a receiver type, and in our example that is a `User`. But what does this mean? What is a receiver? Receivers assign a scope, or a receiver type, to a lambda. This means that we can change what `this` is inside a lambda. Having a `User` as a receiver gives us the power to call everything on a `user` object without having to explicitly reference it. ```kotlin fun caps(user: User, text: User.() -> String) = user.text().capitalize() ``` The second thing that might look slightly weird at first glimpse is the way the `text` lambda is invoked. It's called directly on the user object as if it were an extension function. When working with lambdas with receivers we have some nice syntactical sugar; since the parameter `user` has the same type as the receiver, we can call the lambda directly on it. This means that in the context of our lambda `user.text()` is the same thing as `text(user)`. Our `caps` function doesn't quite look like apply yet, but we are getting there. On the other hand `caps` looks very similar to the `with` function in Kotlin, which is not a keyword, but is in fact a function in the [standard library](https://github.com/JetBrains/kotlin/blob/master/libraries/stdlib/src/kotlin/util/Standard.kt). Let's compare them. ```kotlin caps(user) { "$username!" } with(user) { "$username!" } ``` Both `caps` and `with` changes the context of the code block allowing us to refer directly to properties. But our goal was to implement `apply`, not `with`. Extension functions to the rescue! Let's change our `caps` function to be an extension functions and see what happens. ```kotlin fun User.caps(text: User.() -> String): String = text().capitalize() ``` In extension functions `this` refers to the object it's invoked on and since we are extending `User`, `this` is actually a reference to a user. When using receivers types this allows us to call `text()` directly without supplying the `user` to it. ```kotlin fun User.caps(text: User.() -> String): String = text().capitalize() val user = User(username = "Santa", id = 1) user.caps { username } ``` Now we're talking. With that change our `caps` function look and behave much more like `apply`. Using extension functions and lambdas with receiver types we can make a lot of cool code snippets, and even create amazing domain specific languages! Receivers make it possible to create some pretty interesting things, but remember that with great syntactical powers comes great responsibilities. ## Relevant resources recommended by the author - [Kotlin Lambdas](https://kotlinlang.org/docs/reference/lambdas.html)