Function Types

fun main() {
    val multiply: (Int, Int) -> Int = { a, b -> a * b }
    println("Product: ${multiply(6, 7)}")
}

fun applyOperation(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

fun main() {
    val result = applyOperation(4, 5) { x, y -> x + y }
    println("Result: $result")
}

fun runTask(task: () -> Unit) {
    println("Starting task...")
    task()
    println("Task finished")
}

fun main() {
    runTask { println("Doing work") }
}

fun main() {
    val operations = mapOf<String, (Int, Int) -> Int>(
        "add" to { a, b -> a + b },
        "subtract" to { a, b -> a - b }
    )
    println("5 + 3 = ${operations["add"]!!(5, 3)}")
    println("5 - 3 = ${operations["subtract"]!!(5, 3)}")
}

1. Forgetting the parentheses around the parameter types in a function type, writing Int -> Int instead of (Int) -> Int.
2. Confusing a nullable function type (() -> Unit)? with a function returning a nullable type () -> Unit?; the parentheses placement matters.
3. Trying to pass a plain value where a function type is expected, instead of a lambda or function reference.

• A function type is written as (ParamTypes) -> ReturnType, such as (Int, Int) -> Int.
• Variables, parameters, and properties can all be declared with a function type and hold a lambda or function reference.
• () -> Unit describes a function that takes no parameters and returns nothing meaningful.
• Function types make it possible to pass behavior itself as data, which is central to higher-order functions.