Что такое лямбда функция?

Лямбда функция (Lambda Function)

Лямбда (или анонимная функция) - это функция без названия, которую можно передать как значение. В Kotlin лямбды - это первоклассные граждане, они повсюду используются.

Синтаксис

// Обычная функция
fun add(a: Int, b: Int): Int {
    return a + b
}

// Лямбда
val addLambda = { a: Int, b: Int -> a + b }
addLambda(2, 3)  // 5

// Более читаемо с типизацией
val addLambda: (Int, Int) -> Int = { a, b -> a + b }

Типичные примеры

1. Filter

val numbers = listOf(1, 2, 3, 4, 5)
val evens = numbers.filter { it % 2 == 0 }
// evens = [2, 4]

// Эквивалентно
val evens2 = numbers.filter({ num -> num % 2 == 0 })

2. Map

val numbers = listOf(1, 2, 3)
val doubled = numbers.map { it * 2 }
// doubled = [2, 4, 6]

// С несколькими параметрами
val pairs = listOf(1 to 2, 3 to 4)
val sums = pairs.map { (a, b) -> a + b }
// sums = [3, 7]

3. OnClick слушатель

button.setOnClickListener { 
    Toast.makeText(context, "Clicked!", Toast.LENGTH_SHORT).show()
}

// Вместо
button.setOnClickListener(object : View.OnClickListener {
    override fun onClick(v: View?) {
        Toast.makeText(context, "Clicked!", Toast.LENGTH_SHORT).show()
    }
})

4. Sort с кастомной логикой

data class Person(val name: String, val age: Int)

val people = listOf(
    Person("Alice", 30),
    Person("Bob", 25)
)

// Sort по возрасту
val sorted = people.sortedBy { it.age }

// Sort в обратном порядке
val sorted2 = people.sortedByDescending { it.age }

Особенности лямбд в Kotlin

1. Синтаксис с одним параметром

val square = { x: Int -> x * x }
val square2 = { x -> x * x }  // тип выводится

val numbers = listOf(1, 2, 3)
val squared = numbers.map { it * it }  // it - неявный параметр

2. Trailing lambda syntax

Если последний параметр функции - это лямбда, можно передать её снаружи скобок:

// С скобками
val result = numbers.filter({ it > 2 })

// Trailing lambda (более идиоматично)
val result = numbers.filter { it > 2 }

// Функция с несколькими параметрами
fun execute(name: String, action: (String) -> Unit) { }

// Передача
execute("test") { name -> println(name) }

3. Return из лямбды

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

// Return из лямбды
val result = numbers.map { 
    if (it == 3) return@map 0  // return из лямбды, не из функции
    it * 2
}
// result = [2, 4, 0, 8, 10]

// Без return@map - это будет return из функции
fun getNumbers(): List<Int> {
    val numbers = listOf(1, 2, 3)
    return numbers.map { 
        if (it == 2) return listOf()  // выйдет из getNumbers!
        it * 2
    }
}

4. Деструктуризация в лямбде

val pairs = listOf(1 to "a", 2 to "b", 3 to "c")

val formatted = pairs.map { (num, letter) ->
    "$num -> $letter"
}
// formatted = ["1 -> a", "2 -> b", "3 -> c"]

Лямбды и Higher-Order Functions

Функция, которая принимает или возвращает лямбду - это higher-order function:

// Функция принимает лямбду
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

calculate(5, 3) { a, b -> a + b }  // 8
calculate(5, 3) { a, b -> a * b }  // 15

// Функция возвращает лямбду
fun makeAdder(x: Int): (Int) -> Int {
    return { y -> x + y }
}

val add5 = makeAdder(5)
add5(3)  // 8

Closure - захват переменных

var counter = 0

val increment = {
    counter++  // лямбда захватывает counter
}

increment()  // counter = 1
increment()  // counter = 2
println(counter)  // 2

Практические примеры в Android

1. AsyncTask с лямбдой

launchIO {
    try {
        val user = repository.getUser(userId)
        withContext(Dispatchers.Main) {
            updateUI(user)
        }
    } catch (e: Exception) {
        showError(e.message)
    }
}

2. RecyclerView Adapter

class UserAdapter(
    private val users: List<User>,
    private val onItemClick: (User) -> Unit
) : RecyclerView.Adapter<UserAdapter.UserViewHolder>() {
    
    inner class UserViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        fun bind(user: User) {
            itemView.setOnClickListener { 
                onItemClick(user)  // вызов лямбды
            }
        }
    }
}

// Использование
val adapter = UserAdapter(users) { user ->
    Toast.makeText(context, user.name, Toast.LENGTH_SHORT).show()
}

3. DSL паттерн

fun buildUI(init: UIBuilder.() -> Unit): View {
    val builder = UIBuilder()
    builder.init()  // вызываем лямбду с receiver
    return builder.build()
}

class UIBuilder {
    fun button(text: String, onClick: () -> Unit) { }
    fun textView(text: String) { }
}

// Использование
val view = buildUI {
    button("Click me") {
        println("Clicked!")
    }
    textView("Hello")
}

Лямбда vs Anonymous Object

// Лямбда - более лаконична
button.setOnClickListener { println("Click") }

// Anonymous object - многословнее
button.setOnClickListener(object : View.OnClickListener {
    override fun onClick(v: View?) {
        println("Click")
    }
})

Вывод

Лямбда функция:

• Анонимная функция без названия
• Передаётся как значение
• Очень часто используется (filter, map, listeners)
• Может захватывать переменные из окружения
• Делает код более функциональным и читаемым
• Основа функционального программирования в Kotlin