Lattice

// Forge blocks: controlled mutation that crystallizes
fix config = forge {
    flux temp = Map::new()
    temp.set("host", "localhost")
    temp.set("port", "8080")
    temp.set("debug", "true")
    freeze(temp)
}

// config is now permanently immutable
print(config.get("host"))  // "localhost"
print(phase_of(config))    // "crystal"

struct VendingMachine {
    balance: Int,
    inventory: Map,
    insert_coin: Fn,
    select_item: Fn,
    dispense: Fn
}

fn make_vending_machine() -> VendingMachine {
    flux inv = Map::new()
    inv.set("cola", 150)
    inv.set("chips", 100)
    inv.set("candy", 75)

    return VendingMachine {
        balance: 0,
        inventory: inv,
        insert_coin: |self, amount| {
            self.balance + amount
        },
        select_item: |self, item| {
            let price = self.inventory.get(item)
            if self.balance < price {
                "insufficient funds"
            } else {
                "ok:${item}"
            }
        },
        dispense: |self, item| {
            let price = self.inventory.get(item)
            let change = self.balance - price
            "Dispensing ${item}! Change: ${change}"
        }
    }
}

fn fizzbuzz(n: Int) -> String {
    if n % 15 == 0 {
        "FizzBuzz"
    } else {
        if n % 3 == 0 { "Fizz" }
        else {
            if n % 5 == 0 { "Buzz" }
            else { to_string(n) }
        }
    }
}

fn main() {
    for i in 1..21 {
        print("${i}: ${fizzbuzz(i)}")
    }
}

fn main() {
    let data = [5, 3, 8, 1, 9, 2, 7]

    // Chain operations
    let result = data
        .filter(|x| { x > 3 })
        .map(|x| { x * 2 })
        .sort()

    print(result)  // [10, 14, 16, 18]

    // Reduce to a single value
    let sum = data.reduce(|acc, x| { acc + x }, 0)
    print("sum = ${sum}")  // sum = 35
}

fn main() {
    let name = "Lattice"
    let version = 8

    // Variables and expressions
    print("hello ${name}")              // hello Lattice
    print("2 + 2 = ${2 + 2}")            // 2 + 2 = 4
    print("v0.2.${version}")             // v0.2.8

    // Method calls
    print("upper: ${name.to_upper()}")  // upper: LATTICE
    print("len: ${[1,2,3].len()}")     // len: 3

    // Escaped: literal ${
    print("price: \${9.99}")            // price: ${9.99}
}

fn sum_range(start: Int, end: Int) -> Int {
    flux total = 0
    for i in start..end { total = total + i }
    return total
}

fn main() {
    let ch1 = Channel::new()
    let ch2 = Channel::new()

    // Each spawn runs on its own thread
    scope {
        spawn { ch1.send(freeze(sum_range(0, 500000))) }
        spawn { ch2.send(freeze(sum_range(500000, 1000000))) }
    }
    // Both tasks are done here

    let total = ch1.recv() + ch2.recv()
    print("total: ${total}")  // total: 499999500000
}

// Runtime type checking
fn withdraw(account: Map, amount: Int) -> Int
    require amount > 0, "amount must be positive"
    ensure |result| { result >= 0 }, "balance can't go negative"
{
    return account.get("balance") - amount
}

// Optional chaining & nil coalescing
let city = user?.address?.city ?? "Unknown"

// Defer for guaranteed cleanup
fn process(path: String) {
    let fd = open(path)
    defer { close(fd) }  // runs on any exit
    // ...
}

// Result ? operator for error propagation
fn load() -> Map {
    let data = read_config()?  // unwrap ok, or return err
    let parsed = validate(data)?
    return ok(parsed)
}

fn main() {
    // JSON
    let data = json_parse('{"name": "Lattice", "version": 0.1}')
    print(data.get("name"))  // Lattice

    // Regex
    let emails = regex_find_all(
        "[a-z]+@[a-z]+\\.[a-z]+",
        "contact alice@example.com or bob@test.org"
    )
    print(emails)  // ["alice@example.com", "bob@test.org"]

    // String interpolation
    let pi = 3.14159
    print("pi ≈ ${pi}")

    // Path utilities
    let p = path_join("src", "lang", "parser.lat")
    print("path=${p}, dir=${path_dir(p)}, ext=${path_ext(p)}")
}

fn http_get(host: String, path: String) -> String {
    let fd = tcp_connect(host, 80)
    let req = "GET ${path} HTTP/1.0\r\nHost: ${host}\r\n\r\n"
    tcp_write(fd, req)
    let response = tcp_read(fd)
    tcp_close(fd)
    return response
}

fn main() {
    // Plain HTTP
    let html = http_get("example.com", "/")
    print(html)

    // TLS for encrypted connections
    if tls_available() {
        let fd = tls_connect("api.github.com", 443)
        tls_write(fd, "GET / HTTP/1.1\r\nHost: api.github.com\r\nConnection: close\r\n\r\n")
        print(tls_read(fd))
        tls_close(fd)
    }
}

# Compile a Lattice program using the self-hosted compiler
clat compiler/latc.lat program.lat program.latc

# Run the compiled bytecode
clat program.latc

# The self-hosted compiler supports:
#   - Functions, closures, and upvalue capture
#   - Variables with flux/fix/let declarations
#   - Control flow: if/else, while, loop, for..in
#   - String interpolation
#   - Compound assignment operators
#   - .latc bytecode serialization

[package]
name = "my-project"
version = "0.1.0"
entry = "main.lat"

[dependencies]
json-utils = "^0.2.0"
my-lib = { git = "https://github.com/user/my-lib.git", tag = "v1.0.0" }
dev-tools = { git = "https://github.com/user/dev-tools.git", branch = "main" }