Rux Language Reference

https://rux-lang.dev/docs/
Admin
Official language reference documentation for Rux, a fast, compiled, strongly-typed, multi-paradigm...
Tokens:171,514
Snippets:2,340
Trust Score:5.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### rux install command examples

Source: https://rux-lang.dev/docs/cli/install

Common usage patterns for installing dependencies, including target platform and registry overrides.

```bash
rux install
rux install Rux/Io
rux install Rux/Io@^0.1.0
rux install --target windows-x86_64
rux install --registry http://localhost:8080
```

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

### Add and install dependencies

Source: https://rux-lang.dev/docs/start/examples

Add the standard library to your project and install the necessary packages.

```bash
rux add Std
rux install
```

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

### Navigate to an example project

Source: https://rux-lang.dev/docs/start/examples

Change directory into a specific example folder and open it in your editor.

```bash
cd Hello
code .
```

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

### Clone the examples repository

Source: https://rux-lang.dev/docs/start/examples

Download the official collection of Rux examples from GitHub.

```bash
git clone https://github.com/rux-lang/Examples.git
cd Examples
```

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

### Run an example project

Source: https://rux-lang.dev/docs/start/examples

Execute the build and run command within an example project directory.

```bash
rux run
```

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

### Common rux fmt usage examples

Source: https://rux-lang.dev/docs/cli/fmt

Examples showing standard formatting, check-only mode, and manifest-specific formatting.

```bash
rux fmt
rux fmt --check
rux fmt --manifest-only
```

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

### Package Installation

Source: https://rux-lang.dev/docs/api/io

Commands to add and install the Io package to a Rux project.

```bash
rux add Io
rux install
```

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

### Install a package from the registry

Source: https://rux-lang.dev/docs/packaging/registry

Use the rux add command to record a dependency in Rux.toml, followed by rux install to download the package and its dependencies.

```bash
rux add Rux/Io@^1.0.0
rux install
```

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

### Install Build Tools on Windows

Source: https://rux-lang.dev/docs/start/build

Use Scoop to install the required build dependencies on Windows.

```bash
scoop install llvm cmake ninja git
```

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

### Install the Format package

Source: https://rux-lang.dev/docs/api/format

Commands to add and install the Format package in a Rux project.

```bash
rux add Format
rux install
```

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

### Run unit tests

Source: https://rux-lang.dev/docs/cli/test

Examples of running tests with default settings or the release profile.

```bash
rux test
rux test --release
```

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

### Installing the Text Package

Source: https://rux-lang.dev/docs/api/text

Commands to add the Text package to a project and install dependencies.

```bash
rux add Text
rux install
```

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

### Install Rux Dependencies

Source: https://rux-lang.dev/docs/api/introduction

Use these commands to record a dependency in the manifest and fetch the package.

```bash
rux add Math
rux install
```

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

### Install the C package

Source: https://rux-lang.dev/docs/api/c

Use the Rux CLI to add and install the C package dependency.

```bash
rux add C
rux install
```

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

### Install Windows Package

Source: https://rux-lang.dev/docs/api/windows

Commands to add and install the Windows package to a Rux project.

```bash
rux add Windows
rux install
```

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

### Install Build Tools on Debian/Ubuntu

Source: https://rux-lang.dev/docs/start/build

Use apt to install the required build dependencies on Debian or Ubuntu systems.

```bash
sudo apt install clang cmake ninja-build git
```

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

### Install Rux via script

Source: https://rux-lang.dev/docs/start/install/linux

Downloads and installs the latest Rux binary to ~/.local/bin without requiring root privileges.

```bash
curl -fsSL https://rux-lang.dev/install.sh | sh
```

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

### Syscall Usage Example

Source: https://rux-lang.dev/docs/api/linux/syscalls

Example demonstrating how to invoke a syscall and check for errors using IsError.

```rux
import Linux::{ IsError, SYS_GETPID, Syscall0 };

func Main() -> int {
    let result = Syscall0(SYS_GETPID);
    if !IsError(result) {
        let pid = result;
    }
    return 0;
}
```

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

### Install Rux via Scoop

Source: https://rux-lang.dev/docs/start/install/windows

Install the Rux compiler using the Scoop package manager.

```bash
scoop install rux
```

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

### Install Build Tools on Fedora

Source: https://rux-lang.dev/docs/start/build

Use dnf to install the required build dependencies on Fedora.

```bash
sudo dnf install clang cmake ninja-build git
```

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

### Install Linux Package

Source: https://rux-lang.dev/docs/api/linux

Commands to add and install the Linux package in a Rux project.

```bash
rux add Linux
rux install
```

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

### rux install command usage

Source: https://rux-lang.dev/docs/cli/install

Basic syntax for running the install command with or without specific package identifiers.

```bash
rux install
rux install [namespace]/[package]
rux install [namespace]/[package]@[requirement]
```

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

### Install Bsd Package

Source: https://rux-lang.dev/docs/api/bsd

Commands to add and install the Bsd package in a Rux project.

```bash
rux add Bsd
rux install
```

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

### Install Build Tools on BSD

Source: https://rux-lang.dev/docs/start/build

Use pkg to install the required build dependencies on BSD systems.

```bash
pkg install llvm cmake ninja git
```

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

### rux add command examples

Source: https://rux-lang.dev/docs/cli/add

Common usage patterns for adding registry and local path dependencies.

```bash
rux add Rux/Io
rux add Rux/Io@^0.1.0
rux add Json --path ../Json
```

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

### Install Build Tools on Arch

Source: https://rux-lang.dev/docs/start/build

Use pacman to install the required build dependencies on Arch Linux.

```bash
sudo pacman -S clang cmake ninja git
```

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

### Publishing commands

Source: https://rux-lang.dev/docs/cli/publish

Basic usage examples for publishing packages, including dry-run mode and custom registry targets.

```bash
rux publish
rux publish --dry-run
rux publish --registry http://localhost:8080
```

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

### Login command examples

Source: https://rux-lang.dev/docs/cli/login

Common ways to invoke the login command with or without a specific registry URL.

```bash
rux login
rux login --registry http://localhost:8080
```

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

### Write to Standard Output

Source: https://rux-lang.dev/docs/api/macos

Example demonstrating how to write a string to standard output using the Write wrapper.

```rux
import MacOS::{ StdOut, Write };

func Main() -> int {
    let message = "hello from macOS\n";
    let result = Write(StdOut, message.data, message.length);
    return result == message.length as int64 ? 0 : 1;
}
```

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

### Writing to Standard Output

Source: https://rux-lang.dev/docs/api/macos/write

Example demonstrating how to write a string to standard output using the Write function.

```rux
import MacOS::{ StdOut, Write };

func Main() -> int {
    let text = "hello\n";
    let result = Write(StdOut, text.data, text.length);
    if result != text.length as int64 {
        return 1;
    }
    return 0;
}
```

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

### Using Cotan in Rux

Source: https://rux-lang.dev/docs/api/math/cotan

Example demonstrating the import and usage of the Cotan function with a constant.

```rux
import Math::{ Cotan, QuarterPi };

func Main() -> int {
    let a = Cotan(QuarterPi); // 1.0
    return 0;
}
```

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

### Repository directory structure

Source: https://rux-lang.dev/docs/start/examples

The standard layout for Rux example projects.

```text
Examples/
├── Hello/
│   ├── Src/
│   │    └── Main.rux
│   └── Rux.toml
├── Factorial/
│   ├── Src/
│   │    └── Main.rux
│   └── Rux.toml
├── ...
└── README.md
```

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

### Nanosleep Usage Example

Source: https://rux-lang.dev/docs/api/linux/nanosleep

Demonstrates how to call Nanosleep with a one-second delay and handle potential errors.

```Rux
import Linux::{ IsError, Nanosleep, Timespec };

func Main() -> int {
    var delay = Timespec { seconds: 1i64, nanoseconds: 0i64 };
    if IsError(Nanosleep(@delay, null)) {
        return 1;
    }
    return 0;
}
```

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

### Formatted Output Examples

Source: https://rux-lang.dev/docs/api/io

Shows how to use format strings with PrintLine, including literal brace escaping.

```rux
PrintLine("{} of {} done", 3, 10);  // 3 of 10 done
PrintLine("{{{}}}", "braced");      // {braced}
```

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

### Write to Standard Output

Source: https://rux-lang.dev/docs/api/bsd

Example demonstrating how to write a string to standard output using the Bsd package.

```rux
import Bsd::{ StdOut, Write };

func Main() -> int {
    let message = "hello from BSD\n";
    let result = Write(StdOut, message.data, message.length);
    return result == message.length as int64 ? 0 : 1;
}
```

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

### Install Rux Extension via Command Line

Source: https://rux-lang.dev/docs/start/editors/vscode

Use the VS Code command palette or terminal to install the Rux Language extension.

```bash
# Press Ctrl+P in VS Code and paste:
ext install rux-lang.vscode-rux
```

```bash
code --install-extension rux-lang.vscode-rux
```

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

### Memory.Set Usage Example

Source: https://rux-lang.dev/docs/api/memory/set

Demonstrates allocating memory, filling it with specific byte values, and freeing the allocated block.

```rux
import Memory::{ Alloc, Free, Set };

func Main() -> int {
    let buffer = Alloc(16);

    Set(buffer, 16, 0xA5);  // every byte is 0xA5
    Set(buffer, 16, 0x1FF); // every byte is 0xFF -- only the low 8 bits land

    Free(buffer);
    return 0;
}
```

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

### GetPid Usage Example

Source: https://rux-lang.dev/docs/api/bsd/getpid

Demonstrates how to import and call the GetPid function within a main program.

```Rux
import Bsd::GetPid;

func Main() -> int {
    let pid = GetPid();
    return 0;
}
```

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

### Hypot Usage Example

Source: https://rux-lang.dev/docs/api/math/hypot

Demonstrates importing the Hypot function and calculating the hypotenuse of a 3-4-5 triangle.

```rux
import Math::Hypot;

func Main() -> int {
    let a = Hypot(3.0, 4.0); // 5.0
    return 0;
}
```

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

### Install Rux binary

Source: https://rux-lang.dev/docs/start/install/freebsd

Move the extracted binary to a directory in your system PATH with root privileges.

```shell
su -m root -c 'install -m 755 rux /usr/local/bin/rux'
```

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

### Install Rux dependencies

Source: https://rux-lang.dev/docs/packaging/dependencies

Downloads all dependencies declared in the manifest for the host or a specified target.

```bash
rux install
```

```bash
rux install --target windows-x86_64
```

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

### Examples of rux info usage

Source: https://rux-lang.dev/docs/cli/info

Common command-line invocations for querying package information.

```bash
rux info
rux info Rux/Io
rux info Rux/Io@0.1.0
rux info --json
```

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

### Memory.Free Usage Example

Source: https://rux-lang.dev/docs/api/memory/free

Demonstrates allocating a buffer and subsequently freeing it, including the safe handling of null pointers.

```rux
import Memory::{ Alloc, Free };

func Main() -> int {
    let buffer = Alloc(256);
    if buffer == null {
        return 1;
    }

    Free(buffer);
    Free(null); // harmless
    return 0;
}
```

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

### rux uninstall command examples

Source: https://rux-lang.dev/docs/cli/uninstall

Common usage patterns for uninstalling dependencies or clearing the global cache.

```bash
rux uninstall
rux uninstall Rux/Json
rux uninstall Rux/Json@0.1.0
rux uninstall --global
```

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

### Source Code Example

Source: https://rux-lang.dev/docs/lang/appendix/rcu

A simple Rux source file defining an Add function and a Main entry point.

```rux
// Math.rux
func Add(a: int32, b: int32) -> int32 {
    return a + b;
}

func Main() -> int32 {
    return Add(3, 4);
}
```

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

### Min Usage Example

Source: https://rux-lang.dev/docs/api/math/min

Demonstrates basic usage of Min with standard numbers and signed zeros.

```rux
import Math::Min;

func Main() -> int {
    let a = Min(3.0, 7.0);  // 3.0
    let b = Min(0.0, -0.0); // -0.0
    return 0;
}
```

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

### Example Rux.toml Manifest

Source: https://rux-lang.dev/docs/packaging/manifest

A standard manifest file defining package metadata and dependencies.

```toml
[Manifest]
Version = 1
MinRux = "0.4.0"

[Package]
Namespace = "Acme"
Name = "Widget"
Version = "1.2.3"
Type = "SourceLibrary"
Description = "A widget for every occasion"
Authors = ["Your Name <name@mail.com>"]
License = "MIT"

[Dependencies]
Io = { Namespace = "Rux", Version = "^1.0.0" }
```

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

### Remove dependency examples

Source: https://rux-lang.dev/docs/cli/remove

Examples of removing specific packages by their import name.

```bash
rux remove Json
rux remove Random
```

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

### Check build configuration

Source: https://rux-lang.dev/docs/api/core/config

Example demonstrating the use of #config.Has to conditionally execute code based on build-time definitions.

```rux
import Core::{ #config };
import Io::PrintLine;

func Main() -> int {
    when #config.Has("FeatureX") {
        PrintLine("FeatureX is enabled");
    }
    return 0;
}
```

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

### Sin Usage Example

Source: https://rux-lang.dev/docs/api/math/sin

Demonstrates calculating the sine of specific angles using the Math package.

```rux
import Math::{ HalfPi, Sin };

func Main() -> int {
    let a = Sin(HalfPi); // 1.0
    let b = Sin(0.0);    // 0.0
    return 0;
}
```

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

### Log2 Usage Example

Source: https://rux-lang.dev/docs/api/math/log2

Demonstrates basic usage of the Log2 function within a main program block.

```rux
import Math::Log2;

func Main() -> int {
    let a = Log2(8.0); // 3.0
    let b = Log2(1.0); // 0.0
    return 0;
}
```

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

### IsEmpty Usage Example

Source: https://rux-lang.dev/docs/api/text/string/isempty

Demonstrates checking string emptiness after initialization, assignment, and memory deallocation.

```Rux
import Text::String;

func Main() -> int {
    String::New().IsEmpty(); // true

    var text = String::From("Rux");
    text.IsEmpty();          // false

    text.Free();
    text.IsEmpty();          // true -- Free leaves an empty string behind
    return 0;
}
```

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

### Build and run the project

Source: https://rux-lang.dev/docs/start/examples

Compile the source code and execute the resulting binary.

```bash
rux build
rux run
```

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

### Print Usage Example

Source: https://rux-lang.dev/docs/api/io/print

Demonstrates basic printing of strings, characters, integers, and formatted output.

```rux
import Io::Print;
import Text::String;

func Main() -> int {
    Print("Loading");
    Print(c8'.');
    Print(3);            // Loading.3

    var name = String::From("Rux");
    Print(" {} {}\n", name, 1.5); // " Rux 1.5"

    name.Free();
    return 0;
}
```

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

### Cosh Usage Example

Source: https://rux-lang.dev/docs/api/math/cosh

Demonstrates basic usage of the Cosh function within a Main function.

```rux
import Math::Cosh;

func Main() -> int {
    let a = Cosh(0.0); // 1.0
    let b = Cosh(1.0); // 1.5430806348152437
    return 0;
}
```

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

### Common rux build examples

Source: https://rux-lang.dev/docs/cli/build

Various command-line invocations for building packages with different configurations and inspection flags.

```bash
rux build
rux build --all --stats
rux build --debug
rux build --release --target linux-x86_64
rux build --stats
rux build --verbose --release
rux build --emit ast,sema
```

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

### Basic rux run usage

Source: https://rux-lang.dev/docs/cli/run

Examples of executing the rux run command with various flags and arguments.

```bash
rux run
rux run --release
rux run -- --port 8080
```

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

### Install Memory package

Source: https://rux-lang.dev/docs/api/memory

Commands to add the Memory package to a project and install dependencies.

```bash
rux add Memory
rux install
```

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

### Initialize and Use StringBuilder

Source: https://rux-lang.dev/docs/api/text/stringbuilder/new

Demonstrates creating a new builder, observing its initial capacity, and appending data.

```rux
import Text::StringBuilder;

func Main() -> int {
    var builder = StringBuilder::New();
    builder.Capacity(); // 0 -- nothing is allocated yet

    builder.Append("Rux");
    builder.Capacity(); // 16 -- the first append takes a block

    builder.Free();
    return 0;
}
```

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

### Install MacOS Package

Source: https://rux-lang.dev/docs/api/macos

Commands to add and install the MacOS package in a Rux project.

```bash
rux add MacOS
rux install
```

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

### Create and Open a New Rux Project

Source: https://rux-lang.dev/docs/start/editors/vscode

Initialize a new project using the Rux CLI and open the directory in VS Code.

```bash
rux new MyApp
cd MyApp
code .
```

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

### Examples of rux new usage

Source: https://rux-lang.dev/docs/cli/new

Common usage patterns for creating different types of Rux packages.

```bash
rux new App
rux new App --executable
rux new Io --shared --namespace Rux
rux new Math --static
rux new Json --source
```

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

### Usage of String::New

Source: https://rux-lang.dev/docs/api/text/string/new

Demonstrates initializing an empty string and verifying its properties.

```Rux
import Text::String;

func Main() -> int {
    var empty = String::New();
    empty.IsEmpty(); // true
    empty.Length();  // 0
    empty.Free();    // safe, and not required
    return 0;
}
```

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

### ArcSin Usage Example

Source: https://rux-lang.dev/docs/api/math/arcsin

Demonstrates calculating the inverse sine of 1.0 and 0.0 within a main function.

```rux
import Math::ArcSin;

func Main() -> int {
    let a = ArcSin(1.0); // 1.5707963267948966 (HalfPi)
    let b = ArcSin(0.0); // 0.0
    return 0;
}
```

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

### Silent MSI Installation

Source: https://rux-lang.dev/docs/start/install/windows

Use this command in a terminal for scripted or unattended installations of the Rux compiler.

```bash
msiexec /i rux-windows.msi /quiet
```

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

### Using String and StringBuilder

Source: https://rux-lang.dev/docs/api/text

Demonstrates creating, trimming, and building strings, followed by manual memory cleanup.

```rux
import Io::PrintLine;
import Text::{ String, StringBuilder };

func Main() -> int {
    var name = String::From("  Rux  ").Trim(); // "Rux"

    var builder = StringBuilder::New();
    builder.Append("Hello, ");
    builder.Append(name);
    builder.Append(c8'!');

    var greeting = builder.IntoString(); // "Hello, Rux!"
    PrintLine(greeting.Length());        // 11

    greeting.Free();
    name.Free();
    return 0;
}
```

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

### Floor Usage Example

Source: https://rux-lang.dev/docs/api/math/floor

Demonstrates rounding positive and negative floating-point numbers using the Floor function.

```rux
import Math::Floor;

func Main() -> int {
    let a = Floor(3.7);  // 3.0
    let b = Floor(-3.2); // -4.0
    return 0;
}
```

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

### ParseFloat64 Usage Example

Source: https://rux-lang.dev/docs/api/format/parsefloat64

Demonstrates parsing decimal strings and handling the Result using pattern matching.

```rux
import Format::ParseFloat64;
import Io::PrintLine;

func Main() -> int {
    match ParseFloat64("3.14159") {
        .Success(x) => PrintLine(x),               // 3.14159
        .Error(_) => PrintLine("not a number")
    }

    match ParseFloat64("1.5e-3") {
        .Success(x) => PrintLine(x),               // 0.0015
        .Error(_) => {}
    }
    return 0;
}
```

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

### Install Build Tools on macOS

Source: https://rux-lang.dev/docs/start/build

Use Homebrew to install the required build dependencies on macOS.

```bash
brew install llvm cmake ninja git
```

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

### Initialize a Rux package

Source: https://rux-lang.dev/docs/cli/init

Basic usage of the rux init command to set up a new project.

```bash
rux init
rux init --executable
rux init --shared --namespace Rux
rux init --static
rux init --source
```

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

### Synopsis for rux init

Source: https://rux-lang.dev/docs/cli/init

Command syntax for the rux init utility.

```bash
rux init [options]
```

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

### String Usage Example

Source: https://rux-lang.dev/docs/api/text/string

Demonstrates basic string operations including creation, length checking, searching, transformation, and manual memory management.

```rux
import Io::PrintLine;
import Text::String;

func Main() -> int {
    var greeting = String::From("Hello, Rux!");
    var needle = String::From("Rux");

    PrintLine(greeting.Length());        // 11
    PrintLine(greeting.Contains(needle)); // true
    PrintLine(greeting.IndexOf(needle));  // 7

    var shout = greeting.ToUpper(); // "HELLO, RUX!"

    shout.Free();
    needle.Free();
    greeting.Free();
    return 0;
}
```

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

### Write to Standard Output

Source: https://rux-lang.dev/docs/api/linux

Example demonstrating how to write a message to standard output using the Write syscall wrapper and checking for errors.

```rux
import Linux::{ IsError, StdOut, Write };

func Main() -> int {
    let message = "hello from Linux\n";
    let result = Write(StdOut, message.data, message.length);
    if IsError(result) {
        return 1;
    }
    return result == message.length as int64 ? 0 : 2;
}
```

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

### Max Function Usage Example

Source: https://rux-lang.dev/docs/api/math/max

Demonstrates basic usage of the Max function, including handling of signed zeros.

```rux
import Math::Max;

func Main() -> int {
    let a = Max(3.0, 7.0);  // 7.0
    let b = Max(0.0, -0.0); // 0.0
    return 0;
}
```

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

### Install specific Rux version via script

Source: https://rux-lang.dev/docs/start/install/linux

Installs a specific version of Rux to a custom directory using script flags.

```bash
curl -fsSL https://rux-lang.dev/install.sh | sh -s -- --version 0.3.0 --dir /usr/local/bin
```

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

### Basic Input and Output Usage

Source: https://rux-lang.dev/docs/api/io

Demonstrates reading user input and printing formatted output using the Io package.

```rux
import Io::{ Print, PrintLine, ReadLine };

func Main() -> int {
    Print("What is your name? ");

    var name = ReadLine();
    PrintLine("Hello, {}!", name);

    name.Free();
    return 0;
}
```

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

### Using Memory.Zero to Clear Allocated Memory

Source: https://rux-lang.dev/docs/api/memory/zero

Example demonstrating how to allocate memory and safely clear it using the Zero function.

```rux
import Memory::{ Alloc, Free, Zero };

func Main() -> int {
    let buffer = Alloc(1024);

    Zero(buffer, 1024); // now safe to read before writing

    Free(buffer);
    return 0;
}
```

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

### func Substring(self, start: uint, length: uint) -> String

Source: https://rux-lang.dev/docs/api/text/string/substring

Returns a new String containing a specified number of bytes starting from a given offset.

```APIDOC
## func Substring(self, start: uint, length: uint) -> String

### Description
Returns a copy of the bytes in a range from the receiver string. The receiver remains unchanged.

### Parameters
- **start** (uint) - The byte offset to copy from.
- **length** (uint) - How many bytes to copy.

### Returns
- **String** - A new String holding the requested bytes. If the range runs past the end, it is clamped. A start index at or past the end, or a length of 0, returns an empty string.

### Example
```
import Text::String;

func Main() -> int {
    var text = String::From("Hello, Rux!");

    var hello = text.Substring(0, 5);  // "Hello"
    var rux = text.Substring(7, 3);    // "Rux"
    var tail = text.Substring(7, 999); // "Rux!" -- clamped to what is there
    var none = text.Substring(99, 3);  // "" -- start is past the end

    none.Free();
    tail.Free();
    rux.Free();
    hello.Free();
    text.Free();
    return 0;
}
```
```

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

### Hello World in Rux

Source: https://rux-lang.dev/docs/lang/introduction

The standard entry point for a Rux executable, demonstrating module imports and function definition.

```rux
import Io::Print;

func Main() -> int {
    Print("Hello, World!");
    return 0;
}
```

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

### rux list

Source: https://rux-lang.dev/docs/cli/list

Lists manifest dependencies and the installed versions that satisfy them.

```APIDOC
## rux list

### Description
Lists manifest dependencies and the installed versions that satisfy them. Using the --global option lists every exact version in the user cache.

### Synopsis
rux list [options]

### Options
- **--global** - List packages in the global environment cache instead of the local manifest.

### Examples
rux list
rux list --global

### Exit Status
- **0**: Success
- **1**: Compiler, validation, filesystem, network, or generation failures
- **2**: Invalid command-line usage
```

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

### Copying Memory Blocks Example

Source: https://rux-lang.dev/docs/api/memory/copy

Demonstrates allocating two memory blocks, setting the source block with a value, copying it to the destination, and verifying the result.

```rux
import Memory::{ Alloc, Compare, Copy, Free, Set };

func Main() -> int {
    let src = Alloc(16);
    let dest = Alloc(16);
    Set(src, 16, 0x5A);

    Copy(dest, src, 16);
    Compare(dest, src, 16); // 16 -- the blocks are equal

    Free(dest);
    Free(src);
    return 0;
}
```

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

### Usage of Stringable implementation

Source: https://rux-lang.dev/docs/api/format/stringable

Example showing the instantiation of a custom type and the manual lifecycle management of the returned String.

```rux
import Format::{ Stringable, WriteInt };
import Text::{ String, StringBuilder };
import Io::PrintLine;

struct Point {
    x: int;
    y: int;
}

extend Point : Stringable {
    func ToString(self) -> String {
        var builder = StringBuilder::New();
        builder.Append(c8'(');
        WriteInt(@builder, self.x as int64);
        builder.Append(", ");
        WriteInt(@builder, self.y as int64);
        builder.Append(c8')');
        return builder.IntoString();
    }
}

func Main() -> int {
    var origin = Point{ x: 0, y: 0 };
    var text = origin.ToString(); // "(0, 0)"

    PrintLine(text);
    text.Free();
    return 0;
}
```

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

### Tan Usage Example

Source: https://rux-lang.dev/docs/api/math/tan

Demonstrates calculating the tangent of 0.0 and QuarterPi.

```rux
import Math::{ QuarterPi, Tan };

func Main() -> int {
    let a = Tan(0.0);       // 0.0
    let b = Tan(QuarterPi); // 1.0
    return 0;
}
```

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

### Use StringBuilder for string construction

Source: https://rux-lang.dev/docs/api/text/stringbuilder

Demonstrates creating a builder, appending content, and converting it into a String.

```rux
import Io::PrintLine;
import Text::{ String, StringBuilder };

func Main() -> int {
    var builder = StringBuilder::New();

    for i in 0..3 {
        builder.Append("ab");
        builder.Append(c8'-');
    }

    PrintLine(builder.Length()); // 9

    var text = builder.IntoString(); // "ab-ab-ab-", and the builder is empty
    text.Free();
    return 0;
}
```

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

### ArcCot Usage Example

Source: https://rux-lang.dev/docs/api/math/arccot

Demonstrates calculating the inverse cotangent for specific values.

```rux
import Math::ArcCot;

func Main() -> int {
    let a = ArcCot(0.0); // 1.5707963267948966 (HalfPi)
    let b = ArcCot(1.0); // 0.7853981633974483 (QuarterPi)
    return 0;
}
```

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

### WriteBool Usage Example

Source: https://rux-lang.dev/docs/api/format/writebool

Demonstrates appending a boolean value to a StringBuilder instance.

```rux
import Format::WriteBool;
import Text::StringBuilder;

func Main() -> int {
    var builder = StringBuilder::New();
    builder.Append("cached: ");
    WriteBool(@builder, true);

    var line = builder.IntoString(); // "cached: true"

    line.Free();
    return 0;
}
```

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

### Panic usage example

Source: https://rux-lang.dev/docs/api/core/panic

Demonstrates triggering a panic when an invalid state is encountered.

```rux
import Core::Panic;

func Main() -> int {
    let ok = false;
    if !ok {
        Panic("unreachable state reached");
    }
    return 0;
}
```

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

### Accessing range bounds

Source: https://rux-lang.dev/docs/lang/ranges/overview

Retrieves the start and end fields from a range object.

```rux
let r = 5..12;
let lo = r.start;   // 5
let hi = r.end;     // 12
```

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

### Resizing Memory with Realloc

Source: https://rux-lang.dev/docs/api/memory/realloc

Example demonstrating memory allocation, resizing, and error handling. Note that the original pointer must be freed if the reallocation fails to avoid memory leaks.

```rux
import Memory::{ Alloc, Free, Realloc, Set };

func Main() -> int {
    var buffer = Alloc(8);
    Set(buffer, 8, 0xAB);

    let grown = Realloc(buffer, 64); // the first 8 bytes are still 0xAB
    if grown == null {
        Free(buffer); // the old block survived the failure
        return 1;
    }

    buffer = grown;
    Free(buffer);
    return 0;
}
```

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

### Memory.Compare Usage Example

Source: https://rux-lang.dev/docs/api/memory/compare

Demonstrates comparing two memory blocks and handling the return value for equality and difference offsets.

```Rux
import Memory::{ Alloc, Compare, Free, Set };

func Main() -> int {
    let lhs = Alloc(16);
    let rhs = Alloc(16);
    Set(lhs, 16, 0x5A);
    Set(rhs, 16, 0x5A);

    Compare(lhs, rhs, 16); // 16 -- equal, so the full length

    let bytes = rhs as *var uint8;
    *(bytes + 5) = 0x00;

    Compare(lhs, rhs, 16); // 5 -- the first difference
    Compare(lhs, rhs, 5);  // 5 -- equal, the difference is out of range

    Free(rhs);
    Free(lhs);
    return 0;
}
```

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

### Declaring Struct Types

Source: https://rux-lang.dev/docs/lang/structs/overview

Examples of struct declarations using primitive types and slices.

```rux
struct Point {
    x: float64;
    y: float64;
}

struct Person {
    name: Slice<char8>;
    age: uint32;
}

```

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

### String Table Layout

Source: https://rux-lang.dev/docs/lang/appendix/rcu

Example layout of the flat array of null-terminated UTF-8 strings.

```text
Offset   Content
 0       \0                          ← always: empty sentinel
 1       "add\0"
 5       "main\0"
10       "fn(i32, i32) -> i32\0"
30       "-> i32\0"
37       "math.rux\0"
46       ...
```

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

### Operator Precedence

Source: https://rux-lang.dev/docs/lang/operations/comparison

Examples showing how arithmetic and logical operators interact with comparison operators.

```rux
let valid = offset + length <= capacity && capacity != 0;
```

```rux
let valid = ((offset + length) <= capacity) && (capacity != 0);
```

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

### Examples of rux pack usage

Source: https://rux-lang.dev/docs/cli/pack

Common ways to invoke the pack command, including default and custom output paths.

```bash
rux pack
rux pack --output Dist/Math.ruxpkg
```

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

### Define a basic assembly function

Source: https://rux-lang.dev/docs/lang/functions/assembler

A simple example of an assembly function that returns immediately.

```rux
asm func Halt() {
    ret
}
```

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

### Implement constant in function

Source: https://rux-lang.dev/docs/lang/constants/overview

Example demonstrating the use of a constant within a function scope.

```rux
const MaxRetries: int = 5;

func Fetch() -> bool {
    var attempts = 0;
    while attempts < MaxRetries {
        if TryFetch() { return true; }
        attempts += 1;
    }
    return false;
}
```

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

### Deprecation Notice Example

Source: https://rux-lang.dev/docs/lang/attributes/warn

Using #Warn to notify developers that a function is deprecated and should be replaced.

```rux
#Warn("Use NewApi() instead; OldApi() will be removed in v2.0")
func OldApi() -> int32 {
    return NewApi();
}

func Main() -> int {
    OldApi(); // warning: Use NewApi() instead; OldApi() will be removed in v2.0
    return 0;
}
```

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

### ToUpper usage example

Source: https://rux-lang.dev/docs/api/text/string/toupper

Demonstrates converting a string to uppercase using the ToUpper method.

```rux
import Text::String;

func Main() -> int {
    var text = String::From("Hello, Rux!");

    var shout = text.ToUpper(); // "HELLO, RUX!"

    shout.Free();
    text.Free();
    return 0;
}
```

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

### Exp2 Usage Example

Source: https://rux-lang.dev/docs/api/math/exp2

Demonstrates calculating powers of 2 using the Exp2 function.

```rux
import Math::Exp2;

func Main() -> int {
    let a = Exp2(10.0); // 1024.0
    let b = Exp2(-1.0); // 0.5
    return 0;
}
```

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

### WriteInt Usage Example

Source: https://rux-lang.dev/docs/api/format/writeint

Demonstrates appending multiple signed integers to a StringBuilder instance.

```rux
import Format::WriteInt;
import Text::StringBuilder;

func Main() -> int {
    var builder = StringBuilder::New();
    builder.Append("offset ");
    WriteInt(@builder, -42i64);
    builder.Append(" of ");
    WriteInt(@builder, 100i64);

    var line = builder.IntoString(); // "offset -42 of 100"

    line.Free();
    return 0;
}
```

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

### Update Rux via Scoop

Source: https://rux-lang.dev/docs/start/install/windows

Update an existing Scoop installation of Rux to the latest version.

```bash
scoop update rux
```

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

### Basic Pointer Operations

Source: https://rux-lang.dev/docs/lang/pointers/overview

Demonstrates creating a writable pointer, reading from it, and writing to the underlying memory.

```rux
var x = 42;
let p: *var int32 = @x;   // writable pointer to x (x is a var)
let y = *p;               // y == 42 — read through the pointer
*p = 7;                   // write through the pointer; x == 7
```

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

### Initialize a new Rux project

Source: https://rux-lang.dev/docs/start/editors/sublime

Use these commands in your terminal to create a new project directory and navigate into it before opening it in Sublime Text.

```bash
rux new MyApp
cd MyApp
```

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

### Global Option Usage Examples

Source: https://rux-lang.dev/docs/cli/global

Common patterns for applying global flags to Rux commands.

```bash
rux --manifest examples/Rux.toml check
rux build --color=never
rux --quiet test
rux help build
rux help --json
```

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

### Write bytes to standard output

Source: https://rux-lang.dev/docs/api/bsd/write

Example demonstrating how to write a string to standard output using the Write function.

```rux
import Bsd::{ StdOut, Write };

func Main() -> int {
    let text = "hello\n";
    let result = Write(StdOut, text.data, text.length);
    if result != text.length as int64 {
        return 1;
    }
    return 0;
}
```

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

### Trim Usage Example

Source: https://rux-lang.dev/docs/api/text/string/trim

Demonstrates removing whitespace from a padded string and verifying the resulting length.

```rux
import Text::String;

func Main() -> int {
    var padded = String::From("  Hello, Rux!  \n");

    var text = padded.Trim(); // "Hello, Rux!"
    text.Length();            // 11

    text.Free();
    padded.Free();
    return 0;
}
```

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

### Using Tanh in Rux

Source: https://rux-lang.dev/docs/api/math/tanh

Example usage of the Tanh function within a main program block.

```rux
import Math::Tanh;

func Main() -> int {
    let a = Tanh(0.0); // 0.0
    let b = Tanh(1.0); // 0.7615941559557649
    return 0;
}
```

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

### Using StringBuilder::WithCapacity

Source: https://rux-lang.dev/docs/api/text/stringbuilder/withcapacity

Demonstrates initializing a builder with 64 bytes of capacity and verifying that appends within that limit do not trigger reallocations.

```rux
import Text::StringBuilder;

func Main() -> int {
    var builder = StringBuilder::WithCapacity(64);
    builder.Length();   // 0
    builder.Capacity(); // 64

    builder.Append("Rux");
    builder.Capacity(); // 64 still -- the append fit

    builder.Free();
    return 0;
}
```

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

### Define the Main entry point

Source: https://rux-lang.dev/docs/lang/functions/main

The Main function serves as the entry point for binary executables and must return an integer exit code.

```rux
// Entry point
func Main() -> int {
    return 0;
}
```

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

### Using qualified paths

Source: https://rux-lang.dev/docs/lang/modules/import

Demonstrates accessing items via their full qualified path without using an import statement.

```rux
let result = Math::Sqrt(2.0);
```

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

### Trunc Usage Example

Source: https://rux-lang.dev/docs/api/math/trunc

Demonstrates rounding positive and negative floating-point numbers toward zero.

```rux
import Math::Trunc;

func Main() -> int {
    let a = Trunc(3.9);  // 3.0
    let b = Trunc(-3.9); // -3.0
    return 0;
}
```

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

### Configure and Build Rux

Source: https://rux-lang.dev/docs/start/build

Configure the project using the Ninja generator and Clang, then execute the build process.

```bash
cmake -G Ninja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -B build
cmake --build build
```

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

### Convert Radians to Degrees

Source: https://rux-lang.dev/docs/api/math/radtodeg

Example usage of RadToDeg to convert Pi and HalfPi constants into degrees.

```rux
import Math::{ HalfPi, Pi, RadToDeg };

func Main() -> int {
    let degrees = RadToDeg(Pi);    // 180.0
    let ninety = RadToDeg(HalfPi); // 90.0
    return 0;
}
```

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

### PrintLine Usage Example

Source: https://rux-lang.dev/docs/api/io/printline

Demonstrates basic usage of PrintLine for printing strings, blank lines, formatted output, booleans, and floating-point numbers.

```Rux
import Io::PrintLine;

func Main() -> int {
    PrintLine("Report");
    PrintLine();                     // blank line
    PrintLine("{} items, {} failed", 12, 0);
    PrintLine(true);                 // true
    PrintLine(1.0 / 3.0);            // 0.333333333333333
    return 0;
}
```

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

### Use Pi constant in calculations

Source: https://rux-lang.dev/docs/api/math

Example of importing and using the Pi constant for geometric calculations.

```rux
import Math::Pi;

let circumference = 2.0 * Pi * radius;
```
Tokens:
Raw