Passing Functions as Parameters in Kotlin

By the end of this page, you will understand how Kotlin treats functions as values, how to pass a named function to another function, and when to use a lambda versus a function reference such as ::buz. You will also learn the function type rules that must match for this to work.

In Kotlin, functions are first-class values. That means you can:

• store them in variables
• pass them to other functions
• return them from functions

Your function foo expects a parameter named bar with this type:

(String) -> Unit

That type means:

• it takes one String argument
• it returns Unit (no useful return value)

The function buz has this signature:

fun buz(m: String): Unit

This matches the same shape:

• one String parameter
• returns Unit

So yes, buz can be passed to foo, but in Kotlin you usually pass a function reference, not just the bare function name.

Think of a function like a tool in a toolbox.

• A lambda is like creating a tool on the spot.
• A named function is like using a tool you already built and labeled.
• A function reference (::buz) is like handing someone the labeled tool so they can use it later.

So foo is saying:

Give me a message and also give me a tool that knows what to do with a String.

You can give it:

• a brand new tool:

foo("hello") { println(it) }

• or an existing tool by reference:

foo("hello", ::buz)

Core syntax

A function type in Kotlin looks like this:

(String) -> Unit

A function that accepts another function:

fun foo(m: String, bar: (String) -> Unit) {
    bar(m)
}

A named function with a matching signature:

fun buz(m: String) {
    println("another message: $m")
}

Pass the named function using a function reference:

foo("a message", ::buz)

Lambda vs function reference

Using a lambda

foo("a message") { println("this is a message: $it") }

Using a named function

 {
    println()
}

foo(, ::buz)

Consider this example:

fun foo(m: String, bar: (String) -> Unit) {
    bar(m)
}

fun buz(m: String) {
    println("another message: $m")
}

fun main() {
    foo("a message", ::buz)
}

Here is what happens step by step:

1. main() calls foo("a message", ::buz).
2. The first argument is the string "a message".
3. The second argument is a reference to the function buz.
4. Inside foo, the parameter m becomes "a message".
5. Inside foo, the parameter bar now refers to buz.
6. foo executes .

Higher-order functions and function references are common in real Kotlin code.

1. Processing collections

val names = listOf("ana", "bob", "carl")
println(names.map(String::uppercase))

Here String::uppercase is a function reference.

2. Validation rules

fun validate(input: String, rule: (String) -> Boolean): Boolean {
    return rule(input)
}

You can pass different validation functions depending on context.

3. Logging or formatting callbacks

fun processMessage(message: String, logger: (String) -> Unit) {
    logger(message)
}

This lets you swap out how messages are handled.

4. Event handling

UI frameworks and asynchronous code often expect functions to run later when something happens.

5. Reusable business rules

In real projects, developers use this concept to keep logic reusable and easy to test.

Common patterns

Guarded processing

fun withNonEmptyText(text: String, action: (String) -> Unit) {
    if (text.isBlank()) return
    action(text)
}

This uses an early return before calling the provided function.

Reusing named functions

fun logMessage(message: String) {
    println("LOG: $message")
}

fun handle(message: String, callback: (String) -> Unit) {
    callback(message)
}

handle("Started", ::logMessage)

This is clearer than repeating the same lambda in multiple places.

Passing behavior into utilities

fun transformAndPrint(value: String, transformer: () -> ) {
    println(transformer(value))
}

1. Forgetting :: for a named function

This is the main issue in the original question.

Incorrect

foo("a message", buz)

Correct

foo("a message", ::buz)

Use :: when passing a named function as a value.

2. Function signature does not match

If foo expects (String) -> Unit, the function must accept one String and return Unit.

Broken example

fun wrongBuz(m: Int) {
    println(m)
}

foo("a message", ::wrongBuz)

This fails because Int is not String.

3. Returning the wrong type

Broken example

Function call vs function reference

// Function that accepts another function
fun foo(m: String, bar: (String) -> Unit) {
    bar(m)
}

// Named function
fun buz(m: String) {
    println(m)
}

// Pass lambda
foo("hello") { println(it) }

// Pass named function
foo("hello", ::buz)

Rules

• Use a function type like (String) -> Unit to declare a function parameter.
• Use ::functionName to pass a named function.
• The parameter types and return type must match.
• buz("x") calls the function.
• ::buz passes a reference to the function.

Common matching examples

fun printText(s: String) { println(s) }     // matches (String) -> Unit
fun length:  = s.length       
 { }                            

Can I pass a named function as a parameter in Kotlin?

Yes. Use a function reference with ::, such as ::buz.

Why does foo("a message", buz) not work?

Because Kotlin needs a function reference when you want to pass the function itself as a value. Use foo("a message", ::buz).

What does (String) -> Unit mean in Kotlin?

It means a function that takes one String argument and returns Unit.

When should I use a lambda instead of a function reference?

Use a lambda for short one-time logic. Use a function reference when a suitable named function already exists.

Does the function signature need to match exactly?

Yes. The number of parameters, their types, and the return type must be compatible.

What is the difference between buz("x") and ::buz?

buz("x") executes the function immediately. ::buz creates a reference you can pass to another function.

• Higher-order functions — functions that accept or return other functions.
• Lambdas in Kotlin — inline anonymous functions often used as arguments.
• Function types — the syntax Kotlin uses to describe function parameters and returns.
• Trailing lambda syntax — Kotlin's cleaner syntax when the last parameter is a lambda.
• Anonymous functions — an alternative to lambdas with more explicit syntax.
• Collection operations — methods like map, filter, and forEach rely heavily on passing functions.
• Method references — similar to function references, often used with class or object members.