Kotlin - Single-Expression Functions

Single Expression Functions in Kotlin

Kotlin is known for its concise syntax and expressive capabilities. Among the language's features that contribute to this conciseness is the concept of single-expression functions. This feature allows developers to write functions in a compact form without sacrificing clarity or performance. In this guide, we will delve into what single-expression functions are, how to use them effectively, and when to prefer them over traditional function syntax.

1. Introduction to Functions in Kotlin

1.1 What is a Function?

A function is a block of reusable code designed to perform a particular task. In Kotlin, functions are declared using the fun keyword. A typical function might look like this:

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

This standard syntax is clear and familiar to developers from many backgrounds. However, in cases where the function consists of a single expression, Kotlin provides a more concise syntax.

2. What is a Single-Expression Function?

A single-expression function in Kotlin is a function that returns the result of a single expression. Instead of using curly braces and a return statement, the function body can be replaced by an equals sign followed by the expression.

2.1 Syntax

fun functionName(parameters): ReturnType = expression

Here's a simple example:

fun square(x: Int): Int = x * x

This function does exactly what a longer form would do but is significantly more concise.

2.2 Benefits of Single-Expression Functions

• Improved readability for simple logic
• Less boilerplate code
• Encourages functional programming style
• Easier to inline and optimize by the compiler

3. Examples of Single-Expression Functions

3.1 Basic Arithmetic

fun add(a: Int, b: Int): Int = a + b
fun subtract(a: Int, b: Int): Int = a - b
fun multiply(a: Int, b: Int): Int = a * b
fun divide(a: Int, b: Int): Int = a / b

3.2 String Operations

fun greet(name: String): String = "Hello, $name!"
fun fullName(first: String, last: String): String = "$first $last"

3.3 Boolean Checks

fun isPositive(number: Int): Boolean = number > 0
fun isEven(number: Int): Boolean = number % 2 == 0

3.4 Null Safety

fun safeLength(str: String?): Int = str?.length ?: 0

3.5 Collections

fun countOdds(numbers: List<Int>): Int = numbers.count { it % 2 != 0 }

4. Type Inference

Kotlin has powerful type inference, and in many cases, the return type of a single-expression function can be inferred by the compiler.

fun isAdult(age: Int) = age >= 18

In the example above, the compiler infers that the return type is Boolean.

4.1 When to Specify Return Types

While return types can often be omitted, it’s good practice to specify them for public APIs to ensure clarity and prevent unintended changes.

// With return type (recommended for public functions)
fun max(a: Int, b: Int): Int = if (a > b) a else b

// Without return type (acceptable for private/internal functions)
private fun min(a: Int, b: Int) = if (a < b) a else b

5. Comparison: Block Functions vs. Single-Expression Functions

5.1 Traditional Block Function

fun double(x: Int): Int {
    return x * 2
}

5.2 Equivalent Single-Expression Function

fun double(x: Int): Int = x * 2

Both achieve the same result, but the single-expression form is cleaner for simple logic.

6. When to Use Single-Expression Functions

6.1 Ideal Use Cases

• Utility methods
• Simple calculations
• Lambda wrappers
• Property-like accessors
• Compact logic where readability is preserved

6.2 When Not to Use Them

Avoid single-expression syntax when the function body becomes too complex. Readability should always be a priority.

// Avoid this
fun process(data: List<Int>) = data.filter { it > 0 }.map { it * 2 }.sum()

// Prefer this
fun process(data: List<Int>): Int {
    val filtered = data.filter { it > 0 }
    val mapped = filtered.map { it * 2 }
    return mapped.sum()
}

7. Single-Expression Functions in Higher-Order Programming

Single-expression functions are frequently used as lambdas or passed to higher-order functions like map, filter, or fold.

val numbers = listOf(1, 2, 3, 4, 5)
val squared = numbers.map { square(it) }

fun square(x: Int): Int = x * x

This approach keeps the code modular and clean, separating logic into named, reusable components.

8. Integration with Kotlin Features

8.1 With Extension Functions

fun String.lastChar(): Char = this[this.length - 1]

Single-expression functions shine when writing extension functions for utility purposes.

8.2 With Inline Functions

inline fun <T> measureTime(block: () -> T): T {
    val start = System.currentTimeMillis()
    val result = block()
    println("Time: ${System.currentTimeMillis() - start}ms")
    return result
}

While this is a block-style function, it's commonly used with single-expression functions as blocks.

val result = measureTime { computeExpensiveThing() }

fun computeExpensiveThing(): Int = (1..1_000_000).sum()

9. Interoperability with Java

When used in Kotlin classes that are called from Java, single-expression functions behave just like regular methods. However, Java developers may be surprised by how concise the Kotlin function definitions appear in the source code.

10. Best Practices

10.1 Keep it Simple

Use single-expression functions for logic that fits comfortably on one line. If a function has multiple branches or responsibilities, stick to the traditional syntax.

10.2 Use Descriptive Names

Because the function body is short, the function name must clearly describe what it does.

10.3 Don't Sacrifice Readability

Just because you can write a function in one line doesn’t mean you should. Maintainable code always prioritizes clarity over cleverness.

11. Summary

Kotlin’s support for single-expression functions enhances the language's focus on readability, conciseness, and expressive code. These functions allow developers to write logic in a highly compact form without losing expressiveness or performance.

• Use = instead of curly braces and return for simple functions.
• Great for utility methods, simple conditionals, and functional constructs.
• Let the compiler infer return types where safe, but prefer explicit types in public APIs.
• Always consider readability and maintainability when deciding on syntax.

By incorporating single-expression functions into your coding practices where appropriate, you can write more elegant, readable, and idiomatic Kotlin code.