Lust

https://lust-lang.dev/docs
Admin
Lust is a Lua-inspired, statically-typed language that provides Rust-grade guarantees, offering a...
Tokens:38,307
Snippets:402
Trust Score:2.2
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Lust CLI and language server with Cargo

Source: https://lust-lang.dev/docs/quick-start.html

Install the Lust CLI and language server using Cargo. Requires Rust and Cargo to be installed.

```bash
cargo install lust-rs
cargo install lust-analyzer

```

--------------------------------

### lust-config.toml configuration example

Source: https://lust-lang.dev/docs/tooling.html

Example `lust-config.toml` configuring compiler flags, standard library modules, and dependencies. Shows optional stdlib modules, JIT toggle, memory optimization options, and dependency kinds (rust, lua, registry).

```toml
[settings]
# List of optional standard library modules to enable
stdlib_modules = ["io", "os"]

# Enable or disable trace-based JIT compilation (default: true)
jit = true

# Memory optimization options for embedded environments (e.g. ESP32, no_std)
low_memory_mode = false
minimal_runtime_types = false

[dependencies]
# Native Rust extension crate
lust-double = { path = "extensions/double", kind = "rust" }

# Lua 5.1 C dynamic library
socket = { path = "/usr/local/lib/lua/5.1/socket/core.so", kind = "lua" }

# Registry Lust package
json = { version = "1.0.0" }
```

--------------------------------

### Lust structs, impl blocks, enums with pattern matching

Source: https://lust-lang.dev/docs/language-tour/overview.html

Shows a complete Lust example with a Point struct, impl methods, an enum with payloads, a pattern-matching function using the `is` operator, and output. The example prints "Point: (15, 15)" and "Working on: compiler".

```lust
struct Point
    x: int
    y: int
end

impl Point
    function new(x: int, y: int): Point
        return Point { x = x, y = y }
    end

    function translate(self, dx: int, dy: int): Point
        return Point { x = self.x + dx, y = self.y + dy }
    end
end

enum Status
    Pending,
    Active(string),
    Finished(int)
end

function report(status: Status): string
    if status is Pending then
        return "Waiting..."
    elseif status is Active(task_name) then
        return "Working on: " .. task_name
    elseif status is Finished(code) then
        return "Done with exit code: " .. tostring(code)
    end
    return "Unknown"
end

local pt = Point.new(10, 20)
local moved = pt:translate(5, -5)
println("Point: (" .. tostring(moved.x) .. ", " .. tostring(moved.y) .. ")")

local current = Status.Active("compiler")
println(report(current))
```

```text
Point: (15, 15)
Working on: compiler
```

--------------------------------

### Install lust-analyzer with cargo

Source: https://lust-lang.dev/docs/tooling.html

Installs the official Lust language server, which implements LSP features like diagnostics, autocompletion, hover info, and jump to definition.

```bash
cargo install lust-analyzer
```

--------------------------------

### Check Lust CLI version

Source: https://lust-lang.dev/docs/quick-start.html

Verify that the Lust CLI is installed and available in your PATH.

```bash
lust --version

```

--------------------------------

### Use numeric for loop with range and step

Source: https://lust-lang.dev/docs/print.html

Demonstrates numeric `for` loops iterating over a range `start, stop[, step]`. Two examples show counting from 1 to 5 and stepping by 2.

```lust
-- Count from 1 to 5 inclusive
for i = 1, 5 do
    println(i)
end

-- Count by steps of 2 (0, 2, 4, 6, 8, 10)
for i = 0, 10, 2 do
    println(i)
end
```

--------------------------------

### Create a task with task.create

Source: https://lust-lang.dev/docs/language-tour/tasks.html

Creates a task that yields three values and returns a final result. The task does not start until task.resume is called.

```lust
local ticker: Task = task.create(function(): string
    for step = 1, 3 do
        task.yield("tick " .. tostring(step))
    end
    return "done"
end)
```

--------------------------------

### Lust project configuration (lust-config.toml)

Source: https://lust-lang.dev/docs/quick-start.html

Example `lust-config.toml` that enables the `io` and `os` standard library modules and enables the JIT. The CLI automatically searches the current directory for this file when running `lust script.lust`.

```toml
[settings]
stdlib_modules = ["io", "os"]
jit = true

```

--------------------------------

### Array querying and mutation functions in Lust

Source: https://lust-lang.dev/docs/language-tour/collections.html

Example showcasing array.len, array.push, array.pop, and array.slice with observable lengths and popped value. Shows in-place operations returning as in signatures and code verification through logs.

```lust
local items: Array<int> = [1, 2, 3]

array.push(items, 4)
println("Length: " .. array.len(items)) -- 4

local popped = array.pop(items)
if popped is Some(val) then
    println("Popped: " .. val)          -- 4
end

local sub = array.slice(items, 0, 2)    -- Elements at 0 and 1: [1, 2]
println("Slice length: " .. array.len(sub)) -- 2
```

--------------------------------

### Use short-circuiting for ternary-like expressions

Source: https://lust-lang.dev/docs/print.html

Demonstrates using `and`/`or` short-circuiting to create a ternary-like expression. The example assigns `category` based on age.

```lust
local age = 20
local category = age >= 18 and "adult" or "minor"
println("Category: " .. category) -- Outputs: Category: adult
```

--------------------------------

### Using math module constants and functions

Source: https://lust-lang.dev/docs/language-tour/collections.html

Shows the math module's constants and functions: math.pi, math.abs, math.floor, math.ceil, math.round, and math.clamp. The example computes the area of a circle and applies rounding/truncation functions to a negative float, printing each result.

```lust
local radius: float = 5.0
local area: float = math.pi * radius * radius
println("Area: " .. area)

local val: float = -4.75
println("abs: " .. math.abs(val))       -- 4.75
println("floor: " .. math.floor(val))   -- -5
println("ceil: " .. math.ceil(val))     -- -4
println("round: " .. math.round(val))   -- -5
println("clamp: " .. math.clamp(12, 0, 10)) -- 10
```

--------------------------------

### Iterate collections with for-in

Source: https://lust-lang.dev/docs/print.html

Shows `for-in` loops for traversing arrays and maps. The map example uses `map.iter()` to get key-value pairs.

```lust
-- Iterating over an Array
local fruits: Array<string> = ["apple", "banana", "cherry"]
for fruit in fruits do
    println("Fruit: " .. fruit)
end

-- Iterating over a Map with map.iter()
local inventory: Map<string, int> = { apple = 10, banana = 25 }
for item, count in map.iter(inventory) do
    println(item .. ": " .. count)
end
```

--------------------------------

### Compile C program linking against liblust

Source: https://lust-lang.dev/docs/embedding.html

Compile a C program that uses the Lust FFI, linking against the liblust library. Adjust the include and library paths to match your Lust installation.

```shell
cc main.c -I/path/to/include -L/path/to/target/release -llust -o ffi_example
```

--------------------------------

### Use logical operators and, or, not

Source: https://lust-lang.dev/docs/print.html

Shows Lust's Lua-style logical operators `and`, `or`, and `not`. The example checks if a keyholder is not an admin.

```lust
local has_key = true
local is_admin = false

if has_key and not is_admin then
    println("Standard keyholder")
end
```

--------------------------------

### Define a function with typed parameters and return type

Source: https://lust-lang.dev/docs/print.html

Shows the basic syntax for defining a function in Lust using the `function` keyword, ending with `end`. Parameters and return types are annotated with `:`. The example defines `add` and calls it, printing the result.

```lust
function add(a: int, b: int): int
    return a + b
end

local result = add(15, 27)
println("Result: " .. result) -- Outputs: Result: 42
```

--------------------------------

### Define a function with no return type

Source: https://lust-lang.dev/docs/print.html

Shows that a function returning nothing can omit the return type or use `()`. The example defines `greet` and calls it.

```lust
function greet(name: string)
    println("Hello, " .. name .. "!")
end

greet("World")
```

--------------------------------

### Output of the cooperative scheduler

Source: https://lust-lang.dev/docs/language-tour/tasks.html

Expected output from the cooperative scheduler example, showing interleaved yields and final results.

```text
Yielded: Worker-A step 1
Yielded: Worker-B step 1
Yielded: Worker-A step 2
Yielded: Worker-B step 2
Yielded: Worker-B step 3
Done: Worker-A finished
Done: Worker-B finished
```

--------------------------------

### Use ref fields for weak back-references

Source: https://lust-lang.dev/docs/language-tour/structs.html

Shows how to assign to a ref field (child.parent = self) and read it back as an Option<T>. The example creates a parent-child relationship and inspects the weak parent link, outputting 'Leaf's parent is: root'.

```lust
impl Node
    function new(name: string): Node
        return Node {
            name = name,
            parent = Option.None,
            children = []
        }
    end

    function add_child(self, child: Node)
        child.parent = self -- Set weak back-reference
        array.push(self.children, child)
    end
end

local root = Node.new("root")
local leaf = Node.new("leaf")
root:add_child(leaf)

-- Inspect weak parent link
local parent_opt = leaf.parent
if parent_opt is Some(p) then
    println("Leaf's parent is: " .. p.name) -- Outputs: Leaf's parent is: root
else
    println("Leaf has no parent")
end
```

--------------------------------

### Store dynamic data as `unknown`

Source: https://lust-lang.dev/docs/language-tour/type-system.html

When interfacing with dynamic data, use the `unknown` type. This example shows storing values of different types in a map with `unknown` values.

```lust
local config: Map<string, unknown> = {}
map.set(config, "port", 8080)
map.set(config, "hostname", "localhost")
map.set(config, "debug", true)
```

--------------------------------

### Map operations: set, get, has

Source: https://lust-lang.dev/docs/language-tour/collections.html

Demonstrates basic map operations: creating an empty map, inserting entries with `map.set`, retrieving with `map.get` (returns an `Option`), and checking existence with `map.has`. The `if ... is Some(city)` pattern extracts the value safely. The final line prints `false` because "Germany" was never added.

```lust
local capitals: Map<string, string> = {}
map.set(capitals, "France", "Paris")
map.set(capitals, "Japan", "Tokyo")

local japan_cap = map.get(capitals, "Japan")
if japan_cap is Some(city) then
    println("Capital of Japan: " .. city)
end

println("Has Germany: " .. tostring(map.has(capitals, "Germany"))) -- false
```

--------------------------------

### Attach instance methods with impl and self

Source: https://lust-lang.dev/docs/language-tour/structs.html

Defines instance methods (translate and distance_squared) inside an impl block. Methods that operate on an instance must declare self as their first parameter and are called with colon syntax (instance:method(...)). The example shows expected outputs of 5 and 25.

```lust
impl Point
    function translate(self, dx: int, dy: int): Point
        return Point { x = self.x + dx, y = self.y + dy }
    end

    function distance_squared(self): int
        return (self.x * self.x) + (self.y * self.y)
    end
end

local p1 = Point { x = 3, y = 4 }
local p2 = p1:translate(2, 6)

println("p2.x: " .. p2.x) -- 5
println("distance^2: " .. p1:distance_squared()) -- 25
```

--------------------------------

### Generic struct and impl block in Lust

Source: https://lust-lang.dev/docs/language-tour/generics-and-traits.html

Demonstrates parameterizing a struct (Box<Item>) and implementing generic methods get and set. The impl block uses universal impl syntaxs; specialized and conditional impls are not supported.

```lust
struct Box<Item>
    value: Item
end

impl<Item> Box<Item>
    function get(self): Item
        return self.value
    end

    function set(self, new_val: Item)
        self.value = new_val
    end
end

local int_box: Box<int> = Box { value = 100 }
println("Box contains: " .. int_box:get()) -- 100

```

--------------------------------

### Use array.get to get Option<T> from array index

Source: https://lust-lang.dev/docs/print.html

Shows array.get(arr, index) returning Option<T> instead of Result<T, IndexError>. Pattern matches with Some to print the found item when the element exists.

```lust
__
local maybe_item = array.get(values, 1) -- Option<string>
if maybe_item is Some(item) then
    println("Found: " .. item)
end

```

--------------------------------

### Chain patterns with `and` for linear scoping

Source: https://lust-lang.dev/docs/language-tour/type-system.html

Conditions chained with `and` evaluate left to right, and variables bound by earlier patterns are visible to later expressions. The example chains checks on a fetch result, user age, and age threshold.

```lust
-- If the first check succeeds, 'user' is in scope for the second check:
if fetch_result is Ok(user) and user.age is Some(age) and age >= 21 then
    println("Verified adult: " .. user.name .. " (age " .. age .. ")")
end
```

--------------------------------

### Unwrap array index when index is guaranteed valid

Source: https://lust-lang.dev/docs/print.html

Calls :unwrap() on the Result from bracket indexing to get the element directly, panicking if the index is out of bounds. Use only when certain the index is valid.

```lust
__
local guaranteed = values[0]:unwrap()

```

--------------------------------

### Safely cast with `as` returning Option

Source: https://lust-lang.dev/docs/language-tour/type-system.html

Use `as` to safely downcast from `unknown` to a concrete type. It returns `Option<Type>`: `Some` on success, `None` on failure, so it never crashes at runtime. The example shows casting a raw port value and handling both outcomes.

```lust
local raw_port = map.get(config, "port"):unwrap()

local maybe_int = raw_port as int -- Returns Option<int>
if maybe_int is Some(port) then
    println("Server listening on port: " .. port)
end

-- Attempting an invalid cast safely returns None
local maybe_str = raw_port as string -- Returns Option.None
if maybe_str is None then
    println("Port is not a string!")
end
```

--------------------------------

### Perform filesystem operations with os module

Source: https://lust-lang.dev/docs/language-tour/io-and-os.html

Shows how to create directories, write files, rename files, and clean up resources using the os module.

```lust
local start = os.time()

-- Create a scratch directory and file
local dir = "scratch_tmp"
os.create_dir(dir)
local file = dir .. "/data.txt"
io.write_file(file, "temporary records\n")

-- Rename the file
local renamed = dir .. "/data_archived.txt"
os.rename(file, renamed)

-- Clean up
os.remove_file(renamed)
os.remove_dir(dir)

local elapsed = os.time() - start
println("Completed filesystem tasks in " .. tostring(elapsed) .. " seconds")
```

--------------------------------

### Run Lust script with lust CLI

Source: https://lust-lang.dev/docs/quick-start.html

Run the Lust script `hello.lust` with the `lust` CLI.

```bash
lust hello.lust

```

--------------------------------

### Create hello.lust script

Source: https://lust-lang.dev/docs/print.html

Create a new Lust script named hello.lust that prints a greeting and uses typed variables.

```lust
-- hello.lust
println("Hello from Lust!")

local greeting: string = "Welcome to typed scripting"
local year: int = 2026

println(greeting .. " in " .. tostring(year) .. "!")
```

--------------------------------

### Create and mutate struct instances

Source: https://lust-lang.dev/docs/language-tour/structs.html

Shows struct literal syntax (TypeName { field = value, ... }) to create an instance, and demonstrates field access and mutation. The output is 10 and 25.

```lust
local pt: Point = Point { x = 10, y = 20 }

-- Field access and mutation
println(pt.x) -- 10
pt.y = 25
println(pt.y) -- 25
```

--------------------------------

### Perform file read and write operations

Source: https://lust-lang.dev/docs/language-tour/io-and-os.html

Demonstrates writing a string to a file and reading it back, using Result types to handle potential errors.

```lust
local path = "app_config.txt"

-- Write a file
local write_res = io.write_file(path, "port = 8080\nenv = production\n")
if write_res is Err(err) then
    println("Failed to write config: " .. err)
    return
end

-- Read back the file
local read_res = io.read_file(path)
if read_res is Ok(content) then
    println("Config loaded:\n" .. content)
elseif read_res is Err(err) then
    println("Failed to read config: " .. err)
end
```

--------------------------------

### Enable IO and OS modules in lust-config.toml

Source: https://lust-lang.dev/docs/language-tour/io-and-os.html

Declare the stdlib_modules setting in your configuration file to enable access to IO and OS functionality.

```toml
[settings]
stdlib_modules = ["io", "os"]
jit = true
```

--------------------------------

### Test types with `is` operator

Source: https://lust-lang.dev/docs/language-tour/type-system.html

Use `is` to test if a value is of a concrete type. Negative checks use `not (...)`. The example shows testing an int and a string.

```lust
local x: int = 42
local s: string = "hello"

if x is int then
    println("x is an integer")
end

-- Negative checks use 'not (...)'
if not (s is int) then
    println("s is not an integer")
end
```

--------------------------------

### Declare union type with `|`

Source: https://lust-lang.dev/docs/language-tour/type-system.html

Union types represent values that can be one of multiple types, written with the pipe (`|`) operator. This example declares a variable that can be a string or an int.

```lust
local id: string | int = 101
```

--------------------------------

### Run a Lust script

Source: https://lust-lang.dev/docs/tooling.html

Runs a Lust script. The CLI loads `main.lust`, parses and type-checks the module dependency graph, applies settings from `lust-config.toml` if present, and executes the script.

```bash
lust main.lust
```

--------------------------------

### Combine `as` and `is` in if condition

Source: https://lust-lang.dev/docs/language-tour/type-system.html

Casts and pattern checks associate left-to-right, so you can combine `as` and `is` directly in an `if` statement without extra parentheses. The example checks if a cast succeeds and the value is greater than 1024.

```lust
if raw_port as int is Some(port) and port > 1024 then
    println("Unprivileged port: " .. port)
end
```

--------------------------------

### lust CLI usage

Source: https://lust-lang.dev/docs/tooling.html

Shows the full command-line usage of the `lust` executable, including running scripts, disassembly, extern stubs, help, version, and package management.

```text
USAGE:
    lust <script.lust>                   Run a Lust script
    lust --disassemble <script.lust>     Show bytecode disassembly (-d)
    lust --dump-externs <script.lust>    Create extern stubs from lust-config.toml
    lust --help, -h                      Show this help message
    lust --version, -v                   Show version information
    lust pkg <command> [options]         Manage Lust packages
```

--------------------------------

### Hello world script in Lust

Source: https://lust-lang.dev/docs/quick-start.html

A simple Lust script that prints a greeting and a typed message. Demonstrates string concatenation with the `..` operator and the `tostring` function.

```lust
-- hello.lust
println("Hello from Lust!")

local greeting: string = "Welcome to typed scripting"
local year: int = 2026

println(greeting .. " in " .. tostring(year) .. "!")

```

--------------------------------

### Explicitly specify generic parameter in Lust

Source: https://lust-lang.dev/docs/language-tour/generics-and-traits.html

When a type parameter cannot be inferred, specify it explicitly with the angle brackets directly following the identifier (no whitespace). The example forces the string type for the identity call.

```lust
local text = identity<string>("hello")

```

--------------------------------

### Output of running hello.lust

Source: https://lust-lang.dev/docs/quick-start.html

Expected output when running `lust hello.lust`.

```text
Hello from Lust!
Welcome to typed scripting in 2026!

```

--------------------------------

### Add Lust binary directory to PATH

Source: https://lust-lang.dev/docs/quick-start.html

Add the extracted Lust binary directory to your PATH.

```bash
export PATH="$PWD:$PATH"

```

--------------------------------

### Publish a package with lust pkg publish

Source: https://lust-lang.dev/docs/tooling.html

Packages and uploads the current library to the registry, using the specified manifest and readme files.

```bash
lust pkg publish --manifest-path ./lust-config.toml --readme ./README.md
```

--------------------------------

### Narrow union types with `is` in conditionals

Source: https://lust-lang.dev/docs/language-tour/type-system.html

Inside conditionals, testing a union value with `is` narrows its type within that branch, allowing type-specific operations. The example shows a function that formats an identifier based on its type.

```lust
function format_identifier(id: string | int): string
    if id is string then
        -- Within this branch, 'id' is guaranteed to be a string
        return "ID: " .. string.upper(id)
    elseif id is int then
        -- Within this branch, 'id' is guaranteed to be an int
        return "ID #" .. tostring(id * 2)
    end
    return "Unknown ID"
end

println(format_identifier("usr_alpha")) -- Outputs: ID: USR_ALPHA
println(format_identifier(50))          -- Outputs: ID #100
```

--------------------------------

### Use while loop

Source: https://lust-lang.dev/docs/print.html

Shows the `while` loop syntax. The loop runs while the condition is true, incrementing a counter.

```lust
local counter = 1
while counter <= 3 do
    println("Step " .. counter)
    counter += 1
end
```

--------------------------------

### Query JIT stats with program.jit_stats()

Source: https://lust-lang.dev/docs/print.html

Query tracing JIT counters from a compiled program and print them. Requires a program that has been compiled and executed.

```rust
#![allow(unused)]
fn main() {
let stats = program.jit_stats();
println!("Root traces compiled: {}", stats.root_traces_compiled);
println!("Native entries:       {}", stats.native_trace_entries);
println!("Recursive calls:      {}", stats.recursive_calls);
}

```

--------------------------------

### Module initialization and caching

Source: https://lust-lang.dev/docs/language-tour/modules.html

Top-level statements in a module execute once upon the first import, and exported symbols are cached for subsequent imports.

```lust
-- lib/config.lust
println("[config] initializing settings...")
TIMEOUT: int = 30
```

```lust
-- main.lust
use lib.config as cfg

println("Timeout is: " .. cfg.TIMEOUT)
```

--------------------------------

### os.create_file(path)

Source: https://lust-lang.dev/docs/print.html

Creates an empty file. Returns a Result that must be checked for success or failure.

```APIDOC
## os.create_file(path)

### Description
Creates an empty file.

### Function Signature
`os.create_file(path)`

### Parameters
- **path** (string) - Required - The path of the file to create.

### Returns
- **Result<(), string>** - On success, contains an empty tuple. On failure, contains an error message.
```

--------------------------------

### Explicit Conversion with `tostring`

Source: https://lust-lang.dev/docs/language-tour/basics.html

Shows how to explicitly convert values to strings using `tostring(val)`.

```lust
println("Flag is " .. tostring(true))
```

--------------------------------

### Import module with alias

Source: https://lust-lang.dev/docs/language-tour/modules.html

Import an entire module namespace and assign it an alias for use in the current scope.

```lust
use geom.shapes as shapes

local c = shapes.Circle { radius = 5.0 }
println("Area: " .. tostring(shapes.area(c)))
```

--------------------------------

### Arithmetic Operators

Source: https://lust-lang.dev/docs/language-tour/basics.html

Demonstrates standard arithmetic operators: addition, subtraction, multiplication, division, and modulo. The comments show the resulting values.

```lust
local a = 20
local b = 6

local sum = a + b              -- 26
local difference = a - b       -- 14
local product = a * b          -- 120
local quotient = a / b         -- 3
local remainder = a % b        -- 2
```

--------------------------------

### os.create_dir(path)

Source: https://lust-lang.dev/docs/print.html

Creates a new directory. Returns a Result that must be checked for success or failure.

```APIDOC
## os.create_dir(path)

### Description
Creates a new directory.

### Function Signature
`os.create_dir(path)`

### Parameters
- **path** (string) - Required - The path of the directory to create.

### Returns
- **Result<(), string>** - On success, contains an empty tuple. On failure, contains an error message.

### Example
```lust
os.create_dir(dir)
```
```

--------------------------------

### Compile and run an embedded Lust program

Source: https://lust-lang.dev/docs/embedding.html

Builds a Lust module in memory using EmbeddedProgram::builder(), runs its entry script, and calls a typed Lust function from Rust.

```rust
use lust::EmbeddedProgram;

fn main() -> lust::Result<()> {
    let script = r#"
        function greet(name: string): string
            return "Hello, " .. name .. "!"
        end
    "#;

    let mut program = EmbeddedProgram::builder()
        .module("main", script)
        .entry_module("main")
        .compile()?;

    // Execute top-level statements to initialize globals
    program.run_entry_script()?;

    // Call a typed Lust function directly from Rust
    let message: String = program.call_typed("main.greet", "Rust Host")?;
    println!("{message}");

    Ok(())
}
```

--------------------------------

### Download and extract Lust precompiled release for Linux x86_64

Source: https://lust-lang.dev/docs/quick-start.html

Download and extract the precompiled Lust release for Linux x86_64. Verifies the SHA256 checksum before extracting.

```bash
curl -OL https://lust-lang.dev/downloads/lust-linux-x86_64.tar.gz
curl -OL https://lust-lang.dev/downloads/lust-linux-x86_64.tar.gz.sha256
shasum -a 256 -c lust-linux-x86_64.tar.gz.sha256
tar -xf lust-linux-x86_64.tar.gz

```

--------------------------------

### Build a cooperative scheduler with task.resume

Source: https://lust-lang.dev/docs/language-tour/tasks.html

Implements a simple cooperative scheduler that interleaves two worker tasks. It repeatedly resumes each active task, prints yielded values, and collects tasks that are still running until all complete.

```lust
function worker(name: string, steps: int): string
    for i = 1, steps do
        task.yield(name .. " step " .. tostring(i))
    end
    return name .. " finished"
end

local task_a = task.create(function(): string
    return worker("Worker-A", 2)
end)

local task_b = task.create(function(): string
    return worker("Worker-B", 3)
end)

local active: Array<Task> = [task_a, task_b]

while array.len(active) > 0 do
    local remaining: Array<Task> = []
    for t in active do
        local status = task.status(t)
        if status is Completed or status is Failed or status is Stopped then
            local info = task.info(t)
            if info.last_result is Some(res) then
                println("Done: " .. tostring(res))
            end
        else
            local frame = task.resume(t)
            if frame.last_yield is Some(msg) then
                println("Yielded: " .. tostring(msg))
            end
            array.push(remaining, t)
        end
    end
    active = remaining
end
```

--------------------------------

### Disassemble Lust bytecode with --disassemble flag

Source: https://lust-lang.dev/docs/quick-start.html

Disassemble the bytecode of `hello.lust` using the `--disassemble` (or `-d`) flag. Dumps the constant pool, local variable tables, and opcode instructions.

```bash
lust --disassemble hello.lust

```

--------------------------------

### Add dependencies with lust pkg add

Source: https://lust-lang.dev/docs/tooling.html

Adds dependencies to the project manifest. The first adds a specific version, the second adds a package from a custom registry.

```bash
lust pkg add json@1.2.0
lust pkg add my-utils --registry https://packages.lust-lang.dev
```

--------------------------------

### Module directory structure mapping

Source: https://lust-lang.dev/docs/language-tour/modules.html

Lust maps directory hierarchies to module names using dot notation, where each file represents a module.

```text
my_project/
├── lust-config.toml
├── main.lust
└── geom/
    ├── shapes.lust           -- Maps to module: geom.shapes
    └── vector.lust           -- Maps to module: geom.vector
```
Tokens:
Raw