Programación funcional en Kotlin: fundamentos y ejemplos

Introducción a la programación funcional en Kotlin

Kotlin es un lenguaje moderno multiparadigma que combina orgánicamente la programación orientada a objetos y la programación funcional. Gracias a su sintaxis concisa y sus potentes capacidades, Kotlin permite escribir código limpio, predecible y fácilmente testeable. La programación funcional (PF) en Kotlin no es solo una tendencia de moda, sino una herramienta poderosa para resolver tareas cotidianas: desde el procesamiento de colecciones hasta la construcción de cadenas de llamadas asíncronas.

En este artículo, analizaremos los conceptos clave de la PF aplicados a Kotlin: inmutabilidad de datos, funciones como valores de primera clase, expresiones lambda, funciones de orden superior y cadenas de procesamiento de colecciones (map, filter, reduce). Todos los ejemplos estarán acompañados de código práctico que se puede ejecutar inmediatamente en IntelliJ IDEA o en un compilador en línea.

Fundamentos del enfoque funcional en Kotlin

Inmutabilidad (Immutability)

El principio fundamental de la PF es trabajar con datos inmutables. En Kotlin, para esto se utilizan las palabras clave val (referencia inmutable) y las colecciones inmutables (listOf, mapOf, setOf).

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

// Intentar modificarla causará un error de compilación// numbers.add(6) // ¡Error!

// En lugar de mutar, creamos una nueva colecciónval newNumbers = numbers + 6 // [1, 2, 3, 4, 5, 6]

Las ventajas de la inmutabilidad son evidentes: el código se vuelve seguro para subprocesos, es más fácil de depurar y los efectos secundarios se reducen al mínimo. Si necesita modificar datos, siempre crea una nueva copia con los cambios necesarios.

Funciones como valores de primera clase

En Kotlin, las funciones son objetos de pleno derecho. Se pueden asignar a variables, pasar a otras funciones y devolver desde funciones. El tipo de función se escribe entre paréntesis con una flecha:

// Función como valorval sum: (Int, Int) -> Int = { a, b -> a + b }

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

// Función que recibe otra funciónfun 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

Tenga en cuenta: si la lambda es el último argumento, Kotlin permite colocarla fuera de los paréntesis; esto es la sintaxis trailing lambda, que hace que el código sea muy legible.

Expresiones lambda y funciones de orden superior

Expresiones lambda

Una lambda es una función anónima encerrada entre llaves. En Kotlin, las lambdas pueden capturar variables del contexto externo (cierres).

// Lambda simpleval greet = { name: String -> "¡Hola, $name!" }println(greet("Ana")) // ¡Hola, Ana!

// Lambda con varios parámetrosval multiply: (Int, Int) -> Int = { a, b -> a * b }

// Si hay un solo parámetro, se puede usar itval double = { it: Int -> it * 2 }println(double(5)) // 10

Funciones de orden superior (Higher-Order Functions)

Son funciones que reciben otras funciones como argumentos o las devuelven. En la biblioteca estándar de Kotlin hay muchas de estas funciones: let, apply, run, with y otras. Veamos un ejemplo práctico:

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("Iván", 25),    User("María", 17),    User("Pedro", 30))

// Filtremos los mayores de edad y mostremos sus nombresval adultNames = processUsers(    users,    filter = { it.age >= 18 },    transform = { "Adulto: ${it.name}" })