Data Types

let small: i32 = 42        # 32-bit signed integer
let large: i64 = 1000000  # 64-bit signed integer
let unsigned: u32 = 100   # 32-bit unsigned integer
let big: u64 = 999999     # 64-bit unsigned integer

let single: f32 = 3.14    # 32-bit float
let double: f64 = 3.14159 # 64-bit float (default)

let active: bool = true
let disabled: bool = false

let name: str = "JOEL"
let greeting = "Hello, World"
let multiline = "Line 1
Line 2"

let numbers: list[i32] = [1, 2, 3, 4, 5]
let names: list[str] = ["Alice", "Bob"]
let mixed = [1, "hello", true]  # Type inferred

let items = [1, 2, 3]
let first = items[0]      # Access: 1
let len = items.length()  # Length: 3

let person: map[str, str] = {
  "name": "JOEL",
  "age": "24"
}

let scores: map[str, i32] = {
  "Alice": 95,
  "Bob": 87
}

let person = {"name": "JOEL", "age": 24}
let name = person["name"]  # Access: "JOEL"
person["city"] = "NYC"     # Add/Update

let value: Option[i32] = Some(10)
let none: Option[i32] = None

# Pattern matching (coming soon)
match value {
  Some(x) => print(x),
  None => print("No value"),
}

fn read_file(path: str) -> Result<Bytes, Error> {
  # Returns Ok(value) or Err(error)
}

let data: Bytes = bytes("Hello")
let raw = bytes([0x48, 0x65, 0x6c, 0x6c, 0x6f])

let x = 10           # Inferred as i32
let y = 3.14         # Inferred as f64
let z = "hello"      # Inferred as str
let flag = true      # Inferred as bool

let x: i32 = 10
let y: f64 = 3.14
let name: str = "JOEL"

let x: i32 = 10
let y: f64 = x as f64  # Cast to float

let num: f64 = 3.14
let int: i32 = num as i32  # Cast to integer

[Compiled]

let x: i32 = 10
let y: str = "hello"
let z = x + y  # Compile error: type mismatch

[Interpreted]

let x = 10
let y = "hello"
let z = x + y  # Runtime error

[Compiled]

sql result: sql<{name: str, age: i32}> = 
  SELECT name, age FROM users

[Compiled]

qubit q0 = |0⟩
qubit q1 = |1⟩
qubit[3] register = [|0⟩, |0⟩, |0⟩]