O que é Higher-Order Function em Kotlin?

Uma Higher-Order Function (função de ordem superior) é uma função que recebe outra função como parâmetro ou retorna uma função. Em Kotlin, funções são cidadãs de primeira classe, então esse tipo de construção é super natural.

Você já usa higher-order functions sem perceber: map, filter, forEach — todas elas recebem lambdas como argumento.

Recebendo funções como parâmetro

fun executarOperacao(a: Int, b: Int, operacao: (Int, Int) -> Int): Int {
    return operacao(a, b)
}

fun main() {
    val soma = executarOperacao(10, 5) { a, b -> a + b }
    val produto = executarOperacao(10, 5) { a, b -> a * b }

    println("Soma: $soma")       // Soma: 15
    println("Produto: $produto") // Produto: 50
}

O tipo (Int, Int) -> Int declara que o parâmetro é uma função que recebe dois inteiros e retorna um inteiro.

Retornando funções

fun criarMultiplicador(fator: Int): (Int) -> Int {
    return { numero -> numero * fator }
}

fun main() {
    val dobrar = criarMultiplicador(2)
    val triplicar = criarMultiplicador(3)

    println(dobrar(5))     // 10
    println(triplicar(5))  // 15
}

Aqui, criarMultiplicador retorna uma função. Cada vez que você chama, recebe uma função nova configurada com o fator escolhido.

Exemplo prático: validação

fun validar(valor: String, vararg regras: (String) -> Boolean): Boolean {
    return regras.all { regra -> regra(valor) }
}

fun main() {
    val naoVazio: (String) -> Boolean = { it.isNotBlank() }
    val tamanhoMinimo: (String) -> Boolean = { it.length >= 3 }
    val semEspaco: (String) -> Boolean = { !it.contains(" ") }

    println(validar("kotlin", naoVazio, tamanhoMinimo, semEspaco)) // true
    println(validar("ab", naoVazio, tamanhoMinimo))                // false
    println(validar("tem espaco", naoVazio, semEspaco))            // false
}

Referência de função com ::

Você pode passar funções já existentes usando :::

fun ehPositivo(n: Int) = n > 0

fun main() {
    val numeros = listOf(-2, -1, 0, 1, 2)
    val positivos = numeros.filter(::ehPositivo)
    println(positivos) // [1, 2]
}

Higher-order functions são o alicerce da programação funcional em Kotlin. Elas tornam o código mais flexível, reutilizável e expressivo.