Functions

Why functions?

A function is a named, reusable block of code that does one job. Instead of repeating the GST calculation in ten places, you write it once as a function and call it ten times. If the rule changes, you fix one place.

fun withGst(price: Double, ratePercent: Double): Double {
    return price + price * ratePercent / 100
}

fun main() {
    val total = withGst(1000.0, 18.0)
    println(total)       // 1180.0
}

Unit: returning nothing

A function that only does something (like printing) and returns no useful value has the return type Unit. You can leave it out: fun greet(name: String) { ... } is the same as fun greet(name: String): Unit { ... }.

Single-expression functions

If a function just returns one expression, write = and the expression, without braces or return. Kotlin infers the return type. This style is very common.

fun square(n: Int) = n * n
fun isAdult(age: Int) = age >= 18
fun grade(marks: Int) = if (marks >= 33) "Pass" else "Fail"

Default arguments

A parameter can have a default value. Callers may leave it out. In Java you would write several overloaded versions; in Kotlin one function is enough.

fun ticket(from: String, to: String, passengers: Int = 1, classType: String = "Sleeper") =
    "$passengers x $classType: $from to $to"

fun main() {
    println(ticket("Pune", "Nagpur"))                  // 1 x Sleeper: Pune to Nagpur
    println(ticket("Pune", "Nagpur", 3))               // 3 x Sleeper: Pune to Nagpur
    println(ticket("Pune", "Nagpur", classType = "3A")) // 1 x 3A: Pune to Nagpur
}

Named arguments

You can name arguments when calling: sendSms(to = "98...", text = "Hi", urgent = true). Named arguments make calls with many parameters, especially Booleans, much easier to read, and you can give them in any order. Jetpack Compose code uses named arguments everywhere.

vararg: any number of arguments

fun total(vararg prices: Int): Int {
    var sum = 0
    for (p in prices) sum += p
    return sum
}

fun main() {
    println(total(120, 80, 45))     // 245
    println(total())                // 0
}

Top-level and local functions

Kotlin functions do not need to live inside a class. A function written directly in a file is a top-level function, usable from anywhere in the module. You can also define a function inside another function (a local function) for a small helper that nobody else needs.

Common mistakes

• Forgetting the return type when using braces and return: the function then returns Unit, and return value is an error. Add : Type.
• Using return inside a single-expression function body. With =, there is no return keyword.
• Positional Boolean arguments like save(true, false). Use named arguments: save(sync = true, notify = false).
• Mixing named and positional arguments in a confusing order. Keep positional ones first.