Lambda: Was ist das, Syntax und Verwendung in Kotlin

Was ist Lambda?

Lambda (Lambda-Ausdruck) ist eine anonyme Funktion, die als Ausdruck statt als Deklaration definiert wird. Der Begriff stammt aus dem Lambda-Kalkül von Alonzo Church (1936). In der Programmierung ist eine Lambda ein Codeblock, der als Wert übergeben, in einer Variable gespeichert und später aufgerufen werden kann. In Kotlin ist eine Lambda immer in geschweifte Klammern { } eingeschlossen, wobei Argumente durch den Pfeil -> vom Körper getrennt werden.

Eine Lambda unterscheidet sich von einer regulären Funktion durch das Fehlen eines Namens und des Schlüsselworts fun. Dies ermöglicht es, Verhalten direkt am Verwendungspunkt zu deklarieren, ohne den Code mit zusätzlichen Deklarationen zu überladen. Der Kotlin-Compiler leitet Argumenttypen aus dem Kontext ab, sodass Typen in vielen Fällen weggelassen werden können. Eine Lambda ist syntaktischer Zucker über dem funktionalen Typ (T) -> R: Jede Lambda hat einen entsprechenden funktionalen Typ.

Die Hauptverwendung von Lambdas in Kotlin ist die Übergabe an Higher-Order-Functions. Die Standardbibliothek verwendet Lambdas überall: filter { it > 0 }, map { it.uppercase() }, forEach { println(it) }. Lambdas werden auch für Ereignis-Listener, Callbacks und Objektkonfiguratoren über apply und run verwendet, was Code im Vergleich zu anonymen Klassen deklarativer macht.

Syntax von Lambda-Ausdrücken in Kotlin

Die vollständige Form eines Lambda-Ausdrucks in Kotlin: { Argumente -> Lambda_Körper }. Die Argumente werden durch Kommas getrennt aufgelistet, gefolgt von einem Pfeil und dem Körper — einem oder mehreren Ausdrücken. Wenn der Körper mehrere Zeilen enthält, wird der letzte Ausdruck zum Rückgabewert. Wenn eine Funktion eine Lambda als letztes Argument akzeptiert, kann sie außerhalb der Aufrufklammern platziert werden.

val sum: (Int, Int) -> Int = { a, b -> a + b }

// Aus Kontext abgeleitete Typen
val sumShort = { a: Int, b: Int -> a + b }

// Lambda-Aufruf
val result = sum(5, 3)  // 8
println(result)

Die Variable sum wird mit einem expliziten funktionalen Typ (Int, Int) -> Int deklariert und mit einer Lambda { a, b -> a + b } initialisiert. Bei sumShort werden die Typen innerhalb der Lambda angegeben und der Variablentyp wird abgeleitet. Beide Varianten sind äquivalent. Der Aufruf einer Lambda unterscheidet sich nicht vom Aufruf einer regulären Funktion — unter Verwendung der Syntax sum(5, 3). Eine Lambda ohne Argumente wird als { body } geschrieben, mit einem Argument — { it -> it * 2 } oder einfach { it * 2 }.

Implizites it und Weglassen von Argumenten

Wenn eine Lambda genau ein Argument akzeptiert, stellt Kotlin den impliziten Namen it bereit. Dies macht die Deklaration des Arguments auf der linken Seite überflüssig. Der Entwickler schreibt nur den Lambda-Körper und verwendet it, um auf den einzelnen Parameter zuzugreifen. Diese Syntax ist besonders praktisch in Verarbeitungsketten von Sammlungen, wo it auf das aktuelle Element verweist.

val numbers = listOf(1, 2, 3, 4, 5)

// Expliziter Parametername
val squaredExplicit = numbers.map { n -> n * n }

// Implizites it
val squared = numbers.map { it * it }

// Filtern mit it
val even = numbers.filter { it % 2 == 0 }

println(squared) // [1, 4, 9, 16, 25]

Im Beispiel verwendet map { it * it } it anstelle von n ->. Kotlin weist it automatisch für einen einzelnen Lambda-Parameter zu. Wenn eine Lambda zwei oder mehr Argumente akzeptiert, wird it nicht erstellt — alle Parameter müssen explizit deklariert werden. Für bessere Lesbarkeit von verschachtelten Lambdas sollten Parameter sinnvolle Namen erhalten und it nur in kurzen einzeiligen Prädikaten verwendet werden.

Trailing Lambda und mehrzeilige Lambdas

Trailing Lambda ist ein syntaktisches Merkmal von Kotlin, das es ermöglicht, das letzte Lambda-Argument außerhalb der Funktionsaufrufklammern zu platzieren. Dadurch sieht der Code aus wie eingebaute Sprachkonstrukte. Wenn die Lambda das einzige Argument ist, können die Klammern vollständig weggelassen werden. Dieser Ansatz wird aktiv in der Standardbibliothek und DSLs verwendet.

// Standardaufruf
thread(block = {
    println("Hallo vom Thread")
})

// Trailing-Lambda-Version
thread {
    println("Hallo vom Thread")
}

// repeat mit Trailing Lambda
repeat(3) { index ->
    println("Iteration $index")
}

// run mit mehrzeiliger Lambda
val config = run {
    val host = "localhost"
    val port = 8080
    "$host:$port"
}

Die Funktion thread akzeptiert ein Runnable als letztes Argument. Dank der Trailing Lambda kann die Lambda außerhalb der Klammern übergeben werden, was optisch wie ein Codeblock aussieht. Die Funktion repeat nimmt eine Anzahl von Iterationen und eine Lambda mit einem Index entgegen. run ist ein Beispiel für eine Higher-Order-Function, bei der eine mehrzeilige Lambda einen von der letzten Expression zurückgegebenen Wert berechnet. Die Klammern um run() können weggelassen werden, wenn die Lambda das einzige Argument ist.

Variablen-Einfang (Closure) in Lambdas

Variablen-Einfang (Closure) ist die Fähigkeit einer Lambda, auf Variablen zuzugreifen, die im äußeren Gültigkeitsbereich deklariert wurden. In Kotlin kann eine Lambda var-Variablen lesen und ändern sowie val-Variablen aus dem umgebenden Kontext lesen. Eingefangene Variablen werden zusammen mit der Lambda während ihres gesamten Lebenszyklus gespeichert, was Funktionen mit Zustand ermöglicht.

fun makeCounter(): () -> Int {
    var count = 0
    return {
        count++  // Einfangzähler
    }
}

fun main() {
    val counter = makeCounter()
    println(counter()) // 0
    println(counter()) // 1
    println(counter()) // 2
}

Die Funktion makeCounter deklariert eine lokale Variable count und gibt eine Lambda { count++ } zurück. Obwohl makeCounter die Ausführung abgeschlossen hat, behält die zurückgegebene Lambda durch die Closure eine Referenz auf count. Jeder Aufruf von counter() erhöht und gibt den aktuellen Wert zurück. Der Closure-Mechanismus liegt Currying, Funktionsfabriken und Memoization zugrunde. Es ist wichtig zu bedenken, dass das Einfangen veränderlicher Variablen bei gleichzeitiger Ausführung zu unerwartetem Verhalten führen kann.