Function References

fun isEven(n: Int): Boolean = n % 2 == 0

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    val evens = numbers.filter(::isEven)
    println(evens)
}

class Greeter(val greeting: String) {
    fun greet(name: String) = "$greeting, $name!"
}

fun main() {
    val greeter = Greeter("Hi")
    val greetFn: (String) -> String = greeter::greet
    println(greetFn("Kotlin"))
}

data class Person(val name: String) {
    fun shout() = name.toUpperCase()
}

fun main() {
    val shoutFn: (Person) -> String = Person::shout
    println(shoutFn(Person("ana")))
}

data class Point(val x: Int, val y: Int)

fun main() {
    val coordinates = listOf(1 to 2, 3 to 4)
    val points = coordinates.map { (x, y) -> Point(x, y) }
    println(points)
}

1. Forgetting the :: syntax and trying to pass a function's name alone, which Kotlin interprets as trying to call it rather than reference it.
2. Using a function reference where the referenced function's signature doesn't actually match what the receiving parameter expects.
3. Not realizing member function references need either a bound receiver (instance::method) or an unbound one (ClassName::method) depending on how they'll be called.

• ::functionName creates a reference to an existing top-level or member function, which can be passed wherever a matching function type is expected.
• ClassName::method creates an unbound reference, expecting the receiver as the first parameter when called.
• instance::method creates a bound reference tied to that specific instance.
• Function references are useful for passing existing functions directly to higher-order functions instead of wrapping them in a lambda.