Single-expression functions in Kotlin

Introduction

Single-expression functions let you write simple functions in one line. This makes your code shorter and easier to read.

When your function returns a simple calculation or value.

When you want to write clear and concise code.

When the function body has only one expression.

When you want to avoid writing curly braces and return statements.

When you want to quickly define small helper functions.

Syntax

Kotlin

fun functionName(parameters): ReturnType = expression

The equals sign = replaces the usual curly braces and return statement.

The expression after = is automatically returned.

Examples

This function returns the square of a number in one line.

Kotlin

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

Return type is inferred here because Kotlin can guess it from the expression.

Kotlin

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

This function returns true if the number is even, false otherwise.

Kotlin

fun isEven(num: Int) = num % 2 == 0

Sample Program

This program defines a single-expression function add that adds two numbers. It then prints the result.

Kotlin

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

fun main() {
    val result = add(5, 7)
    println("5 + 7 = $result")
}

Important Notes

Single-expression functions are great for simple logic but avoid using them for complex code blocks.

If your function needs multiple statements, use the regular function body with curly braces.

Summary

Single-expression functions let you write short functions in one line.

They automatically return the value of the expression after the equals sign.

Use them to make your code cleaner and easier to read.

Practice

1. What is a key feature of a single-expression function in Kotlin?

easy

A. It returns the value of the expression after the equals sign automatically.

B. It requires a block body with explicit return statements.

C. It cannot have parameters.

D. It must be declared inside a class.

Solution

1. Step 1: Understand single-expression function syntax

   Single-expression functions use an equals sign followed by an expression, without braces.

2. Step 2: Identify the return behavior

   They automatically return the value of that expression without needing an explicit return keyword.

3. Final Answer:

   It returns the value of the expression after the equals sign automatically. -> Option A

4. Quick Check:

   Single-expression function = auto return [OK]

Hint: Look for '=' and no braces for single-expression functions [OK]

Common Mistakes:

• Thinking explicit return is needed
• Assuming parameters are not allowed
• Believing it must be inside a class

2. Which of the following is the correct syntax for a single-expression function in Kotlin that adds two integers?

easy

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

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

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

D. fun add(a: Int, b: Int): Int => a + b

Solution

1. Step 1: Identify single-expression function syntax

   It uses '=' followed by the expression without braces or explicit return.

2. Step 2: Check each option

   fun add(a: Int, b: Int) = a + b matches this syntax exactly: fun add(a: Int, b: Int) = a + b.

3. Final Answer:

   fun add(a: Int, b: Int) = a + b -> Option B

4. Quick Check:

   Equals sign and expression = correct syntax [OK]

Hint: Single-expression functions use '=' not braces [OK]

Common Mistakes:

• Using braces with return in single-expression functions
• Using '=>' instead of '='
• Omitting '=' sign

3. What will be the output of this Kotlin code?

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

medium

A. 16

B. 4

C. x * x

D. Compilation error

Solution

1. Step 1: Understand the function behavior

   The function square returns the product of x times x.

2. Step 2: Calculate the output for input 4

   4 * 4 = 16, so square(4) returns 16, which is printed.

3. Final Answer:

   16 -> Option A

4. Quick Check:

   4 squared = 16 [OK]

Hint: Multiply input by itself for square function [OK]

Common Mistakes:

• Expecting the expression as a string output
• Confusing input with output
• Thinking it causes a compile error

4. Identify the error in this Kotlin single-expression function:

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

medium

A. Missing return type declaration.

B. String interpolation is invalid.

C. Using braces {} after equals sign is incorrect.

D. Function must have no parameters.

Solution

1. Step 1: Check single-expression function syntax

   Single-expression functions use '=' followed by an expression without braces.

2. Step 2: Identify the error

   The braces after '=' create a lambda block, which is not allowed here; it should be just the expression.

3. Final Answer:

   Using braces {} after equals sign is incorrect. -> Option C

4. Quick Check:

   No braces allowed after '=' in single-expression functions [OK]

Hint: No braces after '=' in single-expression functions [OK]

Common Mistakes:

• Adding braces after '='
• Thinking return type is mandatory
• Misusing string interpolation syntax

5. You want to write a Kotlin single-expression function that returns the length of a string only if it is not empty; otherwise, it returns zero. Which of these is correct?

hard

A. fun lengthOrZero(s: String) = s.length ?: 0

B. fun lengthOrZero(s: String) { if (s.isNotEmpty()) return s.length else return 0 }

C. fun lengthOrZero(s: String): Int = { if (s.isNotEmpty()) s.length else 0 }

D. fun lengthOrZero(s: String) = if (s.isNotEmpty()) s.length else 0

Solution

1. Step 1: Understand the requirement

   The function must return length if string is not empty, else zero, in a single expression.

2. Step 2: Check each option

   fun lengthOrZero(s: String) = if (s.isNotEmpty()) s.length else 0 uses a single-expression function with an if-else expression correctly. fun lengthOrZero(s: String) { if (s.isNotEmpty()) return s.length else return 0 } uses braces and explicit returns, not single-expression. fun lengthOrZero(s: String): Int = { if (s.isNotEmpty()) s.length else 0 } wrongly uses braces after '='. fun lengthOrZero(s: String) = s.length ?: 0 misuses the Elvis operator on Int.

3. Final Answer:

   fun lengthOrZero(s: String) = if (s.isNotEmpty()) s.length else 0 -> Option D

4. Quick Check:

   If-else expression after '=' = correct single-expression function [OK]

Hint: Use if-else expression directly after '=' for conditions [OK]

Common Mistakes:

• Using braces after '='
• Trying to use return inside single-expression function
• Misusing Elvis operator on non-nullable Int