Anonymous Function

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

​

Syntax

val multiply = fun(x: Int, y: Int): Int {
    return x * y
}

val multiply = fun(x: Int, y: Int): Int = x * y

​

Syntactic Differences from Lambdas

• No Trailing Closure Syntax: Unlike lambdas, an anonymous function cannot be passed outside the parentheses of a higher-order function call. It must always be passed as a standard argument inside the parentheses.

val list = listOf(1, 2, 3)

// Valid: Passed inside parentheses
list.filter(fun(x) = x > 0)

// Syntax Error: Cannot be placed outside parentheses
// list.filter fun(x) = x > 0

• No Implicit it Parameter: Anonymous functions do not support the implicit it parameter for single-parameter functions. Even if the compiler can infer the parameter type, the parameter name itself must always be explicitly declared.

// Valid: Explicit parameter name 'item'
list.map(fun(item) = item * 2)

// Syntax Error: 'it' is not implicitly generated for anonymous functions
// list.map(fun() = it * 2)

​

Type Inference Rules

• Parameters: If the anonymous function is passed as an argument to another function, its parameter types can be inferred from the context and may be omitted (though the parameter names must still be declared). If assigned to a variable without an explicit type declaration, parameter types must be specified.
• Return Type: For expression-body anonymous functions, the return type is inferred automatically. For block-body anonymous functions, the return type must be explicitly declared unless it is Unit.

// Parameter type inferred from the context of `filter`, but name 'item' is required
val positiveNumbers = listOf(-1, 2, -3, 4).filter(fun(item) = item > 0)

​

Control Flow and Return Semantics

• Inside a Lambda: A bare return inside a lambda expression returns from the enclosing named function (a non-local return), provided the higher-order function taking the lambda is marked as inline.
• Inside an Anonymous Function: Because an anonymous function is declared using the fun keyword, a bare return statement resolves to the anonymous function itself. It triggers a local return, yielding a value back to the caller of the anonymous function without exiting the outer enclosing function.

fun demonstrateReturnSemantics() {
    val numbers = listOf(1, 2, 3, 4, 5)

    // Using an anonymous function
    numbers.forEach(fun(value) {
        if (value == 3) return  // Local return: exits the anonymous function only
        print(value)            // Output: 1245
    })
    
    println(" - End of function") // This line WILL execute
}

​

Invocation

val greet = fun(name: String): String = "Hello, $name"

// Invocation
val message1 = greet("System")
val message2 = greet.invoke("Admin")