Расскажите о функциях высшего порядка. Когда они нужны?android-243

fun higherOrderFunction(callback: (Int) -> String): String {
    val result = 42
    return callback(result)
}

fun fetchData(callback: (Result<Data>) -> Unit) {
    thread {
        try {
            val data = api.getData()
            callback(Result.success(data))
        } catch (e: Exception) {
            callback(Result.failure(e))
        }
    }
}

// Использование
fetchData { result ->
    when (result) {
        is Success -> showData(result.data)
        is Failure -> showError(result.exception)
    }
}

fun List<Int>.filterCustom(predicate: (Int) -> Boolean): List<Int> {
    val result = mutableListOf<Int>()
    for (item in this) {
        if (predicate(item)) {
            result.add(item)
        }
    }
    return result
}

// Использование
val numbers = listOf(1, 2, 3, 4, 5)
val evens = numbers.filterCustom { it % 2 == 0 }

fun processPayment(
    amount: Double,
    strategy: (Double) -> Boolean
): Boolean {
    return strategy(amount)
}

// Стратегии
val creditCardStrategy = { amount: Double ->
    /* логика оплаты картой */ true
}
val cryptoStrategy = { amount: Double ->
    /* логика крипто-оплаты */ true
}

// Использование
processPayment(100.0, creditCardStrategy)

fun dialog(init: DialogBuilder.() -> Unit): Dialog {
    val builder = DialogBuilder()
    builder.init()
    return builder.build()
}

// Использование
dialog {
    title = "Warning"
    message = "Are you sure?"
    positiveButton("Yes") { /* action */ }
    negativeButton("No") { /* action */ }
}

fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C {
    return { x -> f(g(x)) }
}

val square = { x: Int -> x * x }
val double = { x: Int -> x * 2 }
val squareThenDouble = compose(double, square)

fun <T, R> ((T) -> R).memoize(): (T) -> R {
    val cache = mutableMapOf<T, R>()
    return { input -> cache.getOrPut(input) { this(input) } }
}

val expensiveCalculation = { x: Int ->
    Thread.sleep(1000)
    x * x
}.memoize()

inline fun measureTime(block: () -> Unit): Long {
    val start = System.nanoTime()
    block()
    return System.nanoTime() - start
}