Programação Funcional em Kotlin: Fundamentos e Exemplos

Introdução à Programação Funcional em Kotlin

Kotlin é uma linguagem moderna e multiparadigma que combina perfeitamente programação orientada a objetos e funcional. Graças à sua sintaxe concisa e recursos poderosos, Kotlin permite escrever código limpo, previsível e facilmente testável. A programação funcional (PF) em Kotlin não é apenas uma tendência da moda, mas uma ferramenta poderosa para resolver problemas do dia a dia: desde o processamento de coleções até a construção de cadeias de chamadas assíncronas.

Neste artigo, abordaremos os conceitos-chave da PF aplicados ao Kotlin: imutabilidade de dados, funções como valores de primeira classe, expressões lambda, funções de ordem superior e cadeias de processamento de coleções (map, filter, reduce). Todos os exemplos serão acompanhados de código prático que pode ser executado imediatamente no IntelliJ IDEA ou em um compilador online.

Fundamentos da Abordagem Funcional em Kotlin

Imutabilidade (Immutability)

O princípio fundamental da PF é trabalhar com dados imutáveis. Em Kotlin, usamos as palavras-chave val (referência imutável) e coleções imutáveis (listOf, mapOf, setOf).

// Lista imutávelval numbers: List<Int> = listOf(1, 2, 3, 4, 5)

// Tentar modificar causará um erro de compilação// numbers.add(6) // Erro!

// Em vez de mutação, criamos uma nova coleçãoval newNumbers = numbers + 6 // [1, 2, 3, 4, 5, 6]

As vantagens da imutabilidade são óbvias: o código se torna thread-safe, mais fácil de depurar e os efeitos colaterais são minimizados. Se você precisar alterar dados, sempre cria uma nova cópia com as alterações desejadas.

Funções como Valores de Primeira Classe

Em Kotlin, funções são objetos de pleno direito. Elas podem ser atribuídas a variáveis, passadas para outras funções e retornadas de funções. O tipo de uma função é escrito entre parênteses com uma seta:

// Função como valorval sum: (Int, Int) -> Int = { a, b -> a + b }

// Usoval result = sum(10, 20) // 30

// Função que recebe outra funçãofun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {    return operation(a, b)}

println(operate(5, 3, sum)) // 8println(operate(5, 3, { x, y -> x * y })) // 15

Observe: se o lambda for o último argumento, Kotlin permite colocá-lo fora dos parênteses — isso é a sintaxe trailing lambda, que torna o código muito legível.

Expressões Lambda e Funções de Ordem Superior

Expressões Lambda

Um lambda é uma função anônima, delimitada por chaves. Em Kotlin, lambdas podem capturar variáveis do contexto externo (closures).

// Lambda simplesval greet = { name: String -> "Olá, $name!" }println(greet("Ana")) // Olá, Ana!

// Lambda com vários parâmetrosval multiply: (Int, Int) -> Int = { a, b -> a * b }

// Se houver apenas um parâmetro, podemos usar itval double = { it: Int -> it * 2 }println(double(5)) // 10

Funções de Ordem Superior (Higher-Order Functions)

São funções que recebem outras funções como argumentos ou as retornam. A biblioteca padrão do Kotlin possui muitas dessas funções: let, apply, run, with e outras. Vejamos um exemplo prático:

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

fun processUsers(users: List<User>, filter: (User) -> Boolean, transform: (User) -> String): List<String> {    return users.filter(filter).map(transform)}

val users = listOf(    User("Ivan", 25),    User("Maria", 17),    User("Pedro", 30))

// Filtramos os maiores de idade e exibimos seus nomesval adultNames = processUsers(    users,    filter = { it.age >= 18 },    transform = { "Adulto: ${it.name}" })