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.

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.

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.

// 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.

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.

// Standard parameter
val processPairStandard: (Pair<Int, String>) -> Unit = { pair ->
    println("${pair.first} and ${pair.second}")
}

// Destructured parameter
val processPairDestructured: (Pair<Int, String>) -> 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:

val processPairPartial: (Pair<Int, String>) -> 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.

// 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.

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

Functions

Lambdas

Classes & Types

Interfaces

Object Constructs

Constructors

Extensions

Properties

Delegation

Generics

Variables

Parameters

Control Flow

Loops

Error Handling

Annotations

Packages & Imports

Built-In Types

Comments

Arithmetic Operators

Assignment Operators

Equality Operators

Comparison Operators

Containment Operators

Logical Operators

Null Safety Operators

Unary Operators

Type Check & Cast Operators

Range Operators

Bitwise Operators

Shift Operators

Kotlin Lambda Parameter

Explicit Parameter Declaration

The Implicit `it` Parameter

Unused Parameters

Destructuring Declarations

Default Values Restriction

Shadowing

​Explicit Parameter Declaration

​The Implicit it Parameter

​Unused Parameters

​Destructuring Declarations

​Default Values Restriction

​Shadowing

Explicit Parameter Declaration

The Implicit `it` Parameter

Unused Parameters

Destructuring Declarations

Default Values Restriction

Shadowing