Functions

fun functionName(parameters) returnType {
    // body
    return value
}

// Simple function
fun greet() string {
    return "Hello, World!"
}

// Function with parameters
fun add(number x, number y) number {
    return x + y
}

// Function with no return value
fun logMessage(string message) {
    print(message)
}

fun multiply(number a, number b) number {
    return a * b
}

fun formatName(string first, string last) string {
    return "${first} ${last}"
}

fun createUser(string name, number age, boolean active) object {
    return {
        name: name,
        age: age,
        active: active
    }
}

fun sum(number[] numbers) number {
    var total = 0
    for n in numbers {
        total += n
    }
    return total
}

fun first(string[] items) string {
    return items[0]
}

fun getPort() number {
    return 8080
}

fun getName() string {
    return "default"
}

fun isEnabled() boolean {
    return true
}

fun getConfig() object {
    return {
        host: "localhost",
        port: 8080
    }
}

fun getPorts() number[] {
    return [80, 443, 8080]
}

fun outer(number x, number y) (number) -> number {
    fun inner(number p) number {
        return p + x + y
    }
    return inner
}

var adder  = outer(10, 20)
var result = adder(5)  // 35

// Simple call
var message = greet()

// With arguments
var total   = add(5, 3)

// Chained calls
var doubled = multiply(add(2, 3), 2)  // 10

// With variables
var x       = 10
var y       = 20
var sum     = add(x, y)

(parameters) -> expression
(parameters) -> { statements }

// Simple lambda
var double    = (x) -> x * 2

// With type annotations
var add       = (number a, number b) -> a + b

// Block body
var process   = (string input) -> {
    var upper = toUpperCase(input)
    return upper
}

// Assign to variable
var square  = (x) -> x * x
var result  = square(5)  // 25

// Pass to higher-order function
var numbers = [1, 2, 3, 4, 5]
var doubled = map(numbers, (n) -> n * 2)
// Result: [2, 4, 6, 8, 10]

// Filter with lambda
var evens   = filter(numbers, (n) -> n % 2 == 0)
// Result: [2, 4]

// Define function types
type MathOp         = (number, number) -> number
type Predicate      = (string) -> boolean
type Transformer    = (object) -> object

// Use in declarations
var MathOp add      = (a, b) -> a + b
var MathOp multiply = (a, b) -> a * b

// Function that takes a function
fun applyTwice((number) -> number f, number x) number {
    return f(f(x))
}

var result = applyTwice((n) -> n * 2, 5)  // 20

// Function that returns a function
fun makeMultiplier(number factor) (number) -> number {
    return (x) -> x * factor
}

var triple = makeMultiplier(3)
var result = triple(10)  // 30

component Server {
    input string name
    var string normalizedName

    init() {
        normalizedName = toLowerCase(name)
    }

    resource EC2.Instance server {
        name           = normalizedName
    }
}

init(string prefix, number count) {
    // initialization code
}

@description("Calculate the area of a rectangle")
fun area(number width, number height) number {
    return width * height
}

fun factorial(number n) number {
    if n <= 1 {
        return 1
    }
    return n * factorial(n - 1)
}

var result = factorial(5)  // 120

fun makeCounter() () -> number {
    var count = 0
    return () -> {
        count++
        return count
    }
}

var counter   = makeCounter()
counter()  // 1
counter()  // 2
counter()  // 3