Kairo Operators and Control Expressions Reference

Reference for every operator and control expression in Kairo v0.1.

Boolean operators

Operator	Meaning	Operand type	Result
`not <expr>`	Logical NOT	`Bool`	`Bool`
`<left> and <right>`	Logical AND	`Bool`, `Bool`	`Bool`
`<left> or <right>`	Logical OR	`Bool`, `Bool`	`Bool`

Kairo uses words, not symbols, for boolean logic. Both operands must be Bool; there are no truthy/falsy conversions.

if not isValid or hasExpired {
    return false
}

Equality operators

Operator	Meaning	Result
`<left> == <right>`	Equal	`Bool`
`<left> != <right>`	Not equal	`Bool`

Operands must be compatible types. Custom equality rules are not part of the v0.1 executable subset.

if status == Paid {
    return true
}

Comparison operators

Operator	Meaning	Result
`<left> < <right>`	Less than	`Bool`
`<left> <= <right>`	Less than or equal	`Bool`
`<left> > <right>`	Greater than	`Bool`
`<left> >= <right>`	Greater than or equal	`Bool`

Operands must be compatible comparable types. Broad numeric promotion is not performed.

if total > 0 {
    return true
}

Arithmetic operators

Operator	Meaning
`<left> + <right>`	Addition; `Text` concatenation
`<left> - <right>`	Subtraction
`<left> * <right>`	Multiplication
`<left> / <right>`	Division

Operands must be compatible. Kairo does not silently promote across numeric families.

let subtotal: Decimal = 100.00
let tax: Decimal = 10.00
let total: Decimal = subtotal + tax

Assignment

<target> = <expression>

Target must be a var local or var member.
Expression must be assignment-compatible with the target type.
let bindings and immutable members cannot be reassigned outside valid construction.

var count: Int32 = 0
count = count + 1

Member access

<receiver>.<memberName>

Reads a member on a value, object, or receiver.
Chained access is supported: customer.address.city.

Type membership access

<TypeName>.<staticMemberName>

Calls a type func or reads a type-owned member.
Also used for enum cases: OrderStatus.Draft.

Control expressions

`if / else`

Statement form. Condition must be Bool.

if condition {
    // ...
} else if otherCondition {
    // ...
} else {
    // ...
}

`match` (statement)

Block arms; used when each arm performs side effects.

match status {
    Draft {
        // ...
    }
    else {
        // ...
    }
}

`match` (expression)

Arrow arms; returns a value. Must be exhaustive with an else arm in v0.1.

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

Supported v0.1 patterns:

Literal values
Enum cases
null
Type names
else

Destructuring patterns and guards are deferred.

`return`

return <expression>
return

Exits the current callable.

Precedence and grouping

Kairo evaluates expressions with these precedence levels, from highest to lowest:

Member access ., function/method calls (...)
Unary not
*, /
+, -
<, <=, >, >=
==, !=
and
or
Assignment =

Use parentheses to group explicitly when precedence is unclear.

if (subtotal + tax) > threshold and not skipCheck {
    return true
}

Control flow

if, match, and bindings in prose.

Types reference

Built-in types operators work on.

Language Reference

Forge CLI

Pulse Runtime

Kairo Operators and Control Expressions Reference

Boolean operators

Equality operators

Comparison operators

Arithmetic operators

Assignment

Member access

Type membership access

Control expressions

`if / else`

`match` (statement)

`match` (expression)

`return`

Precedence and grouping

Control flow

Types reference

​Boolean operators

​Equality operators

​Comparison operators

​Arithmetic operators

​Assignment

​Member access

​Type membership access

​Control expressions

​if / else

​match (statement)

​match (expression)

​return

​Precedence and grouping

​Related

Control flow

Types reference

Boolean operators

Equality operators

Comparison operators

Arithmetic operators

Assignment

Member access

Type membership access

Control expressions

`if / else`

`match` (statement)

`match` (expression)

`return`

Precedence and grouping

Related