# Chapter 9. Multi- to Single-Expression Functions

Nat and Duncan both love Kotlin’s single-expression function definitions. When should we use this form, why might we prefer it, and what Kotlin features can we use to make more functions single expressions?

As with Java, the code in a Kotlin function is usually { defined inside braces } and uses `return` to define the result of the function (unless it is `Unit`, Kotlin’s alias for `void`):

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

If the top level of the code is a single expression though, we can optionally drop the result type, and define the code with an expression after an equals sign:

``fun` `addToo``(``a``:` `Int``,` `b``:` `Int``):` `Int` `=` `a` `+` `b``

We can read this as: the result of function `add` equals `a + b`. Which makes sense for a single expression, and can also read nicely when that expression is itself composed of subexpressions:

````fun` `max``(``a``:` `Int``,` `b``:` `Int``):` `Int` `=`
`when` `{`
`a` `>` `b` `->` `a`
`else` `->` `b`
`}````

This interpretation makes less sense for functions that have side effects, especially those that perform I/O or write to mutable state. For instance:

``fun` `printTwice``(``s``:` `String``):` `Unit` `=` `println``(``"\$s\n\$s"``)``

We can’t read this as the result of `printTwice` equals `println(..)`, because `println` doesn’t have a result, or at least it doesn’t return one. Its function is entirely side effects, as we explored in Chapter 7.

# Reserve Single-Expression Functions for Calculations

If we adopt a convention of reserving single-expression functions for calculations (“Calculations”), then ...

Get Java to Kotlin now with O’Reilly online learning.

O’Reilly members experience live online training, plus books, videos, and digital content from 200+ publishers.