Functions

Reviewed & published by Brayan K

Kotlin is a modern, concise language where functions are first-class building blocks — declared with fun, they package reusable logic and return values cleanly.

Part of the free Kotlin course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

By the end of this lesson you'll define functions with typed parameters and return types, write compact single-expression functions, and understand Unit.

What You'll Learn in This Lesson

• How to declare a function with fun
• Typed parameters and explicit return types
• Returning values with return
• Single-expression functions with =
• What Unit means (Kotlin's void)
• Composing functions by calling one from another

1️⃣ Declaring Functions

A Kotlin function starts with fun, followed by a name, parameters written as name: Type, and an optional return type after a colon. Inside, return hands a value back to the caller.

// Declare a function with 'fun'. Parameters are name: Type.
// The return type comes after the parameter list, following a colon.
fun add(a: Int, b: Int): Int {
    return a + b
}

// A function that returns nothing has return type Unit (you can omit it).
fun greet(name: String) {
    println("Hello, $name!")
}

fun main() {
    val sum = add(3, 4)
    println("3 + 4 = $sum")      // -> 3 + 4 = 7

    greet("Linus")               // -> Hello, Linus!
}

The greet function returns nothing useful, so its type is Unit — Kotlin's equivalent of void. You can omit : Unit entirely.

2️⃣ Single-Expression Functions

When a function is just one expression, you can replace the braces and return with an = sign. The return type is inferred. This is one of the most idiomatic patterns in Kotlin for small, focused functions.

// Single-expression functions: replace the braces and 'return'
// with an = sign. The return type is inferred.
fun square(n: Int) = n * n

fun max(a: Int, b: Int) = if (a > b) a else b

// Functions can call other functions, building up behaviour.
fun describe(n: Int): String =
    if (n % 2 == 0) "$n is even" else "$n is odd"

fun main() {
    println(square(5))           // -> 25
    println(max(8, 3))           // -> 8
    println(describe(7))         // -> 7 is odd
    println(describe(square(2))) // -> 4 is even
}

Functions compose naturally: describe(square(2)) first squares 2 to get 4, then describes it. Small functions that each do one thing are the foundation of clean code.

Your turn. Replace each TODO, then run and compare.

// 🎯 YOUR TURN — replace each TODO then run main()

// 1) Write a single-expression function that returns the larger of two Ints.
fun larger(a: Int, b: Int) = if (a > b) a TODO b   // 👉 replace TODO with 'else'

// 2) Write a function that returns true if a number is even.
fun isEven(n: Int): Boolean {
    return n % 2 TODO 0          // 👉 replace TODO with '=='
}

fun main() {
    println(larger(10, 4))       // expect 10
    println(isEven(6))           // expect true
}

Mini-Challenge: A Temperature Converter

Write two small functions — one for the maths, one for the label — and combine them in main().

// 🎯 MINI-CHALLENGE: a temperature converter.
// Save as Temp.kt and run main().
//
// 1. Write fun cToF(c: Double): Double that returns c * 9 / 5 + 32.
//    (Try writing it as a single-expression function.)
// 2. Write fun label(c: Double): String that returns
//    "freezing" if c <= 0, "hot" if c >= 30, else "mild".
// 3. In main(), print the Fahrenheit value and label for 25.0.
//
// ✅ Example output:
//    25.0C = 77.0F (mild)

fun main() {
    // your code here
}

Common Errors (and the fix)

• "A function with a block body must specify a return type" — When you use braces and { return ... }, you must declare the return type (e.g. : Int). Or switch to single-expression form with =.
• Missing a parameter type — Every parameter needs a type: fun f(x: Int), not fun f(x).
• Forgetting to return a value — A non-Unit function must return on every path. The compiler will flag a missing return.
• Calling before defining? No problem — Order of top-level functions doesn't matter; the compiler sees them all. But arguments must match the parameter types.

Pro Tips

• 💡 Prefer single-expression form for one-liners — it's shorter and the return type is inferred.
• 💡 Keep functions small: one function, one job. It's easier to name, test, and reuse.
• 💡 Return a Pair when you need two values: return Pair(a, b) and destructure with val (x, y) = ....

📋 Quick Reference — Functions

🎉 Lesson Complete!

• ✅ Functions are declared with fun
• ✅ Parameters are name: Type; return type follows a colon
• ✅ Single-expression functions use = and infer the type
• ✅ Unit is Kotlin's "returns nothing"
• ✅ Small functions compose into bigger behaviour

Practice quiz

Continue this course

• Previous: Arrays
• Next: Default & Named Arguments — Reduce overloads with default parameter values and named arguments
• Quick reference: Kotlin cheat sheet › Functions & Lambdas

Frequently asked questions

What is a single-expression function?

When a function's body is a single expression, you can drop the curly braces and the return keyword and write it with an = sign instead: fun square(n: Int) = n * n. The return type is inferred from the expression, though you may state it explicitly for clarity. This style is very common in Kotlin for small, pure functions and keeps code concise and readable.

What is Unit and how is it different from void?

Unit is Kotlin's type for functions that don't return a meaningful value — the equivalent of void in Java. The difference is that Unit is a real type with a single value, so it fits into Kotlin's everything-is-an-expression model. You almost never write : Unit explicitly; if a function has no return type annotation and returns nothing, it returns Unit automatically.

Does the order of parameters matter when I call a function?

When you pass arguments positionally, yes — the first argument fills the first parameter, and so on. However, Kotlin also lets you pass named arguments like add(b = 4, a = 3), in which case order doesn't matter and the code is clearer. Named arguments and default values are powerful features you'll explore fully in the 'Default & Named Arguments' lesson.

Can a function return more than one value?

Not directly, but you have good options. You can return a small data class holding the values, or use one of Kotlin's built-in Pair or Triple types, for example return Pair(name, age). The caller can then destructure it with val (name, age) = result. For anything beyond two or three related values, a named data class is usually the cleanest choice.