Lambda: vad är det, syntax och användning i Kotlin

Vad är lambda?

Lambda (lambda-uttryck) — är en anonym funktion definierad som ett uttryck, inte en deklaration. Termen kommer från lambdakalkylen av Alonzo Church (1936). Inom programmering representerar lambda ett kodblock som kan skickas som ett värde, lagras i en variabel och anropas senare. I Kotlin är lambdan alltid omsluten av klammerparenteser { }, argumenten separeras från kroppen med pilen ->.

Lambda skiljer sig från en vanlig funktion genom avsaknaden av namn och nyckelordet fun. Detta gör det möjligt att deklarera beteende direkt på användningsstället, utan att belamra koden med ytterligare deklarationer. Kotlin-kompilatorn härleder argumenttyperna från kontexten, så i många fall kan typerna utelämnas. Lambda är syntaktiskt socker över den funktionella typen (T) -> R: varje lambda har en motsvarande funktionell typ.

Den huvudsakliga användningen av lambdas i Kotlin är att skicka dem till högre ordningens funktioner (higher-order functions). Standardbiblioteket använder lambdas överallt: filter { it > 0 }, map { it.uppercase() }, forEach { println(it) }. Lambdas används också för att skapa händelseavlyssnare, återanrop, objektkonfiguratorer via apply och run, vilket gör koden mer deklarativ jämfört med anonyma klasser.

Syntax för lambda-uttryck i Kotlin

Den fullständiga formen av lambda-uttryck i Kotlin: { argument -> lambdans_kropp }. Argumenten listas med kommatecken, följt av en pil och kroppen — ett eller flera uttryck. Om kroppen innehåller flera rader blir det sista uttrycket returvärdet. Om en funktion accepterar en lambda som sista argument, kan den placeras utanför anropsparenteserna.

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

// Typer härledda från kontext
val sumShort = { a: Int, b: Int -> a + b }

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

Variabeln sum deklareras med explicit funktionell typ (Int, Int) -> Int och initieras med lambdan { a, b -> a + b }. För sumShort anges typerna inuti lambdan och variabelns typ härleds. Båda varianterna är likvärdiga. Att anropa en lambda skiljer sig inte från att anropa en vanlig funktion — syntaxen sum(5, 3) används. En lambda utan argument skrivs som { body }, med ett argument — { it -> it * 2 } eller helt enkelt { it * 2 }.

Implicita namnet it och utelämnande av argument

När en lambda accepterar exakt ett argument tillhandahåller Kotlin det implicita namnet it. Detta eliminerar behovet av att deklarera argumentet på vänster sida. Programmeraren skriver bara lambdans kropp och använder it för att komma åt den enda parametern. Sådan syntax är särskilt bekväm i kedjor av samlingsbearbetning, där it betecknar det aktuella elementet.

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

// Explicit parameternamn
val squaredExplicit = numbers.map { n -> n * n }

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

// Filtrering med it
val even = numbers.filter { it % 2 == 0 }

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

I exemplet map { it * it } används it istället för deklarationen n ->. Kotlin tilldelar automatiskt it till lambdans enda parameter. Om en lambda accepterar två eller fler argument skapas inte it — alla parametrar måste deklareras explicit. För bättre läsbarhet av nästlade lambdas rekommenderas att ge parametrar meningsfulla namn och använda it i korta enradspredikat.

Trailing lambda och flerradiga lambdas

Trailing lambda (avslutande lambda) — en syntaktisk funktion i Kotlin som gör det möjligt att placera det sista argumentet-lambdan utanför de runda parenteserna i funktionsanropet. Detta får koden att likna inbyggda språkkonstruktioner. Om lambdan är det enda argumentet kan parenteserna utelämnas helt. Detta tillvägagångssätt används aktivt i standardbiblioteket och DSL.

// Standardanrop
thread(block = {
    println("Hej från tråd")
})

// Trailing lambda-version
thread {
    println("Hej från tråd")
}

// repeat med trailing lambda
repeat(3) { index ->
    println("Iteration $index")
}

// run med flerradig lambda
val config = run {
    val host = "localhost"
    val port = 8080
    "$host:$port"
}

Funktionen thread accepterar Runnable som sista argument. Tack vare trailing lambda kan lambdan skickas utanför parenteserna, vilket visuellt liknar ett kodblock. Funktionen repeat accepterar antalet iterationer och en lambda med index. run — ett exempel på en högre ordningens funktion där en flerradig lambda beräknar värdet som returneras av det sista uttrycket. Parenteserna runt run() kan utelämnas om lambdan är det enda argumentet.

Infångning av variabler (closure) i lambdas

Infångning av variabler (closure) — lambdans förmåga att komma åt variabler deklarerade i det externa omfånget. I Kotlin kan en lambda läsa och ändra var-variabler, samt läsa val-variabler från den omgivande kontexten. Infångade variabler lagras tillsammans med lambdan under hela dess livscykel, vilket gör det möjligt att skapa funktioner med tillstånd.

fun makeCounter(): () -> Int {
    var count = 0
    return {
        count++  // antal infångningar
    }
}

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

Funktionen makeCounter deklarerar en lokal variabel count och returnerar lambdan { count++ }. Trots att makeCounter har slutfört sitt arbete behåller den returnerade lambdan referensen till count genom en closure. Varje anrop till counter() ökar och returnerar det aktuella värdet. Closures mekanism ligger till grund för currying, funktionsfabriker och memoisering. Det är viktigt att komma ihåg att infångning av föränderliga variabler kan leda till oväntat beteende vid parallell exekvering.