Lambda: wat is het, syntaxis en gebruik in Kotlin

Wat is lambda?

Lambda (lambda-expressie) — is een anonieme functie gedefinieerd als een expressie, niet als een declaratie. De term komt van de lambdacalculus van Alonzo Church (1936). In programmeren vertegenwoordigt lambda een codeblok dat als waarde kan worden doorgegeven, in een variabele kan worden opgeslagen en later kan worden aangeroepen. In Kotlin staat een lambda altijd tussen accolades { }, argumenten worden van het lichaam gescheiden door de pijl ->.

Een lambda verschilt van een gewone functie door het ontbreken van een naam en het sleutelwoord fun. Dit maakt het mogelijk om gedrag direct op het gebruikspunt te declareren, zonder de code te vervuilen met extra declaraties. De Kotlin-compiler leidt de argumenttypes af uit de context, dus in veel gevallen kunnen types worden weggelaten. Lambda is syntactische suiker over het functionele type (T) -> R: elke lambda heeft een overeenkomstig functioneel type.

Het belangrijkste gebruik van lambda's in Kotlin is het doorgeven aan hogere-ordefuncties (higher-order functions). De standaardbibliotheek gebruikt overal lambda's: filter { it > 0 }, map { it.uppercase() }, forEach { println(it) }. Lambda's worden ook gebruikt voor het maken van gebeurtenislisteners, callbacks, objectconfigurators via apply en run, wat de code declaratiever maakt in vergelijking met anonieme klassen.

Syntaxis van lambda-expressies in Kotlin

De volledige vorm van een lambda-expressie in Kotlin: { argumenten -> lambda_lichaam }. Argumenten worden met komma's opgesomd, gevolgd door een pijl en het lichaam — een of meer expressies. Als het lichaam meerdere regels bevat, wordt de laatste expressie de retourwaarde. Als een functie een lambda als laatste argument accepteert, kan deze buiten de aanroephaken worden geplaatst.

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

// Types afgeleid uit context
val sumShort = { a: Int, b: Int -> a + b }

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

Variabele sum is gedeclareerd met het expliciete functionele type (Int, Int) -> Int en geïnitialiseerd met de lambda { a, b -> a + b }. Voor sumShort zijn de types binnen de lambda gespecificeerd en het type van de variabele is afgeleid. Beide varianten zijn equivalent. Het aanroepen van een lambda verschilt niet van het aanroepen van een gewone functie — de syntaxis sum(5, 3) wordt gebruikt. Een lambda zonder argumenten wordt geschreven als { body }, met één argument — { it -> it * 2 } of gewoon { it * 2 }.

Impliciete naam it en weglaten van argumenten

Wanneer een lambda precies één argument accepteert, biedt Kotlin de impliciete naam it. Dit elimineert de noodzaak om het argument aan de linkerkant te declareren. De programmeur schrijft alleen het lichaam van de lambda en gebruikt it om toegang te krijgen tot de enige parameter. Deze syntaxis is vooral handig in verwerkingsketens van collecties, waar it het huidige element aangeeft.

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

// Expliciete paramieternaam
val squaredExplicit = numbers.map { n -> n * n }

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

// Filteren met it
val even = numbers.filter { it % 2 == 0 }

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

In het voorbeeld map { it * it } wordt it gebruikt in plaats van de declaratie n ->. Kotlin kent automatisch it toe voor de enige parameter van de lambda. Als een lambda twee of meer argumenten accepteert, wordt it niet gemaakt — alle parameters moeten expliciet worden gedeclareerd. Voor betere leesbaarheid van geneste lambda's is het aan te raden parameters betekenisvolle namen te geven en it te gebruiken in korte eenregelige predicaten.

Trailing lambda en meerregelige lambda's

Trailing lambda (afsluitende lambda) — een syntactische functie van Kotlin waarmee het laatste argument-lambda buiten de ronde haakjes van de functieaanroep kan worden geplaatst. Dit maakt de code vergelijkbaar met ingebouwde taalconstructies. Als de lambda het enige argument is, kunnen de haakjes volledig worden weggelaten. Deze benadering wordt actief gebruikt in de standaardbibliotheek en DSL.

// Standaardaanroep
thread(block = {
    println("Hallo van draad")
})

// Trailing lambda-versie
thread {
    println("Hallo van draad")
}

// repeat met trailing lambda
repeat(3) { index ->
    println("Iteratie $index")
}

// run met meerregelige lambda
val config = run {
    val host = "localhost"
    val port = 8080
    "$host:$port"
}

De functie thread accepteert Runnable als laatste argument. Dankzij trailing lambda kan de lambda buiten de haakjes worden doorgegeven, wat visueel op een codeblok lijkt. De functie repeat accepteert het aantal iteraties en een lambda met index. run — een voorbeeld van een hogere-ordefunctie waarbij een meerregelige lambda de waarde berekent die door de laatste expressie wordt geretourneerd. De haakjes rond run() kunnen worden weggelaten als de lambda het enige argument is.

Variabelen capturen (closure) in lambda's

Variabelen capturen (closure) — het vermogen van een lambda om variabelen te benaderen die zijn gedeclareerd in het externe bereik. In Kotlin kan een lambda var-variabelen lezen en wijzigen, evenals val-variabelen uit de omringende context lezen. Gecaptureerde variabelen worden samen met de lambda opgeslagen gedurende de hele levenscyclus, wat het mogelijk maakt om functies met toestand te maken.

fun makeCounter(): () -> Int {
    var count = 0
    return {
        count++  // aantal captures
    }
}

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

De functie makeCounter declareert een lokale variabele count en retourneert de lambda { count++ }. Hoewel makeCounter zijn werk heeft voltooid, behoudt de geretourneerde lambda de referentie naar count via een closure. Elke aanroep van counter() verhoogt en retourneert de huidige waarde. Het closure-mechanisme vormt de basis van currying, functiefabrieken en memoïsatie. Het is belangrijk te onthouden dat het capturen van muteerbare variabelen kan leiden tot onverwacht gedrag bij parallelle uitvoering.