Single-expression functions in Kotlin - Step-by-Step Execution

Concept Flow - Single-expression functions

Define function with = expression

↓

Function returns expression result

↓

Call function

↓

Output result

A single-expression function in Kotlin uses = to return the result of one expression directly, making code shorter and clearer.

Execution Sample

Kotlin

fun square(x: Int) = x * x

fun main() {
  println(square(4))
}

Defines a single-expression function 'square' that returns x squared, then prints square(4).

Execution Table

Step	Action	Expression Evaluated	Result	Output
1	Call square(4)	4 * 4	16
2	Return from square	16	16
3	Print result	println(16)		16

💡 Function returns after evaluating single expression; main ends after printing.

Variable Tracker

Variable	Start	After call	Final
x	-	4	4
square(x)	-	-	16

Key Moments - 2 Insights

Why don't we use curly braces {} in single-expression functions?

Single-expression functions use = to return the expression result directly, so curly braces and explicit return are not needed (see execution_table step 1).

What happens if the expression has multiple statements?

Single-expression functions can only have one expression; multiple statements require a block with {} and explicit return.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'square(4)' at step 2?

A 16

B 4

C 8

D Error

💡 Hint

Check the 'Result' column at step 2 in the execution_table.

At which step is the output printed to the console?

A Step 1

B Step 3

C Step 2

D No output printed

💡 Hint

Look at the 'Output' column in the execution_table.

If we replace '=' with '{}' and omit 'return', what happens?

A Function still works the same

B Compilation error due to missing return

C Function returns Unit

D Function returns null

💡 Hint

Single-expression functions require '=' or explicit return in blocks.

Concept Snapshot

Single-expression functions use '=' followed by one expression.
They return the expression result automatically.
No curly braces or return keyword needed.
Example: fun square(x: Int) = x * x
Simplifies code and improves readability.

Full Transcript

This visual trace shows how a Kotlin single-expression function works. The function 'square' is defined with '=' and a single expression 'x * x'. When called with 4, it calculates 4 times 4, returning 16 immediately without curly braces or return keyword. The main function prints this result. The execution table tracks each step: calling the function, returning the result, and printing output. Variables 'x' and 'square(x)' are tracked to show their values. Key moments clarify why '=' is used and that multiple statements need a block. The quiz tests understanding of function return values, output timing, and syntax rules. This helps beginners see how single-expression functions simplify Kotlin code by returning one expression directly.

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