Programação Funcional em Kotlin: Lambdas e Coleções

Kotlin oferece uma abordagem moderna à programação. Ao combinar conceitos orientados a objetos com o poder da programação funcional, a linguagem proporciona maior flexibilidade e expressividade. Além disso, recursos como lambdas, funções de ordem superior e operações em coleções imutáveis tornam o código mais limpo, legível e fácil de manter.

Neste artigo, você vai entender como esses elementos funcionam em Kotlin, com exemplos práticos que mostram como aplicar programação funcional no dia a dia do desenvolvimento.

Funções de Ordem Superior

Em Kotlin, os desenvolvedores tratam as funções como cidadãs de primeira classe: eles podem passá-las como parâmetros, armazená-las em variáveis e retorná-las de outras funções. Consequentemente, é possível criar funções de ordem superior — aquelas que recebem outras funções como argumentos ou as retornam como resultado.

Exemplo simples de função de ordem superior:

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

fun soma(x: Int, y: Int) = x + y

val resultado = operar(5, 3, ::soma) // Resultado: 8

No exemplo acima, a função operar recebe outra função como parâmetro e a executa. A notação ::soma referencia diretamente a função existente.

Lambdas e Funções Anônimas

Kotlin permite que os desenvolvedores criem funções anônimas, conhecidas como lambdas, que facilitam a escrita de lógicas simples e não reutilizáveis.

A mesma operação anterior com uma lambda ficaria assim:

val resultado = operar(5, 3, { x, y -> x + y }) // Resultado: 8

Graças à inferência de tipos do Kotlin, essa expressão pode ser ainda mais enxuta usando sintaxe de trailing lambda:

val resultado = operar(5, 3) { x, y -> x + y }

Operações Comuns em Coleções Usando Lambdas

Kotlin possui uma poderosa API para manipulação de coleções que segue o estilo funcional. Usando lambdas, é possível realizar operações como map, filter, reduce e outras de forma muito fluida.

Map

Transforma os elementos de uma coleção:

val nomes = listOf("ana", "bruno", "carla")
val capitalizados = nomes.map { it.replaceFirstChar { c -> c.uppercase() } }
// Resultado: [Ana, Bruno, Carla]

Filter

Filtra os elementos com base em uma condição:

val numeros = listOf(1, 2, 3, 4, 5)
val pares = numeros.filter { it % 2 == 0 }
// Resultado: [2, 4]

Reduce

Combina os elementos em um único valor, utilizando uma função acumuladora:

val numeros = listOf(1, 2, 3, 4)
val soma = numeros.reduce { acc, numero -> acc + numero }
// Resultado: 10

Essas operações são declarativas, ou seja, você descreve o que quer fazer, e não como fazer, o que resulta em código mais legível e expressivo.

Conclusão

A programação funcional em Kotlin não é apenas possível — na verdade, ela é fortemente incentivada pela própria linguagem. Por meio de funções de ordem superior, lambdas e uma API rica para coleções, os desenvolvedores conseguem escrever código conciso, reutilizável e fácil de manter. Além disso, esse estilo se mostra ideal para lidar com dados imutáveis, realizar transformações e construir pipelines de processamento, o que contribui para aplicações mais robustas e modernas.