Concise Functions: Kotlin's Shorthand Syntax

Hello! This is the final lesson in our "Kotlin Fundamentals" module.

In our previous lesson, we explored how default and named arguments make function calls more flexible and readable. We saw how this is a cornerstone of APIs like Jetpack Compose.

Today, we'll focus on making the function definitions themselves more concise. We will cover single-expression functions, another of Kotlin's elegant features that helps you write clean, idiomatic code. Since you're familiar with Java's more verbose syntax, you'll find this a refreshing way to reduce boilerplate.

By the end of this 60-minute lesson, you'll be able to transform standard block-body functions into sleek, single-expression functions using Kotlin's shorthand syntax.

From Block Bodies to Single Expressions

In Java, and as we've seen in Kotlin so far, functions are typically defined with a "block body" using curly braces {}. The return keyword is used to send a value back to the caller.

// A standard function with a block body
fun calculateArea(width: Double, height: Double): Double {
    return width * height
}

This is perfectly valid Kotlin code, but when a function's body consists of just one expression, Kotlin offers a more concise syntax. You can:

Remove the curly braces {}.
Remove the return keyword.
Place the expression directly after an equals sign =.

Let's see this in action.

A Java Developer's Guide to Kotlin Basics

The article 'A Java Developer's Guide to Kotlin Basics' provides a very clear before-and-after example of this transformation. It's a great starting point.

Read the subsection titled 'Single-Expression Functions'. Pay close attention to how the traditional square function is simplified into a single line.

As the article demonstrates, a function like this:

// Traditional function
fun square(x: Int): Int {
    return x * x
}

Becomes this:

// Simplified single-expression version
fun square(x: Int): Int = x * x

This syntax makes simple functions much easier to read at a glance.

The Power of Type Inference

The syntax gets even cleaner. For single-expression functions, the Kotlin compiler is often smart enough to figure out the return type on its own. This is called type inference.

If the compiler can determine the type of the expression on the right side of the =, you can omit the explicit return type declaration.

Functions | Kotlin Documentation

The official Kotlin documentation explains this feature and its nuances authoritatively. Let's study the relevant section to understand how it works and when to be careful.

Read the section titled 'Single-expression functions'. Note the example where the compiler infers the return type and the important warnings about when you should explicitly declare the type.

Based on the documentation, we can further simplify our square function:

// The compiler infers that the function returns an Int
fun square(x: Int) = x * x

The compiler sees x * x where x is an Int, and correctly infers that the result must also be an Int.

When to Explicitly Declare Return Types

While type inference is powerful, the documentation rightly points out situations where you should (or must) explicitly declare the return type:

Readability and Clarity: Sometimes, even if the compiler can infer the type, explicitly stating it makes the code clearer for human readers. This is especially true for functions in a public API.

Guiding the Compiler: If you want the return type to be a supertype (e.g., Number instead of Int), you must declare it.

// Without explicit type, this returns Int
fun double(x: Int) = x * 2

// With explicit type, we can return a more general type
fun doubleAsNumber(x: Int): Number = x * 2

Recursive Functions: For a function that calls itself, the compiler cannot infer the return type without it being declared first.

// This will cause a compiler error
// fun factorial(n: Int) = if (n == 1) 1 else n * factorial(n - 1)

// This is correct
fun factorial(n: Int): Int = if (n == 1) 1 else n * factorial(n - 1)

Combining with Other Kotlin Features

Single-expression functions become even more powerful when combined with features we've already learned, like default arguments and if/else expressions.

Remember how if/else in Kotlin is an expression that returns a value? This makes it a perfect candidate for single-expression functions.

Let's convert a block-body function that uses if/else into a single-expression one.

Before (Block Body):

fun getWelcomeMessage(user: String, isLoggedIn: Boolean): String {
    if (isLoggedIn) {
        return "Welcome back, $user!"
    } else {
        return "Hello, Guest!"
    }
}

After (Single Expression):

fun getWelcomeMessage(user: String, isLoggedIn: Boolean): String = 
    if (isLoggedIn) "Welcome back, $user!" else "Hello, Guest!"

We can even omit the return type here, as the compiler can infer it's a String.

fun getWelcomeMessage(user: String, isLoggedIn: Boolean) = 
    if (isLoggedIn) "Welcome back, $user!" else "Hello, Guest!"

Practice Exercise

Let's apply this to a scenario from your past projects. Imagine you're working on your e-banking system. You need a function to determine the status of a transaction based on its amount.

Start with the following block-body function. It takes a transaction amount and returns a String label.

fun getTransactionStatus(amount: Double): String {
    return if (amount > 10000.0) {
        "Requires Manual Approval"
    } else {
        "Approved Automatically"
    }
}

Your task is to rewrite getTransactionStatus as a single-expression function.
First, rewrite it while keeping the explicit : String return type.
Then, create a second version where you let the compiler infer the return type.

Click for the solution

Here is the solution for the practice exercise.

1. Single-Expression Function with Explicit Return Type:
This version is more concise than the block body but still clearly states its intent to return a String.

fun getTransactionStatus(amount: Double): String =
    if (amount > 10000.0) "Requires Manual Approval" else "Approved Automatically"

2. Single-Expression Function with Inferred Return Type:
This is the most concise version. The compiler examines the if/else expression, sees that both branches return a String, and infers the function's return type as String.

fun getTransactionStatus(amount: Double) =
    if (amount > 10000.0) "Requires Manual Approval" else "Approved Automatically"

Both versions are correct and demonstrate idiomatic Kotlin. The choice between them often comes down to team coding style and the desired level of explicitness.

Conclusion

Congratulations on completing the first module on Kotlin fundamentals! We've built a strong foundation, moving from variables and control flow to the nuances of defining functions.

Key Takeaways from this Lesson:

For functions with a body consisting of a single expression, you can use the = syntax to make them more concise.
This involves removing the curly braces {} and the return keyword.
In many cases, the Kotlin compiler can infer the return type, allowing you to omit it for even cleaner code.
Be mindful of cases like recursion or the need for a specific supertype, where you must declare the return type explicitly.

What's Next?

We have successfully covered the basics of writing and structuring code in Kotlin. In the next module, Object-Oriented Programming in Kotlin, we will take a significant step forward. We'll start by learning how to define classes with primary and secondary constructors. This will be the foundation for building the objects that will populate your Android applications, from simple data holders to complex UI components.

Recommended resources