Lambda: co to je, syntaxe a použití v Kotlinu

Co je lambda?

Lambda (lambda výraz) — je anonymní funkce definovaná jako výraz, nikoli deklarace. Termín pochází z lambda kalkulu Alonza Churcha (1936). V programování lambda představuje blok kódu, který může být předán jako hodnota, uložen v proměnné a později zavolán. V Kotlinu je lambda vždy uzavřena do složených závorek { }, argumenty jsou od těla odděleny šipkou ->.

Lambda se od běžné funkce liší absencí názvu a klíčového slova fun. To umožňuje deklarovat chování přímo v místě použití, aniž by byl kód zaneřáděn dalšími deklaracemi. Kompilátor Kotlinu odvozuje typy argumentů z kontextu, takže v mnoha případech lze typy vynechat. Lambda je syntaktický cukr nad funkcionálním typem (T) -> R: každá lambda má odpovídající funkcionální typ.

Hlavní použití lambd v Kotlinu je předávání funkcím vyššího řádu (higher-order functions). Standardní knihovna používá lambdy všude: filter { it > 0 }, map { it.uppercase() }, forEach { println(it) }. Lambdy se také používají pro vytváření posluchačů událostí, zpětných volání, konfigurátorů objektů pomocí apply a run, což činí kód deklarativnějším ve srovnání s anonymními třídami.

Syntaxe lambda výrazů v Kotlinu

Úplná forma lambda výrazu v Kotlinu: { argumenty -> tělo_lambdy }. Argumenty jsou vyjmenovány čárkou, následuje šipka a tělo — jeden nebo více výrazů. Pokud tělo obsahuje více řádků, poslední výraz se stává návratovou hodnotou. Pokud funkce přijímá lambdu jako poslední argument, může být umístěna mimo závorky volání.

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

// Typy odvozené z kontextu
val sumShort = { a: Int, b: Int -> a + b }

// Volání lambdy
val result = sum(5, 3)  // 8
println(result)

Proměnná sum je deklarována s explicitním funkcionálním typem (Int, Int) -> Int a inicializována lambdou { a, b -> a + b }. Pro sumShort jsou typy uvedeny uvnitř lambdy a typ proměnné je odvozen. Obě varianty jsou ekvivalentní. Volání lambdy se neliší od volání běžné funkce — používá se syntaxe sum(5, 3). Lambda bez argumentů se zapisuje jako { body }, s jedním argumentem — { it -> it * 2 } nebo jednoduše { it * 2 }.

Implicitní název it a vynechávání argumentů

Když lambda přijímá přesně jeden argument, Kotlin poskytuje implicitní název it. To eliminuje potřebu deklarovat argument na levé straně. Programátor píše pouze tělo lambdy a používá it pro přístup k jedinému parametru. Tato syntaxe je obzvláště vhodná v řetězcích zpracování kolekcí, kde it označuje aktuální prvek.

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

// Explicitní název parametru
val squaredExplicit = numbers.map { n -> n * n }

// Implicitní it
val squared = numbers.map { it * it }

// Filtrování s it
val even = numbers.filter { it % 2 == 0 }

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

V příkladu map { it * it } se používá it místo deklarace n ->. Kotlin automaticky přiřadí it jedinému parametru lambdy. Pokud lambda přijímá dva nebo více argumentů, it se nevytváří — všechny parametry musí být deklarovány explicitně. Pro lepší čitelnost vnořených lambd se doporučuje dávat parametrům smysluplné názvy a používat it v krátkých jednořádkových predikátech.

Trailing lambda a víceřádkové lambdy

Trailing lambda (koncová lambda) — syntaktická vlastnost Kotlinu, která umožňuje umístit poslední argument-lambdu mimo kulaté závorky volání funkce. Tím se kód podobá vestavěným jazykovým konstrukcím. Pokud je lambda jediným argumentem, závorky lze zcela vynechat. Tento přístup je aktivně používán ve standardní knihovně a DSL.

// Standardní volání
thread(block = {
    println("Ahoj z vlákna")
})

// Verze s trailing lambda
thread {
    println("Ahoj z vlákna")
}

// repeat s trailing lambdou
repeat(3) { index ->
    println("Iterace $index")
}

// run s víceřádkovou lambdou
val config = run {
    val host = "localhost"
    val port = 8080
    "$host:$port"
}

Funkce thread přijímá Runnable jako poslední argument. Díky trailing lambdě lze lambdu předat mimo závorky, což vizuálně připomíná blok kódu. Funkce repeat přijímá počet iterací a lambdu s indexem. run — příklad funkce vyššího řádu, kde víceřádková lambda vypočítává hodnotu vrácenou posledním výrazem. Závorky kolem run() lze vynechat, pokud je lambda jediným argumentem.

Zachycení proměnných (closure) v lambdách

Zachycení proměnných (closure) — schopnost lambdy přistupovat k proměnným deklarovaným ve vnějším rozsahu viditelnosti. V Kotlinu může lambda číst a měnit proměnné var, stejně jako číst proměnné val z okolního kontextu. Zachycené proměnné jsou ukládány spolu s lambdou po celý její životní cyklus, což umožňuje vytvářet funkce se stavem.

fun makeCounter(): () -> Int {
    var count = 0
    return {
        count++  // počet zachycení
    }
}

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

Funkce makeCounter deklaruje lokální proměnnou count a vrací lambdu { count++ }. Přestože makeCounter dokončila svou práci, vrácená lambda si udržuje odkaz na count prostřednictvím uzávěru (closure). Každé volání counter() zvyšuje a vrací aktuální hodnotu. Mechanismus closure tvoří základ currying, továren funkcí a memoizace. Je důležité si pamatovat, že zachycení měnitelných proměnných může vést k neočekávanému chování při paralelním provádění.