Functions

Functions are reusable blocks of code that can accept parameters and return values.

Function Declaration

Basic Syntax

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

Examples

// 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)
}

Parameters

Typed Parameters

fun multiply(number a, number b) number {
    return a * b
}
fun formatName(string first, string last) string {
    return "${first} ${last}"
}

Multiple Parameters

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

Array Parameters

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

Return Types

Explicit Return Type

fun getPort() number {
    return 8080
}
fun getName() string {
    return "default"
}
fun isEnabled() boolean {
    return true
}

Complex Return Types

fun getConfig() object {
    return {
        host: "localhost",
        port: 8080
    }
}
fun getPorts() number[] {
    return [80, 443, 8080]
}

Function Return Types

Functions can return other functions:

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

Function Calls

// 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)

Lambda Expressions

Basic Syntax

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

Examples

// 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
}

Using Lambdas

// 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]

Type Aliases for Functions

// 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

Higher-Order Functions

Functions that take or return other functions:

// 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

Init Blocks

Init blocks run initialization code within components:

component Server {
    input string name
    var string normalizedName
    init() {
        normalizedName = toLowerCase(name)
    }
    resource EC2.Instance server {
        name           = normalizedName
    }
}

Init with Parameters

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

Function Decorators

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

Recursion

Functions can call themselves:

fun factorial(number n) number {
    if n  <= 1 {
        return 1
    }
    return n * factorial(n - 1)
}
var result = factorial(5)  // 120

Closures

Inner functions capture variables from outer scope:

fun makeCounter() () -> number {
    var count = 0
    return () -> {
        count++
        return count
    }
}
var counter   = makeCounter()
counter()  // 1
counter()  // 2
counter()  // 3

Next: Learn about Control Flow - if/else, loops, and comprehensions.