Functions & Lambdas

Why Functions Matter

Functions are the primary unit of code organization. A well-designed function does one thing, has a clear name, and can be tested in isolation. Kotlin's function syntax reduces boilerplate compared to Java while maintaining full expressiveness.

Basic Syntax

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

// Usage
println(greet("Amazon"))  // Hello, Amazon!

The return type goes after the parameter list. If a function returns nothing, the return type is omitted (Unit is implied):

fun printGreeting(name: String) {
    println("Hello, $name!")
    // Implicitly returns Unit
}

Single-Expression Functions

When a function body is a single expression, you can omit the braces and use =:

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

// Return type is inferred
fun multiply(a: Int, b: Int) = a * b

Single-expression functions are not just shorter. They signal to the reader that the function is a simple transformation with no side effects.

Default Parameters

Kotlin eliminates method overloading for default values. You declare defaults directly in the signature:

fun log(message: String, level: String = "INFO") {
    println("[$level] $message")
}

log("Server started")           // [INFO] Server started
log("Disk full", "WARN")       // [WARN] Disk full

In Java, you would need two overloaded methods. In Kotlin, one function handles both cases.

Named Arguments

When calling a function, you can name the arguments to improve clarity and skip defaults:

fun createUser(
    name: String,
    age: Int,
    email: String = "",
    active: Boolean = true
) {
    println("$name, age $age, active=$active")
}

// Skip default parameters by name
createUser(name = "Alice", age = 30)

// Reorder named arguments
createUser(active = false, name = "Bob", age = 25)

Named arguments are especially valuable when a function has many parameters of the same type. Without names, it is easy to swap two String or Int arguments by mistake.

Explicit Return Types

Kotlin can infer return types for non-recursive functions, but public API functions should declare them explicitly for documentation:

// Inferred return type (fine for private/internal)
fun doubleIt(x: Int) = x * 2

// Explicit return type (better for public API)
fun doubleIt(x: Int): Int = x * 2

First-Class Functions

In Kotlin, functions are first-class citizens. You can store them in variables, pass them as arguments, and return them from other functions. This is the foundation of functional programming patterns.

Lambda Expressions

A lambda is an anonymous function defined inline:

val double: (Int) -> Int = { x -> x * 2 }
println(double(5))  // 10

The syntax is { parameters -> body }. When a lambda has a single parameter, you can use it instead of naming it:

val isEven: (Int) -> Boolean = { it % 2 == 0 }
println(isEven(4))  // true

Passing Lambdas to Functions

Functions that accept lambdas as parameters are called higher-order functions. The standard library is full of them:

val numbers = listOf(1, 2, 3, 4, 5)

// filter, map, reduce all take lambdas
val evens = numbers.filter { it % 2 == 0 }       // [2, 4]
val doubled = numbers.map { it * 2 }               // [2, 4, 6, 8, 10]
val sum = numbers.reduce { acc, i -> acc + i }     // 15

Trailing Lambda Syntax

When the last parameter of a function is a lambda, you can move it outside the parentheses. When it is the only parameter, you can drop the parentheses entirely:

// These are all equivalent
numbers.filter({ it > 2 })
numbers.filter() { it > 2 }
numbers.filter { it > 2 }   // Preferred

This trailing lambda syntax makes higher-order functions read like built-in language constructs.

Function Types

Every lambda has a function type. You can use them as parameter types and return types:

fun applyOperation(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

val sum = applyOperation(3, 4) { a, b -> a + b }       // 7
val product = applyOperation(3, 4) { a, b -> a * b }    // 12

Returning Values from Lambdas

The last expression in a lambda is the return value. Use return@label to exit from an enclosing function:

fun processNumbers(numbers: List<Int>) {
    numbers.forEach {
        if (it < 0) return@forEach  // Skips negative, continues loop
        println(it)
    }
    println("Done")
}

Lambdas vs Anonymous Classes

Kotlin lambdas compile to the same bytecode as Java anonymous classes when implementing single-abstract-method interfaces. This means lambdas work seamlessly with Java APIs:

// Kotlin lambda
view.setOnClickListener { println("Clicked") }

// Equivalent Java anonymous class
// view.setOnClickListener(new OnClickListener() { ... })