Kairo Control Flow: Branching, Matching, and Bindings

Kairo’s control flow is deliberately small and explicit. You get if/else, match, return, and two local bindings (let and var). Loops are reserved but not executable in v0.1.

Local bindings

let

Immutable local binding. Cannot be reassigned.

var

Mutable local binding. Requires an explicit type.

let name: Text = "Pete"
let active = true

var count: Int32 = 0
count = count + 1

Rules:

let supports type inference when the initializer type is obvious.
Local var requires an explicit type in v0.1.
let bindings cannot be reassigned; immutable members follow the same rule.

`if / else`

if branches on a Bool. There are no truthy or falsy coercions.

if customer.name == "" {
    return 1
} else {
    return 0
}

You can chain with else if:

if total > 100 {
    Pulse.Console.out.writeLine("Large")
} else if total > 0 {
    Pulse.Console.out.writeLine("Small")
} else {
    Pulse.Console.out.writeLine("Empty")
}

if customer will not compile. Kairo forces you to write the check you actually mean, like if customer != null.

`match`

match branches on a pattern. It has two forms: statement and expression.

Statement match

Uses block arms. Good when each arm does side-effecting work.

match status {
    Draft {
        Pulse.Console.out.writeLine("Draft")
    }

    Paid {
        Pulse.Console.out.writeLine("Paid")
    }

    else {
        Pulse.Console.out.writeLine("Other")
    }
}

Expression match

Uses arrow arms and returns a value. Must be exhaustive with an else arm in v0.1.

let label: Text = match status {
    Draft => "Draft"
    Submitted => "Submitted"
    Paid => "Paid"
    else => "Unknown"
}

Supported v0.1 patterns:

Literal values (0, "paid", true)
Enum cases (Draft, Paid)
null
Type names
else

Destructuring patterns and guards are deferred.

`return`

return exits the current callable, optionally with a value.

public func classify(status: OrderStatus): Text {
    return match status {
        Draft => "Not submitted"
        else => "In workflow"
    }
}

Loops (reserved)

for and while are reserved keywords in v0.1. Their executable semantics are deferred until the next ratified stage.

Do not write for or while in code today. Their behavior is not ratified. Use match on enums or recursive helpers for now.

Combining with Result

match on result.isSuccess is the standard pattern for handling Result<T, E>:

let result = createEmail("pete@example.com")

match result.isSuccess {
    true {
        let email = result.value
        Pulse.Console.out.writeLine(email.value)
    }

    false {
        Pulse.Console.error.writeLine("Could not create email")
    }
}

See Error Handling for the full model.

Next steps

Error handling

Result<T, E> and faults.

Operators reference

Boolean, equality, comparison, and arithmetic operators.

Get Started

Language

Packages & Modules

Toolchain

Ecosystem

Kairo Control Flow: Branching, Matching, and Bindings

Local bindings

let

var

`if / else`

`match`

Statement match

Expression match

`return`

Loops (reserved)

Combining with Result

Next steps

Error handling

Operators reference

​Local bindings

let

var

​if / else

​match

​Statement match

​Expression match

​return

​Loops (reserved)

​Combining with Result

​Next steps

Error handling

Operators reference

Local bindings

`if / else`

`match`

Statement match

Expression match

`return`

Loops (reserved)

Combining with Result

Next steps