> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Kotlin Lambda Parameter A lambda parameter in Kotlin is a variable declared within a lambda expression that receives an argument when the underlying function type is invoked. These parameters are defined on the left side of the arrow (`->`) operator, which separates the parameter list from the execution body. ## Explicit Parameter Declaration By default, lambda parameters are declared explicitly with their names and types. ```kotlin theme={"dark"} val multiplyExplicit: (Int, Int) -> Int = { x: Int, y: Int -> x * y } ``` If the Kotlin compiler can infer the parameter types from the surrounding context (such as the declared function type of the variable), the explicit type declarations can be omitted. ```kotlin theme={"dark"} val multiplyInferred: (Int, Int) -> Int = { x, y -> x * y } ``` ## The Implicit `it` Parameter When a lambda expression has exactly one parameter, and its type can be inferred by the compiler, Kotlin allows you to omit the parameter declaration and the `->` operator entirely. The single parameter is implicitly exposed under the keyword `it`. ```kotlin theme={"dark"} // Explicit declaration val squareExplicit: (Int) -> Int = { number -> number * number } // Implicit 'it' declaration val squareImplicit: (Int) -> Int = { it * it } ``` ## Unused Parameters If a lambda requires multiple parameters to satisfy a function type signature, but the lambda body does not utilize all of them, the unused parameters can be replaced with an underscore (`_`). This prevents compiler warnings and explicitly signals to other developers that the parameter is intentionally ignored. ```kotlin theme={"dark"} val logMessage: (Int, String, Throwable) -> Unit = { _, message, _ -> println(message) } ``` ## Destructuring Declarations Lambda parameters support destructuring declarations. If a parameter is a type that provides `componentN()` operator functions (such as a `Data Class`, `Pair`, or `Map.Entry`), you can destructure the object directly within the parameter list by wrapping the destructured variables in parentheses. ```kotlin theme={"dark"} // Standard parameter val processPairStandard: (Pair) -> Unit = { pair -> println("${pair.first} and ${pair.second}") } // Destructured parameter val processPairDestructured: (Pair) -> Unit = { (id, name) -> println("$id and $name") } ``` You can also combine destructuring with the unused parameter underscore if you only need specific components of the destructured object: ```kotlin theme={"dark"} val processPairPartial: (Pair) -> Unit = { (_, name) -> println("Only using $name") } ``` ## Default Values Restriction Unlike standard function parameters, lambda parameters cannot have default values. The Kotlin compiler strictly enforces this rule, meaning all arguments must be provided when the lambda's underlying function type is invoked. Attempting to assign a default value to a lambda parameter results in a syntax error. ```kotlin theme={"dark"} // INVALID SYNTAX: Compiler error "Lambda parameters cannot have default values" // val increment: (Int) -> Int = { x: Int = 1 -> x + 1 } ``` ## Shadowing Lambda parameters follow standard lexical scoping rules. If a lambda parameter shares a name with a variable in the enclosing scope, the lambda parameter will shadow the outer variable within the lambda body. ```kotlin theme={"dark"} val x = 10 val addToX: (Int) -> Int = { x -> x + 5 // 'x' refers to the lambda parameter, not the outer variable } ```

Tired of Poor Kotlin Skills? Fix That With Deep Grasping! Learn More