Examples

let name = "Zolo"
let version = 1
print("Hello, {name} v{version}!")
print("The modern language with a VM written in Rust")

// let: immutable, const: constant, mut: mutable
let name: str = "Zolo"
const PI: float = 3.14159
let mut counter = 0

counter = counter + 1
counter = counter + 1

print("Name: {name}")
print("PI: {PI}")
print("Counter: {counter}")

// Optional types
let maybe: str? = nil
…

// The pipe |> passes the result as the first argument
fn double(x: int) -> int { x * 2 }
fn add_ten(x: int) -> int { x + 10 }
fn square(x: int) -> int { x * x }

let result = 5
    |> double()
    |> add_ten()
    |> square()

print(result) // ((5*2)+10)^2 = 400

// With strings — '|> .method()' calls 'method' on the left-hand value,
// equivalent to 'expr.method()'. Works with strings and arrays.
…

fn classify(n: int) -> str {
    match n {
        0       => "zero",
        1..=9   => "single digit",
        10..=99 => "double digit",
        _       => "large",
    }
}

fn day_name(d: int) -> str {
    match d {
        1 => "Monday",
        2 => "Tuesday",
        3 => "Wednesday",
…

// Lazy iterators — only compute what is needed

// Even squares of the first 5 numbers
let result = 0..
    |> Iter.map(|x| x * x)
    |> Iter.filter(|x| x % 2 == 0)
    |> Iter.take(5)
    |> Iter.collect()

print(result)

// Fibonacci via Iter.from_fn
fn fib_iter() {
    let mut a = 0
…

struct Point {
    x: float,
    y: float,
}

impl Point {
    fn new(x: float, y: float) -> Point {
        return Point { x, y }
    }

    fn distance(self, other: Point) -> float {
        let dx = self.x - other.x
        let dy = self.y - other.y
        return (dx * dx + dy * dy) ** 0.5
…

enum Shape {
    Circle(float),
    Rect(float, float),
    Triangle(float, float, float),
}

fn area(shape: Shape) -> float {
    match shape {
        Shape.Circle(r)        => 3.14159 * r * r,
        Shape.Rect(w, h)       => w * h,
        Shape.Triangle(a, b, c) => {
            let s = (a + b + c) / 2.0
            return (s * (s-a) * (s-b) * (s-c)) ** 0.5
        },
…

struct Address {
    street: str,
    city: str?,
}

struct User {
    name: str,
    address: Address?,
}

let user = User {
    name: "Alice",
    address: Address {
        street: "Main Street",
…

// @memoize: automatic result caching
@memoize
fn fibonacci(n: int) -> int {
    if n <= 1 { return n }
    return fibonacci(n - 1) + fibonacci(n - 2)
}

// @test: inline tests
@test
fn test_fibonacci() {
    assert_eq(fibonacci(0), 0)
    assert_eq(fibonacci(1), 1)
    assert_eq(fibonacci(10), 55)
    assert_eq(fibonacci(20), 6765)
…

// Closures capture variables from the outer scope
fn make_counter(start: int) {
    let mut count = start
    return || {
        count = count + 1
        return count
    }
}

let counter = make_counter(0)
print(counter()) // 1
print(counter()) // 2
print(counter()) // 3

…

let nums = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]

// Basic operations
print("Length: {Array.len(nums)}")
print("First: {nums[0]}")
print("Last: {nums[Array.len(nums) - 1]}")

// Functional
let evens = nums |> Array.filter(|x| x % 2 == 0)
let doubled = nums |> Array.map(|x| x * 2)
let sum = nums |> Array.reduce(|acc, x| acc + x, 0)

// {:?} = debug format — prints arrays as [1, 2, 3]
print("Evens: {evens:?}")
…

// Generators with fn* and yield
fn* range(start: int, end: int, step: int) {
    let mut i = start
    while i < end {
        yield i
        i = i + step
    }
}

fn* fibonacci() {
    let mut a = 0
    let mut b = 1
    loop {
        yield a
…

// for with exclusive and inclusive ranges
print("Range 0..5:")
for i in 0..5 {
    print(i)
}

print("Range 1..=3:")
for i in 1..=3 {
    print(i)
}

// for over array
let fruits = ["apple", "banana", "cherry"]
for fruit in fruits {
…

fn divide(a: int, b: int) -> Result<int, str> {
    if b == 0 {
        return Result.Err("division by zero")
    }
    return Result.Ok(a / b)
}

// Checking and extracting
let r1 = divide(10, 2)
let r2 = divide(5, 0)

print(r1.is_ok())   // true
print(r2.is_err())  // true

…

trait Displayable {
    fn display(self) -> str

    // Default implementation
    fn debug(self) -> str {
        return "[debug] {self.display()}"
    }
}

struct Circle {
    radius: float,
}

struct Rect {
…

// Tuples — destructuring directly in let
fn min_max(nums: [int]) -> (int, int) {
    let mut lo = nums[0]
    let mut hi = nums[0]
    for n in nums {
        if n < lo { lo = n }
        if n > hi { hi = n }
    }
    return (lo, hi)
}

let (min, max) = min_max([3, 1, 4, 1, 5, 9, 2, 6])
print("Min: {min}, Max: {max}")

…

// Map literal uses #{...} to distinguish from blocks
let scores: {str: int} = #{
    "Alice": 95,
    "Bob":   87,
    "Carol": 92,
}

// Access by key or by field
print("Alice: {scores["Alice"]}")
print("Bob: {scores.Bob}")

// Iterate with (key, value) — destructuring directly in for
for name, score in scores {
    let grade = if score >= 90 { "A" } else if score >= 80 { "B" } else { "C" }
…

// String methods
let s = "  Hello, World!  "
print(s.trim())
print(s.trim().upper())
print(s.trim().lower())
print(s.trim().len())

// Search and check
let text = "Zolo is fast and safe"
print(text.contains("fast"))
print(text.starts_with("Zolo"))
print(text.ends_with("safe"))

// Transformation
…

// Basic interpolation
let name = "Zolo"
let version = 1
print("Language: {name} v{version}")

// Expressions inside {}
let price = 9.99
let qty = 3
print("Total: $ {price * qty:.2f}")

// Floats
let pi = 3.14159265
print("Pi: {pi:.4f}")
print("Pi (2 places): {pi:.2f}")
…

// Guards with if in match arms
fn classify(n: int) -> str {
    match n {
        n if n < 0   => "negative",
        0            => "zero",
        n if n % 2 == 0 && n < 100 => "small even",
        n if n % 2 != 0 && n < 100 => "small odd",
        n if n >= 100 => "large ({n})",
        _            => "unknown",
    }
}

for n in [-5, 0, 4, 7, 42, 99, 200] {
    print("{n} => {classify(n)}")
…

// dbg(): helper that prints the array in debug format and returns nil
fn dbg(x: [int]) { print("{x:?}") }

// Tap operator &. — side effect without breaking the chain
let result = [5, 2, 8, 1, 9, 3]
    &. dbg()                            // prints the original array
    |> Array.filter(|x| x > 3)
    &. dbg()                            // prints after filtering
    |> Array.map(|x| x * x)
    &. dbg()                            // prints after mapping
    |> Array.sort()

print("Final: {result:?}")

…

// if returns a value — can be used in any expression
let score = 85

let grade = if score >= 90 { "A" }
            else if score >= 80 { "B" }
            else if score >= 70 { "C" }
            else { "F" }

print("Grade: {grade}")

// Inline in interpolation
let temp = 38.5
print("Temperature {temp}°C: {if temp > 37.5 { "fever" } else { "normal" }}")

…

// Functions that take and return functions
fn compose(f: fn(int) -> int, g: fn(int) -> int) -> fn(int) -> int {
    return |x| f(g(x))
}

fn memoize(f: fn(int) -> int) -> fn(int) -> int {
    let cache: {int: int} = {}
    return |n| {
        if let hit = cache[n] { return hit }
        let result = f(n)
        cache[n] = result
        return result
    }
}
…

use std::http
use std::html::{
    document, head, meta, title, body, main, nav, section, div,
    span, h1, h2, p, a, code, View,
}

fn shell(page_title: str, content: View) -> View {
    <document lang="en">
        <head>
            <meta charset="utf-8"/>
            <meta name="viewport" content="width=device-width, initial-scale=1"/>
            <title>{page_title}</title>
            <style global>
              * { box-sizing: border-box; }
…

use std::http
use std::html::{
    document, head, meta, title, body, main, section, div, span,
    h1, h2, p, button, strong, style, client_script, View,
}

@island
fn Counter(label: str, start: int = 0, step: int = 1) -> View {
    var<signal> count = start
    let<signal> direction = if count > start {
        "above the initial value"
    } else if count < start {
        "below the initial value"
    } else {
…

use std::http
use std::html::{
    document, head, meta, title, body, main, div, h1, p, span,
    label, input, button, client_script, View,
}

@island
fn ProfileForm() -> View {
    var<signal> name = ""
    var<signal> saved = false
    let<signal> greeting = if name == "" {
        "Start typing to create your profile."
    } else {
        "Hello, {name}!"
…

use std::http
use std::html::{
    document, head, meta, title, body, main, div, h1, h2, p,
    label, input, strong, client_script, View,
}

@island
fn Cart() -> View {
    var<signal> price = 30
    var<signal> quantity = 2
    var<signal> coupon = ""

    let<signal> subtotal = price * quantity
    let<signal> discount = if coupon == "ZOLO" { subtotal / 10 } else { 0 }
…

use std::http
use std::html::{
    document, head, meta, title, body, main, div, h1, h2, p,
    span, label, input, button, client_script, View,
}

@island
fn EventLab() -> View {
    var<signal> name = ""
    var<signal> enabled = false
    var<signal> points = 0

    <div class="event-lab" data-testid="event-lab" aria-label="DOM event laboratory">
        <h2>Bindings</h2>
…

use std::http
use std::html::{
    document, head, meta, title, body, main, div, h1, p, span,
    label, input, button, client_script, View,
}

@action
fn greet(name: str) -> str {
    "Hello, {name}. This came back from the Zolo server."
}

@island
fn Greeting() -> View {
    var<signal> name = ""
…

use std::http
use std::html::{
    document, head, meta, title, body, main, section, div, h1, h2, p,
    button, style, client_script, View,
}

@island
fn ThemeCard() -> View {
    var<signal> accent = "rgb(139 92 246)"

    <section class="theme-card">
        <div class="swatch"></div>
        <h2>Component-scoped theme</h2>
        <p>The CSS variable bridge follows the signal without replacing the component.</p>
…

// Canvas plugin — 2D software rasterizer (96x64 pixels)
use plugin canvas::{Canvas}

let c = Canvas.new(96, 64)

// Dark background
c.fill(16, 18, 32, 255)

// Filled rectangle — teal panel
c.fill_rect(4, 4, 88, 20, 20, 80, 100, 255)

// Title text
c.draw_text_5x7(8, 9, "ZOLO CANVAS", 0, 220, 180, 255)

…

use std::database::Database

// A real SQLite database, isolated inside this Playground run.
let db = Database.open("sqlite://:memory:").unwrap()
defer db.close()

db.execute("""
  CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    price REAL NOT NULL,
    stock INTEGER NOT NULL
  )
""").unwrap()
…

// Algebraic effects: declare an operation, 'perform' it,
// and let the caller decide what it means in a handler.
effect Ask {
    fn ask(question: str) -> str
}

// 'with Ask' marks this function as performing the effect.
fn survey() with Ask -> str {
    let name = perform Ask::ask("What is your name?")
    let color = perform Ask::ask("What is your favourite colour?")
    return "{name} likes {color}"
}

// The handler interprets each operation. resume(v) sends v
…

// @flags: each variant gets a power-of-two bit; a value of
// the type is a bitmask holding zero or more flags at once.
@flags
enum Perm: u8 { Read, Write, Exec }   // Read=1, Write=2, Exec=4

// Combine flags with |
let rw = Perm::Read | Perm::Write
print(rw.to_int())                // 3
print(rw.name())                  // Read | Write

// Test membership
print(rw.contains(Perm::Read))    // true
print(rw.contains(Perm::Exec))    // false

…

// 'using' embeds a struct and promotes its fields into the
// outer struct's dot-access — composition, not inheritance.
struct Entity {
    x: int,
    y: int,
}

struct Player {
    using base: Entity,
    hp: int,
}

fn status(p: Player) {
    // Promoted access — p.x desugars to p.base.x
…

// Enums can pin numeric values on a backing type — handy
// for protocols and FFI. Unpinned variants auto-increment.
enum Packet: u8 {
    Connect = 0,
    Data    = 1,
    Ping    = 9,
    Pong,          // auto-increments to 10
    Bye     = 255,
}

print(Packet::Data.to_int())   // 1
print(Packet::Pong.to_int())   // 10
print(Packet::Bye.name())      // Bye

…

// Declarative state machines: states, an initial state,
// and 'on' transitions — cleaner than ad-hoc enums + match.
machine TrafficLight {
    state Red, Yellow, Green
    initial Red
    Red -> Green on go
    Green -> Yellow on caution
    Yellow -> Red on stop
}

let light = TrafficLight.new()
print(light.state)          // Red

// send() advances and reports whether the event applied
…

// comptime blocks run inside the compiler; the tail expression
// is baked into the program as a literal. Zero runtime cost.
let answer = comptime {
    let a = 6
    let b = 7
    a * b
}
print(answer)   // 42 — the binary ships the literal, not the math

// Loops work too — precompute a lookup table at build time.
let squares = comptime {
    var out = []
    for n in 1..=6 {
        out = out.push(n * n)
…

// Bitwise operators work on plain ints.
let a = 0b1100
let b = 0b1010
print("a & b    = {a & b}")      // 8
print("a | b    = {a | b}")      // 14
print("a ^ b    = {a ^ b}")      // 6
print("~a       = {~a}")         // -13
print("1 << 4   = {1 << 4}")     // 16
print("256 >> 3 = {256 >> 3}")   // 32

// Duration literals: a unit suffix on the number.
// Internally they are just i64 milliseconds.
let limit = 5s
let tick = 100ms
…

struct User {
    name: str,
    age: int,
    email: str,
}

let u = User { name: "Alice", age: 30, email: "[email protected]" }

// '..rest' collects the fields the pattern did not extract
// into an anonymous record.
fn split(user: User) {
    let User { name, ..rest } = user
    print("name={name}")
    print("rest: age={rest.age} email={rest.email}")
…