What is a single-expression function in Kotlin, and how does its syntax differ from a regular block-body function?
answer
- = instead of { }
- No return keyword
- Body is one expression
- if/when/try are expressions
- Enables return-type inference
basics
~20 sIt is a function whose body is a single expression written after an equals sign instead of curly braces. For example: fun square(x: Int) = x * x. The result of the expression is what the function returns.
solid answer
~40 sA single-expression (expression-body) function replaces the block body { return ... } with = <expression>. The function's value is the expression itself, so no explicit return keyword is used. Example: fun square(x: Int): Int = x * x. With block bodies you write fun square(x: Int): Int { return x * x }. Because the right-hand side is an expression, the compiler can infer the return type, letting you drop the explicit type for simple cases: fun square(x: Int) = x * x infers Int. Expression bodies pair naturally with when, if, and elvis expressions, which are all expressions in Kotlin. Block-body functions cannot omit the return type (except those returning Unit) and require explicit return statements.
code
kotlin · 3 linesfun square(x: Int): Int = x * x
fun max(a: Int, b: Int) = if (a > b) a else b // inferred Int
fun greeting(name: String?) = "Hello, " + (name ?: "guest")go deeper
Recognizes the = syntax, knows there is no return keyword and that the expression is the result.
Knows if/when/try are expressions so non-trivial logic fits, and that the type can be inferred.
Articulates readability trade-offs and when a block body is the better choice.
Frames it as a style/idiom convention worth codifying in a team style guide and lint rules.
## What it is Kotlin lets you define a function in two body styles: - **Block body**: braces `{ ... }` containing statements, with explicit `return`. - **Expression body (single-expression function)**: an `=` followed by exactly one expression. The function evaluates that expression and returns its value. ```kotlin // Block body fun square(x: Int): Int { return x * x } // Expression body — same behavior fun square(x: Int): Int = x * x ``` ## Key mechanics - **No `return` keyword.** The expression after `=` *is* the return value. Writing `return` inside it is a syntax error in this form. - **It must be a single expression**, but in Kotlin many constructs are expressions: `if`, `when`, `try`, elvis `?:`, and function calls all produce values, so you can express quite complex logic. - **Return-type inference** is allowed: `fun square(x: Int) = x * x` — the compiler infers `Int`. This is only possible with expression bodies, never block bodies. ```kotlin fun describe(n: Int) = when { n < 0 -> "negative" n == 0 -> "zero" else -> "positive" } ``` ## Why use it It removes ceremony for small, pure functions and makes intent obvious: the function *is* its expression. It is idiomatic for accessors, mappers, and delegating one-liners. ## When NOT to use it If the body needs multiple statements, local variables across several lines, loops, or side effects, a block body is clearer. Forcing complex logic into one expression hurts readability.
- Can you write 'return' inside a single-expression function body?No. The expression after = is itself the return value; adding a return keyword is a compile error in expression-body form.
- Is 'fun f() = if (c) 1 else 2' valid?Yes, because if is an expression in Kotlin and returns a value, so it can serve as the single expression.
Like a math formula f(x) = x*x — you state what the result equals rather than describing steps to compute it.
saying these in an interview costs you the question
- Claiming you still need 'return' after the = sign
- Thinking the body can contain multiple statements separated by semicolons
- Saying expression bodies behave differently at runtime than block bodies
- Confusing = (expression body) with == or assignment