Syntax Basics
Kite's syntax is designed to be clean, readable, and familiar to developers coming from modern programming languages. This page covers the fundamental building blocks: variables, types, operators, and literals.
Variables
The var Keyword
Variables are declared using the var keyword:
var name = "production"
var count = 42
var enabled = trueExplicit Type Annotations
Types can be explicitly specified:
var string name = "production"
var number count = 42
var boolean enabled = trueType Inference
When the type is omitted, Kite infers it from the initial value. The inferred type is fixed at declaration.
var name = "hello" // Inferred as string
var count = 10 // Inferred as number
var items = [1, 2, 3] // Inferred as number[]Types
Primitive Types
| Type | Description | Example |
|---|---|---|
string | UTF-8 text values with interpolation support | "hello", "Hello, ${name}!" |
number | 64-bit floating-point (integers and decimals) | 42, 3.14, -17, 1.5e10 |
boolean | Logical true/false values | true, false |
null | Explicit absence of a value | null |
any | Disables type checking (use sparingly) | var any x = "hello" |
Array Types
Arrays are declared with [] suffix:
var string[] names = ["alice", "bob"]
var number[] scores = [95, 87, 92]
var boolean[] flags = [true, false, true]Object Types
Objects use key-value syntax:
var config = {
host: "localhost",
port: 8080,
ssl: true
}Union Types
Union types allow multiple possible types:
var string | number id = "abc123"
id = 42 // Also validFunction Types
Function type syntax:
// (param types) -> return type
var (number, number) -> number add = (a, b) -> a + b
// No parameters
var () -> string greet = () -> "Hello"
// No return value
var (string) -> void log = (msg) -> print(msg)Operators
Arithmetic Operators
Kite supports standard arithmetic operations on numeric values. When mixing integers and decimals, integers are automatically promoted to floating-point. Division always returns a floating-point result, while modulo (%) returns the remainder after division.
var sum = 10 + 5 // 15
var diff = 10 - 5 // 5
var product = 10 * 5 // 50
var quotient = 10 / 5 // 2.0 (always float)
var remainder = 10 % 3 // 1Comparison Operators
Comparison operators return boolean values. Equality (==) and inequality (!=) work on all types including strings and booleans. Ordering comparisons (<, >,<=, >=) work on numbers and strings (lexicographic comparison).
a == b // Equal (works on all types)
a != b // Not equal
a < b // Less than
a > b // Greater than
a <= b // Less than or equal
a >= b // Greater than or equal
// String comparison is lexicographic
"apple" < "banana" // true
"abc" == "abc" // trueLogical Operators
Logical operators work with boolean values and use short-circuit evaluation:&& stops evaluating if the left side is false, and || stops if the left side is true. This is useful for conditional execution and providing default values.
a && b // AND: true only if both are true
a || b // OR: true if either is true
!a // NOT: inverts the boolean
// Short-circuit evaluation
enabled && runTask() // runTask() only called if enabled is true
value || "default" // Returns value if truthy, otherwise "default"Assignment Operators
Assignment operators modify variables in place. Compound operators like += combine an operation with assignment. For arrays, += appends elements. The increment (++) and decrement (--) operators modify numeric variables by 1.
x = 10 // Assign
x += 5 // Add and assign (x = x + 5)
x -= 3 // Subtract and assign
x *= 2 // Multiply and assign
x /= 4 // Divide and assign
x++ // Increment by 1
x-- // Decrement by 1
// Array append with +=
var items = ["a", "b"]
items += "c" // items is now ["a", "b", "c"]String Operators
Strings can be concatenated with +. Double-quoted strings support interpolation using ${expression} syntax for complex expressions or $variable for simple variables. Single-quoted strings are literal and do not process interpolation.
var greeting = "Hello" + " " + "World" // Concatenation
// String interpolation (double quotes only)
var name = "Alice"
var message = "Hello, ${name}!" // "Hello, Alice!"
var count = 3
var items = "You have ${count} items" // "You have 3 items"
// Expression interpolation
var total = "Sum: ${10 + 20}" // "Sum: 30"
// Single quotes = no interpolation
var literal = '${name}' // "${name}" (literal text)Member Access
Access object properties with dot notation or bracket notation. Use bracket notation when the key is dynamic or contains special characters. Array elements are accessed by zero-based index.
object.property // Dot notation for known keys
array[0] // Array index (zero-based)
object["key"] // Bracket notation (dynamic keys)
// Examples
var config = { host: "localhost", port: 8080 }
var host = config.host // "localhost"
var port = config["port"] // 8080
var items = ["first", "second", "third"]
var first = items[0] // "first"
var last = items[items.length - 1] // "third"Range Operator
The range operator (..) creates a sequence of integers. The end value is exclusive, meaning 0..5 produces 0, 1, 2, 3, 4 (not including 5). Ranges are commonly used in for loops to iterate a specific number of times.
0..10 // Range from 0 to 9 (end exclusive)
// Common for loop pattern
for i in 0..5 {
print(i) // Prints: 0, 1, 2, 3, 4
}
// Dynamic ranges
var count = 3
for i in 0..count {
print("Item ${i}")
}Literals
String Literals
// Double quotes - with interpolation
var greeting = "Hello, ${name}!"
// Single quotes - literal (no interpolation)
var pattern = '^[a-z]+$'Number Literals
var integer = 42
var negative = -17
var decimal = 3.14159
var scientific = 1.5e10Boolean Literals
var yes = true
var no = falseArray Literals
var empty = []
var numbers = [1, 2, 3, 4, 5]
var mixed = ["hello", 42, true]
var nested = [[1, 2], [3, 4]]Object Literals
var empty = {}
var config = {
name: "server",
port: 8080,
tags: ["web", "api"]
}Null Literal
var nothing = nullNext: Learn about Resources - the core building blocks for infrastructure.