Introducción a las funciones en Kotlin

En programación una función es un procedimiento o subrutina que realiza una tarea específica y puede retornar un valor. Las funciones pueden tomar parámetros que modifican su funcionamiento y son utilizadas para descomponer problemas mayores en tareas simples y para implementar operaciones que son recurrentemente utilizadas durante un programa y de esta manera reducir la cantidad de código y conseguir un código más eficiente.

Las funciones en Kotlin son declaradas usando la palabra fun seguida por un identificador,  luego los parámetros y su tipo (si existen) y el tipo de dato que devuelve (si existe) y finalmente el bloque de instrucciones que se ejecuta entre llaves que terminará con la instrucción return en caso de que devuelva algún valor. Las funciones son llamadas o invocadas con su nombre seguido de los argumentos entre paréntesis (si existen). Cuando una función no devuelve ningún valor, el tipo de retorno es Unit, y entonces no se requiere explicitarlo.

Unos ejemplos:

// función sin parámetros y sin valor de retorno
fun saludar() { // innecesario: fun saludar(): Unit
    print("Hola")
}
saludar() // Hola

// función con un parámetro y sin valor de retorno
fun saludar(nombre: String) {
    print("Hola $nombre")
}
saludar("Pepe") // Hola Pepe

// función con un parámetro que retorna un entero
fun doblar(x: Int): Int { // siempre que exista un valor de retono, se debe especificar su tipo
    return 2 * x
}
val resultado = doblar(4)
println(resultado) // 8

Cuando una función tiene una única expresión en el bloque de instrucciones, las llaves y la palabra return se pueden omitir y el cuerpo se especifica después de un símbolo =. En estos casos se puede inferir el tipo de retorno:

fun doblar(x: Int): Int = x * 2
fun doblar(x: Int) = x * 2 // con inferencia del tipo de retorno

Los parámetros de una función se definen por su nombre y tipo y cuando son más de uno se separan por comas:

fun sumar(x: Int, y: Int): Int {
    return x + y
}
println(sumar(2, 3)) // 5

fun calcular(x: Int, y: Int, operacion: String): Int {
    if (operacion == "restar") return x - y    
    return x + y    
}
println(calcular(5, 2, "sumar")) // 7
println(calcular(5, 2, "restar")) // 3

Los parámetros de una función pueden tener valores predeterminados, y estos valores por defecto son utilizados cuando en la llamada a la función se omite el argumento correspondiente. Por ejemplo:

fun calcular(x: Int, y: Int, operacion: String = "sumar"): Int {
    if (operacion == "restar") return x - y    
    return x + y
}
println(calcular(5, 2)) // 7 (toma el valor por defecto del parámetro operación)
println(calcular(5, 2, "restar")) // 3

Si un parámetro predeterminado precede a un parámetro sin valor predeterminado, es necesario especificar los nombres de los argumentos en caso de que se omita el parámetro por defecto o si se cambia el orden:

fun calcular(operacion: String = "sumar", x: Int, y: Int): Int {
    if (operacion == "restar") return x - y
    return x + y       
}
println(calcular(x = 5, y = 2)) // 7
println(calcular("restar", 5, 2)) // 3
println(calcular(x = 5, y = 2, operacion = "restar")) // 3

En cualquier caso, las funciones siempre pueden ser llamadas con los nombres de sus parámetros (esto suele ser conveniente cuando una función tiene una gran cantidad de parámetros):

fun restar(numero1: Int, numero2: Int): Int {
    return numero1 - numero2
}
println(restar(numero2 = 2, numero1 = 3)) // 1

Pero en estos casos hay que tener en cuenta que cuando se llama a una función con argumentos posicionales y con nombre, todos los argumentos posicionales deben colocarse antes del primero con nombre:

fun restar(numero1: Int, numero2: Int): Int {
    return numero1 - numero2
}    
println(restar(12, numero2 = 8)) // 4
println(restar(numero1 = 12, 8)) // ERROR: Mixing named and positioned arguments is not allowed

Otra opción es utilizar un número variable de argumentos marcando el parámetro con el modificador vararg:

fun calcularMedia(vararg input: Int): Float {
    var suma = 0.0f
    for (item in input) {
        suma += item
    }
    return (suma / input.size)
}
println(calcularMedia(1, 2, 3)) // 2.0
println(calcularMedia(1, 2, 3, 4, 5)) // 3.0