Kotlin let()

Kotlin let() function

In Kotlin, the let() function is a scoping function that is used to execute a block of code on a value. It is particularly useful for simplifying the invocation of functions on an object and for creating a temporary scope.

This function takes a lambda expression as an argument, and the receiver object this becomes the lambda’s implicit receiver. The result of the lambda expression is the value returned by the let() function.

In this tutorial, we’ll explore the syntax of the let() standard function and provide examples of its usage in Kotlin.


The syntax of the let() function is:

inline fun <T, R> T.let(block: (T) -> R): R

The let() function is an extension function on any object of type T. It takes a lambda expression block as an argument, which receives the object as its parameter, and returns the result of applying the lambda.

Examples for let() function

1. Using let() for String Manipulation

In this example, we’ll use let() to perform string manipulation on a non-null string.

Kotlin Program

fun main() {
    val originalString: String? = "Hello, World!"

    val result = originalString?.let {
        // Perform string manipulation inside the let block
        val result = it.uppercase()

    // Printing the result
    println("Original: $originalString")
    println("Modified: $result")


Original: Hello, World!
Modified: HELLO, WORLD!

2. Creating a Temporary Scope

In this example, we’ll use let() to create a temporary scope for a nullable object and perform operations inside the scope.

Kotlin Program

fun main() {
    val nullableValue: Int? = 42

    nullableValue?.let {
        // Operations performed inside the let block
        val doubledValue = it * 2
        println("Doubled Value: $doubledValue")


Doubled Value: 84


In this tutorial, we’ve covered the let() standard function in Kotlin, its syntax, and how to use it for scoping and performing operations on the result of an expression.