Declaración de funciones

Encuentra el código de la lección:

Abstract

Las funciones son una herramienta esencial para construir software reutilizable, legible y organizado. Kotlin facilita su declaración mediante una sintaxis concisa y expresiva, que incorpora características como parámetros con valores por defecto, funciones de una sola expresión e inferencia de tipos.

En esta lección aprenderás a declarar funciones en Kotlin, comprender cómo utilizar vararg vararg para aceptar múltiples argumentos y cuándo conviene especificar tipos de retorno. También explorarás funciones estándar como map map y fold fold , y conocerás las diferencias entre colecciones como Array Array y List List .

No es necesario dominar todos los detalles desde el principio: a medida que avancemos en el curso, retomaremos y profundizaremos los conceptos más relevantes.

Funciones en Kotlin

Una función en Kotlin es un bloque de código reutilizable que encapsula una tarea específica. Su sintaxis básica es la siguiente:

Estructura general

fun functionName(param1: Type1, param2: Type2 = defaultValue, ...): ReturnType {
    // Cuerpo de la función
    return result
}

fun functionName(param1: Type1, param2: Type2 = defaultValue, ...): ReturnType {
    // Cuerpo de la función
    return result
}

Explicación de la sintaxis

fun fun : Palabra clave para declarar una función.
functionName functionName : Nombre que identifica a la función; debe ser claro y representativo de su propósito.
Parámetros ( param1 param1 , param2 param2 ): Lista de argumentos con sus respectivos tipos.
- Una función puede no tener parámetros.
- Es posible asignar valores por defecto, lo que permite omitir argumentos al llamarla.
ReturnType ReturnType : Tipo del valor que retorna la función.
- Si no devuelve un valor significativo, se utiliza Unit Unit , aunque puede omitirse por ser implícito.
Cuerpo de la función: Conjunto de instrucciones que se ejecutan cuando se llama.

Ejemplo: Sumar dos números

Supongamos que queremos crear una función que sume dos números enteros. La declaración básica sería:

Versión con cuerpo de bloque

functions/src/main/kotlin/cl/ravenhill/math/add.kt

fun add(a: Int, b: Int): Int {
    return a + b
}

fun add(a: Int, b: Int): Int {
    return a + b
}

Si la función contiene solo una expresión, puedes escribirla de forma más concisa utilizando asignación directa:

Versión con asignación directa y tipo explícito

functions/src/main/kotlin/cl/ravenhill/math/add.kt

fun add(a: Int, b: Int): Int = a + b

fun add(a: Int, b: Int): Int = a + b

Kotlin incluso permite inferir el tipo de retorno automáticamente:

Versión con inferencia de tipo de retorno

functions/src/main/kotlin/cl/ravenhill/math/add.kt

fun add(a: Int, b: Int) = a + b

fun add(a: Int, b: Int) = a + b

Este estilo hace que el código sea más breve, pero conviene usarlo con moderación: puede dificultar la lectura si el tipo de retorno no es evidente, y volver el código más frágil frente a cambios accidentales.

Si vienes de Scala...

En Kotlin, la palabra clave return return es obligatoria cuando utilizas el bloque clásico { ... } { ... } . Esto contrasta con Scala, donde la última expresión de una función se retorna automáticamente sin necesidad de usar return return .

En Kotlin, ese comportamiento implícito solo se aplica cuando se utiliza la sintaxis de una sola expresión ( = ... = ... ).

Inferencia de tipos

Kotlin es un lenguaje con inferencia de tipos, lo que significa que el compilador puede deducir el tipo de una variable o expresión a partir del contexto. En el ejemplo anterior, dado que la función contiene una sola expresión, el tipo de retorno se infiere automáticamente.

No abuses de la inferencia

Aunque la inferencia puede hacer el código más limpio y conciso, no siempre es recomendable omitir los tipos. En funciones públicas, con lógica compleja o que formen parte de una API, declarar el tipo explícitamente mejora la legibilidad, actúa como documentación autoexplicativa y facilita la evolución del código a largo plazo.

Estilo de nombres

En Kotlin, las funciones y variables deben nombrarse usando la convención camelCase. Esto implica lo siguiente:

El nombre comienza con una letra minúscula.
Cada palabra siguiente se escribe sin espacios, iniciando con mayúscula.

Ejemplos correctos:

calculateTotal calculateTotal
printMessage printMessage
main main

Usar un estilo de nombres consistente mejora la legibilidad y asegura que tu código esté alineado con las prácticas idiomáticas de Kotlin.

Estilos incorrectos

Evita estilos heredados de otros lenguajes o que no son válidos en Kotlin:

CalculateTotal CalculateTotal — PascalCase, reservado para clases y tipos.
calculate_total calculate_total — snake_case, típico en Python, no se utiliza en Kotlin.
calculate-total calculate-total — kebab-case, inválido como identificador.
CALCULATE_TOTAL CALCULATE_TOTAL — UPPER_SNAKE_CASE, reservado para constantes y valores inmutables en tiempo de compilación.

Trailing lambdas (λ al final)

En Kotlin, si el último parámetro de una función es otra función (un function type), puedes pasar la lambda fuera de los paréntesis. Si además es el único parámetro, puedes omitir los paréntesis. Esto mejora la legibilidad, especialmente con operaciones sobre colecciones y DSLs.

Sintaxis básica

// Sin trailing lambda
list.filter({ x -> x > 10 }).map({ x -> x * 2 })

// Con trailing lambda: paréntesis opcionales
list.filter() { x -> x > 10 }.map() { x -> x * 2 }

// Con trailing lambda: la lambda sale de los paréntesis
list.filter { x -> x > 10 }.map { x -> x * 2 }

// Sin trailing lambda
list.filter({ x -> x > 10 }).map({ x -> x * 2 })

// Con trailing lambda: paréntesis opcionales
list.filter() { x -> x > 10 }.map() { x -> x * 2 }

// Con trailing lambda: la lambda sale de los paréntesis
list.filter { x -> x > 10 }.map { x -> x * 2 }

¿Qué acabamos de hacer?

Último parámetro funcional → la lambda puede ir fuera de (...) (...) .
Único parámetro → puedes omitir por completo (...) (...) .
Útil en map map , filter filter , fold fold , DSLs ( apply apply , with with , buildString buildString ), etc.

Lectura fluida

Prefiere trailing lambdas cuando la acción principal es la lambda: p.ej., list.map { ... } list.map { ... } introduce menos "ruido visual" que list.map({ ... }) list.map({ ... }) .

Ambigüedades y sobrecargas

Si una función tiene varias sobrecargas o parámetros con valores por defecto, el trailing lambda puede volver ambigua la llamada. En esos casos, añade parámetros con nombre o vuelve a poner la lambda dentro de (...) (...) .

Retornos desde lambdas

Dentro de una lambda, return return intenta salir de la función envolvente (no de la lambda) en lambdas en línea. Para volver desde la propia lambda, usa return@nombre return@nombre :

users.forEach {
    if (it.age < 0) return@forEach  // solo salta esta iteración
    println(it.name)
}

users.forEach {
    if (it.age < 0) return@forEach  // solo salta esta iteración
    println(it.name)
}

Funciones variádicas ( `vararg vararg` )

En Kotlin puedes definir funciones que aceptan una cantidad variable de argumentos usando la palabra clave vararg vararg . Esto permite invocar la función con cero, uno o más valores del mismo tipo, de manera similar a *args *args en Python o ...args ...args en JavaScript.

Ejemplo: sumar múltiples números

functions/src/main/kotlin/cl/ravenhill/math/sum.kt

fun sumAll(vararg nums: Int): Int =
    nums.sum()

fun sumAll(vararg nums: Int): Int =
    nums.sum()

`sum() sum()`

La función sum() sum() es una extensión que suma todos los elementos de una colección o arreglo.

En el caso de IntArray IntArray , su firma es:

fun IntArray.sum(): Int

fun IntArray.sum(): Int

Esto equivale a realizar: nums[0] + nums[1] + ... + nums[n-1] nums[0] + nums[1] + ... + nums[n-1] .

También existen variantes para otros tipos de colecciones numéricas:

fun Array<out Int>.sum(): Int
fun Iterable<Double>.sum(): Double
// ...

fun Array<out Int>.sum(): Int
fun Iterable<Double>.sum(): Double
// ...

Array<out T> Array<out T> es una colección covariante, lo que significa que puedes pasar cualquier subtipo de T T sin modificar la colección.
El principio get-put establece que un tipo covariante puede utilizarse como tipo de retorno ( out out ) pero no como tipo de entrada ( in in ).

En este caso, out out indica que el arreglo solo se emplea para obtener valores, no para insertarlos.
Las versiones para List List , Set Set y otros Iterable<T> Iterable<T> funcionan del mismo modo.

Invocación de la función

functions/src/main/kotlin/cl/ravenhill/math/sum.kt

sumAll(1, 2, 3, 4)  // devuelve 10
sumAll()            // devuelve 0

sumAll(1, 2, 3, 4)  // devuelve 10
sumAll()            // devuelve 0

Si ya tienes un arreglo existente, puedes desempaquetar sus elementos usando el prefijo * * al pasarlo como argumento:

Desempaquetar un arreglo

functions/src/main/kotlin/cl/ravenhill/math/sum.kt

val extras = intArrayOf(5, 6)
sumAll(1, 2, *extras) // devuelve 14

val extras = intArrayOf(5, 6)
sumAll(1, 2, *extras) // devuelve 14

`* *` solo funciona con arreglos

El operador * * para desempaquetar argumentos funciona exclusivamente con arreglos ( Array Array o tipos primitivos como IntArray IntArray ). Si tienes una List List , primero debes convertirla a un arreglo usando list.toTypedArray() list.toTypedArray() :

val extrasList = listOf(5, 6) 
sumAll(1, 2, *extrasList.toTypedArray()) // devuelve 14

val extrasList = listOf(5, 6) 
sumAll(1, 2, *extrasList.toTypedArray()) // devuelve 14

Ten en cuenta que toTypedArray() toTypedArray() crea una copia completa de la lista en memoria. En colecciones grandes, esto implica una asignación y recorrido adicionales, lo que puede afectar el rendimiento y el consumo de memoria.

Hack: Uno o más argumentos

Si necesitas que una función reciba al menos un argumento obligatorio, declara ese argumento como un parámetro normal y colócalo antes de un vararg vararg .

Una forma sencilla de recordarlo es compararlo con las expresiones regulares:

representa “cero o más repeticiones”
representa “una o más repeticiones”

En este contexto:

El parámetro obligatorio equivale a + + .
El vararg vararg equivale a * * .

Combinados, expresan la idea de “uno o más argumentos”.

Al menos un argumento requerido

functions/src/main/kotlin/cl/ravenhill/math/sum.kt

fun sumTo(first: Int, vararg rest: Int): Int =
    rest.fold(first) { acc, i -> acc + i }

fun sumTo(first: Int, vararg rest: Int): Int =
    rest.fold(first) { acc, i -> acc + i }

`fold() fold()`

La función fold() fold() es una extensión que aplica una operación acumulativa sobre los elementos de una colección, comenzando desde un valor inicial.

En este caso, para IntArray IntArray :

fun IntArray.fold(initial: Int, operation: (acc: Int, Int) -> Int): Int

fun IntArray.fold(initial: Int, operation: (acc: Int, Int) -> Int): Int

Esto equivale a: initial + this[0] + this[1] + ... initial + this[0] + this[1] + ... .

fold() fold() también se puede usar con:

Arreglos primitivos ( DoubleArray DoubleArray , FloatArray FloatArray , etc.)
Arreglos genéricos ( Array<T> Array<T> )
Colecciones ( List<T> List<T> , Set<T> Set<T> , etc.)

Versiones generalizadas:

fun <T, R> Array<out T>.fold(initial: R, operation: (acc: R, T) -> R): R
fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R

fun <T, R> Array<out T>.fold(initial: R, operation: (acc: R, T) -> R): R
fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R

Aquí R R es el tipo del acumulador, T T el tipo de los elementos, y out out indica covarianza: puedes pasar subtipos de T T como elementos.

Ejemplos de uso

functions/src/main/kotlin/cl/ravenhill/math/sum.kt

sumTo(1)                                        // devuelve 1
sumTo(1, 2, 3, 4)                               // devuelve 10
sumTo(first = 1, rest = intArrayOf(2, 3, 4))    // devuelve 10

sumTo(1)                                        // devuelve 1
sumTo(1, 2, 3, 4)                               // devuelve 10
sumTo(first = 1, rest = intArrayOf(2, 3, 4))    // devuelve 10

Este patrón también sirve para funciones con dos o más parámetros obligatorios, seguidos por una cantidad variable de argumentos opcionales.

`vararg vararg` vs. `Array Array`

En Kotlin, vararg vararg es una forma conveniente de permitir que una función reciba una cantidad variable de argumentos. Internamente, el compilador convierte esos argumentos en un arreglo ( Array<T> Array<T> , IntArray IntArray , etc.).

Esto significa que:

Usar vararg vararg es azúcar sintáctico^[*] Se llama azúcar sintáctica (syntactic sugar) a una forma más conveniente o legible de escribir algo que, en realidad, se traduce a una forma más básica del lenguaje. sobre una función que acepta un arreglo.
Puedes seguir llamando a la función con un arreglo existente usando el operador * * para desempaquetarlo.

Usando vararg vararg vs. pasando un arreglo

functions/src/main/kotlin/cl/ravenhill/math/sum.kt

fun sumAll(vararg nums: Int): Int = nums.sum()

val valores = intArrayOf(1, 2, 3)
sumAll(*valores)  // ✅ correcto: desempaquetado con *

fun sumAll(vararg nums: Int): Int = nums.sum()

val valores = intArrayOf(1, 2, 3)
sumAll(*valores)  // ✅ correcto: desempaquetado con *

Kotlin optimiza los tipos primitivos ( Int Int , Double Double , etc.) usando IntArray IntArray , DoubleArray DoubleArray , etc., en lugar de Array<Int> Array<Int> o Array<Double> Array<Double> . Esto mejora el rendimiento y evita el boxing innecesario.

`Array<T> Array<T>` vs. `List<T> List<T>`

Tanto Array<T> Array<T> como List<T> List<T> representan colecciones de tamaño fijo e inmutables en cuanto a estructura (no puedes agregar ni quitar elementos). Sin embargo, tienen propósitos diferentes: un Array<T> Array<T> es mutable en sus elementos y está más orientado a la eficiencia y la interoperabilidad con Java, mientras que List<T> List<T> es más expresiva y está pensada para un estilo idiomático y funcional.

Array<T> Array<T> es una estructura de bajo nivel, más cercana al funcionamiento de los arreglos en lenguajes como Java.
List<T> List<T> es parte de la API de colecciones de Kotlin, más expresiva y flexible para la programación funcional.

Comparativa entre `Array<T> Array<T>` y `List<T> List<T>` en Kotlin
Característica	`Array<T> Array<T>`	`List<T> List<T>`
Mutable	Sí ( `array[i] = ... array[i] = ...` )	No (estructura inmutable, pero sus elementos pueden ser mutables)
Tamaño fijo	Sí	Sí ( `List List` , no en `MutableList MutableList` )
Posiciones accesibles	Por índice ( `array[i] array[i]` )	Por índice ( `list[i] list[i]` )
Métodos funcionales	Limitados	Amplia API funcional
Uso común	Eficiencia, interoperabilidad con Java	Estilo idiomático, programación funcional
Conversión	`array.toList() array.toList()`	`list.toTypedArray() list.toTypedArray()`

En resumen

Usa List<T> List<T> para la mayoría de los casos, especialmente si buscas inmutabilidad lógica y una API más rica y expresiva para manipulación de datos.
Usa Array<T> Array<T> cuando necesites interoperar con código Java o cuando el rendimiento en acceso/modificación por índice sea crítico.

Ejercicio: Duplicar niveles de poder

Vamos a practicar la declaración de funciones en Kotlin aplicando una transformación sobre una lista. Supón que tienes una lista de niveles de poder ( Int Int ) y quieres duplicar cada uno de ellos usando map() map() .

Como recordatorio, map() map() aplica una función a cada elemento de una colección y devuelve una nueva colección con los resultados:

Firma de map() map()

fun <T, R> List<T>.map(transform: (T) -> R): List<R>
fun <T, R> Array<out T>.map(transform: (T) -> R): List<R>

fun <T, R> List<T>.map(transform: (T) -> R): List<R>
fun <T, R> Array<out T>.map(transform: (T) -> R): List<R>

Tu tarea es definir una función llamada doublePowers doublePowers que reciba una lista de enteros ( List<Int> List<Int> ) o bien una cantidad variable de argumentos ( vararg vararg ) y devuelva una nueva lista con cada valor duplicado.

Ejemplos de uso

Ejemplo de uso como lista

doublePowers(listOf(5, 10, 15)) 
// devuelve: [10, 20, 30]

doublePowers(listOf(5, 10, 15)) 
// devuelve: [10, 20, 30]

Ejemplo de uso como vararg vararg

doublePowers(5, 10, 15)
// devuelve: [10, 20, 30]
doublePowers(*intArrayOf(5, 10, 15))
// devuelve: [10, 20, 30]

doublePowers(5, 10, 15)
// devuelve: [10, 20, 30]
doublePowers(*intArrayOf(5, 10, 15))
// devuelve: [10, 20, 30]

Ambas versiones son equivalentes en funcionalidad, pero difieren en cómo se pasan los argumentos al invocar la función.

Solución

Solución: Input como lista

functions/src/main/kotlin/cl/ravenhill/math/doublePowers.kt

fun doublePowers(powers: List<Int>): List<Int> =
    powers.map { it * 2 }

fun doublePowers(powers: List<Int>): List<Int> =
    powers.map { it * 2 }

Solución: Input como vararg vararg

functions/src/main/kotlin/cl/ravenhill/math/doublePowers.kt

fun doublePowers(vararg powers: Int): List<Int> =
    powers.map { it * 2 }

fun doublePowers(vararg powers: Int): List<Int> =
    powers.map { it * 2 }

Conclusiones

En esta lección aprendimos la sintaxis básica para declarar funciones en Kotlin, un componente esencial para escribir código reutilizable, expresivo y mantenible. También exploramos variantes idiomáticas como la inferencia de tipos, las funciones variádicas y las diferencias clave entre colecciones como Array<T> Array<T> y List<T> List<T> .

Puntos clave

Las funciones se declaran con la palabra clave fun fun y pueden tener parámetros con valores por defecto.
El tipo de retorno puede inferirse automáticamente si la función se reduce a una sola expresión.
vararg vararg permite definir funciones que aceptan una cantidad variable de argumentos.
Es posible requerir al menos un argumento junto a vararg vararg , combinándolos en la firma.
Array<T> Array<T> y List<T> List<T> parecen similares, pero tienen diferencias clave en mutabilidad y uso.
Kotlin favorece un estilo conciso, pero también explícito y claro cuando la función es pública o compleja.

¿Qué nos llevamos?

Esta lección fue tu primer paso en el sistema de funciones de Kotlin.

No es necesario memorizar cada detalle ahora: usa este material como referencia rápida cuando lo necesites.

Retomaremos estos conceptos más adelante, profundizando según lo requiera cada unidad.

En otros lenguajes…

Python

¿Con ganas de más?

Referencias recomendadas

“ Functions ” en Kotlin docs Documentación oficial
Esta documentación ofrece una guía exhaustiva sobre la declaración y uso de funciones en Kotlin. Aborda desde conceptos básicos como la sintaxis con fun fun , el uso de parámetros con tipo explícito y valores por defecto, hasta temas más avanzados como funciones variádicas ( vararg vararg ), argumentos nombrados, funciones de una sola expresión, inferencia de tipos, funciones infijas ( infix infix ), genéricas y recursivas de cola ( tailrec tailrec ). También detalla cómo declarar funciones a nivel superior, funciones locales, de miembro y de extensión, promoviendo un estilo conciso, idiomático y expresivo. Es una fuente esencial para comprender el modelo funcional y flexible de funciones en Kotlin.

Declaración de funciones

Abstract

Funciones en Kotlin

Explicación de la sintaxis

Ejemplo: Sumar dos números

Si vienes de Scala...

Inferencia de tipos

No abuses de la inferencia

Estilo de nombres

Estilos incorrectos

Trailing lambdas (λ al final)

¿Qué acabamos de hacer?

Lectura fluida

Ambigüedades y sobrecargas

Retornos desde lambdas

Funciones variádicas ( vararg vararg )

sum() sum()

* * solo funciona con arreglos

Hack: Uno o más argumentos

fold() fold()

vararg vararg vs. Array Array

Esto significa que:

Array<T> Array<T> vs. List<T> List<T>

En resumen

Ejercicio: Duplicar niveles de poder

Ejemplos de uso

Solución

Conclusiones

Puntos clave

¿Qué nos llevamos?

En otros lenguajes…

¿Con ganas de más?

Referencias recomendadas

Funciones variádicas ( `vararg vararg` )

`sum() sum()`

`* *` solo funciona con arreglos

`fold() fold()`

`vararg vararg` vs. `Array Array`

`Array<T> Array<T>` vs. `List<T> List<T>`