Mastering Kotlin Functions: A Beginner’s Guide to Functions, Lambdas, and More

April 2025
M	T	W	T	F	S	S
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30

Kotlin is a powerful programming language known for its concise syntax and expressive features. In this blog, we’ll explore one of the most important aspects of Kotlin: functions. We’ll cover various ways to define and use functions, including named arguments, default values, single-expression functions, and lambda expressions. This guide will also help you understand when and why to use them for clean and efficient code.

1. Declaring Functions in Kotlin

In Kotlin, we define functions using the fun keyword. The general structure includes:

Function name
Parameters (with types)
A return type
The body of the function inside curly braces

For example:

fun hello() {
    return println("Hello, world!")
}

fun main() {
    hello()
}

fun hello() {

return println("Hello, world!")

}

fun main() {

hello()

}

In this example, hello() prints "Hello, world!" when called.

2. Function Parameters and Return Types

Function parameters in Kotlin are defined within parentheses () with their respective types. You can also specify the return type after the parameter list using a colon :.

Here’s an example where we define a function sum() that accepts two integer parameters and returns their sum:

fun sum(x: Int, y: Int): Int {
    return x + y
}

fun main() {
    println(sum(1, 2))  // Output: 3
}

fun sum(x: Int, y: Int): Int {

return x + y

}

fun main() {

println(sum(1, 2)) // Output: 3

}

3. Named Arguments

In Kotlin, you can use named arguments to make the function calls more readable. Named arguments allow you to specify parameters by name rather than by position, making the code clearer.

Example:

fun printMessageWithPrefix(message: String, prefix: String) {
    println("[$prefix] $message")
}

fun main() {
    printMessageWithPrefix(prefix = "Log", message = "Hello")  // Output: [Log] Hello
}

fun printMessageWithPrefix(message: String, prefix: String) {

println("[

p r e f i x]

message")

}

fun main() {

printMessageWithPrefix(prefix = "Log", message = "Hello") // Output: [Log] Hello

}

4. Default Parameter Values

Kotlin allows you to specify default values for parameters. This enables you to omit certain arguments when calling the function.

fun printMessageWithPrefix(message: String, prefix: String = "Info") {
    println("[$prefix] $message")
}

fun main() {
    printMessageWithPrefix("Hello")  // Output: [Info] Hello
    printMessageWithPrefix("Hello", "Log")  // Output: [Log] Hello
}

fun printMessageWithPrefix(message: String, prefix: String = "Info") {

println("[

p r e f i x]

message")

}

fun main() {

printMessageWithPrefix("Hello") // Output: [Info] Hello

printMessageWithPrefix("Hello", "Log") // Output: [Log] Hello

}

5. Functions Without Return Values (Unit Type)

If a function doesn’t return anything meaningful, its return type is Unit. The Unit type is Kotlin’s equivalent of void in other languages. You can omit the return type in such cases, and the return keyword is optional.

Example:

fun printMessage(message: String) {
    println(message)
}

fun main() {
    printMessage("Hello")  // Output: Hello
}

fun printMessage(message: String) {

println(message)

}

fun main() {

printMessage("Hello") // Output: Hello

}

6. Single-Expression Functions

To make your code more concise, you can define single-expression functions. These functions are automatically inferred by Kotlin to have the correct return type.

fun sum(x: Int, y: Int) = x + y

fun main() {
    println(sum(1, 2))  // Output: 3
}

fun sum(x: Int, y: Int) = x + y

fun main() {

println(sum(1, 2)) // Output: 3

}

7. Early Returns

You can use return to exit a function early, especially in conditional statements. This helps avoid unnecessary computation.

fun registerUser(username: String, email: String): String {
    if (username in registeredUsernames) return "Username already taken."
    if (email in registeredEmails) return "Email already registered."
    
    registeredUsernames.add(username)
    registeredEmails.add(email)
    return "User registered successfully"
}

fun registerUser(username: String, email: String): String {

if (username in registeredUsernames) return "Username already taken."

if (email in registeredEmails) return "Email already registered."

registeredUsernames.add(username)

registeredEmails.add(email)

return "User registered successfully"

}

8. Lambda Expressions

In Kotlin, lambda expressions allow you to define concise anonymous functions. A lambda expression is written within curly braces {} and can be passed as arguments to other functions, making your code more flexible.

Example:

val upperCaseString = { text: String -&gt; text.uppercase() }
println(upperCaseString("hello"))  // Output: HELLO

val upperCaseString = { text: String -> text.uppercase() }

println(upperCaseString("hello")) // Output: HELLO

Lambda expressions are particularly useful when working with collections. For example, you can use .filter() or .map() functions to transform or filter lists:

val numbers = listOf(1, -2, 3, -4, 5, -6)
val positives = numbers.filter { x -&gt; x &gt; 0 }
println(positives)  // Output: [1, 3, 5]

val numbers = listOf(1, -2, 3, -4, 5, -6)

val positives = numbers.filter { x -> x > 0 }

println(positives) // Output: [1, 3, 5]

9. Function Types

Kotlin allows you to define the type of a function as a variable. The syntax for a function type is written as (parameterType) -> returnType.

val upperCaseString: (String) -&gt; String = { text -&gt; text.uppercase() }
println(upperCaseString("hello"))  // Output: HELLO

val upperCaseString: (String) -> String = { text -> text.uppercase() }

println(upperCaseString("hello")) // Output: HELLO

10. Returning Lambda Expressions from Functions

You can also return lambda expressions from functions. The return type of the function should match the lambda’s function type.

fun toSeconds(time: String): (Int) -&gt; Int = when (time) {
    "hour" -&gt; { value -&gt; value * 60 * 60 }
    "minute" -&gt; { value -&gt; value * 60 }
    else -&gt; { value -&gt; value }
}

fun main() {
    val min2sec = toSeconds("minute")
    println(min2sec(5))  // Output: 300 (5 minutes in seconds)
}

fun toSeconds(time: String): (Int) -> Int = when (time) {

"hour" -> { value -> value * 60 * 60 }

"minute" -> { value -> value * 60 }

else -> { value -> value }

}

fun main() {

val min2sec = toSeconds("minute")

println(min2sec(5)) // Output: 300 (5 minutes in seconds)

}

11. Trailing Lambdas

If a lambda expression is the only parameter in a function, you can write it outside the function parentheses. This is known as a trailing lambda.

val sum = listOf(1, 2, 3).fold(0) { x, item -&gt; x + item }
println(sum)  // Output: 6

val sum = listOf(1, 2, 3).fold(0) { x, item -> x + item }

println(sum) // Output: 6

Conclusion

Mastering Kotlin functions and lambda expressions helps you write cleaner, more efficient code. Functions provide a way to structure your logic, while lambdas allow for even more compact and flexible expressions. Whether you’re defining simple functions or working with more complex operations using lambdas, understanding these concepts is key to becoming proficient in Kotlin programming.

Happy coding!