Kotlin Functions

fun greet(name: String) {
    println("Hello, $name!")
}

fun area(width: Double, height: Double): Double {
    return width * height
}

greet("Ada")
val room = area(4.0, 3.5)

• Each parameter has a name and a type: name: String.
• The return type comes after the brackets: : Double. return sends the result back.
• A function that returns nothing useful has the type Unit, which you can leave out, as in greet.
• Parameters are read-only, like val.

When a function's body is one expression, replace the braces and return with =:

fun area(width: Double, height: Double) = width * height
fun isAdult(age: Int) = age >= 18
fun label(score: Int) = if (score >= 50) "Pass" else "Fail"

Kotlin infers the return type from the expression. For public functions that other code relies on, writing the return type explicitly is still good practice: fun area(w: Double, h: Double): Double = w * h.

Give a parameter a default value and callers can leave it out:

fun order(item: String, size: String = "medium", sugar: Int = 0) =
    "$size $item with $sugar sugar"

order("tea")                         // medium tea with 0 sugar
order("coffee", "large")             // large coffee with 0 sugar
order("tea", sugar = 2)              // medium tea with 2 sugar

Named arguments (sugar = 2) say which parameter each value is for. They let you skip parameters with defaults, and they make calls with several similar values, like createUser("Ana", true, false), much easier to understand: createUser("Ana", isAdmin = true, sendEmail = false).

vararg accepts any number of arguments, which arrive as an array:

fun average(vararg numbers: Int): Double = numbers.average()
average(4, 8, 9)

To return two values, return a Pair with to, and unpack it with destructuring: val (low, high) = minMax(list). For three or more values, a data class is clearer.

Functions can also be declared inside other functions when they're only useful there, keeping helper code close to where it's used.

A vararg parameter wants separate values, so passing a whole list doesn't work directly. Put the values in an array and add the spread operator * in front of it:

fun average(vararg numbers: Int): Double = numbers.average()

val scores = listOf(4, 8, 9)
println(average(*scores.toIntArray()))          // 7.0
println(average(1, *intArrayOf(2, 3), 10))      // 4.0

The * unpacks the array into individual arguments, and you can mix it with ordinary values, as in the second call. For an Int vararg you need an IntArray, which is what toIntArray() gives you; for a String vararg you'd use toTypedArray().

Two functions can share a name as long as their parameter types differ. This is called overloading, and Kotlin picks the right version from the arguments:

fun format(price: Double) = "£%.2f".format(price)
fun format(price: Int) = "£$price.00"

format(3.5)   // £3.50
format(3)     // £3.00

Before writing overloads, check whether a default argument would do the same job with a single function. Defaults usually lead to less code.

A function can also call itself. This is recursion, and it suits problems that are defined in terms of a smaller version of themselves:

fun factorial(n: Int): Long = if (n <= 1) 1 else n * factorial(n - 1)

tailrec fun gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)

factorial(5) is 120. Every recursive function needs a stopping case, here n <= 1, or it calls itself until the program runs out of stack and crashes with a StackOverflowError. When the recursive call is the very last thing a function does, as in gcd, marking it tailrec lets the compiler turn it into a loop, so it can't overflow the stack.

Two special return types are worth recognising:

Because Nothing fits anywhere, you can write val n = text.toIntOrNull() ?: fail("Not a number"), and n is still a plain Int.