Draft:Rex (programming language)

Ownership and borrow checking

Rex implements an ownership-based memory management model. Every value in Rex has a single owner, and ownership is transferred when values are passed to functions or assigned to new variables. This prevents common memory errors such as use-after-free.

The Rex compiler also includes a borrow checker that ensures safe references to data. The borrow rules include:

• Multiple immutable references may exist simultaneously.
• Only one mutable reference may exist at a time.
• Mutable and immutable references cannot coexist.

These rules are enforced at compile time, eliminating the need for a garbage collector.^[2]

Bond system

Rex introduces a transactional state-management mechanism using the keywords bond, commit, and rollback. This mechanism allows a group of operations to be executed atomically.

fn update_player_score(mut player_score: i32, points: i32) -> Result<i32, str> {
    bond temp_score = player_score
    temp_score += points

    if temp_score < 0 {
        rollback
        return Err("Score cannot be negative")
    } else {
        commit
        return Ok(temp_score)
    }
}

This feature allows developers to ensure that changes to program state are either fully applied or completely reverted.^[3]

Concurrency primitives

Rex provides built-in support for concurrent programming:

• spawn creates lightweight concurrent tasks.
• channels provide safe communication between tasks through ownership transfer.

These mechanisms aim to reduce the complexity and risk associated with multithreaded programming.

Type system

The Rex type system supports several modern programming constructs:

• Structs for grouping related data
• Enums for algebraic data types and pattern matching
• Generics for reusable abstractions

Deferred execution

The defer keyword ensures that cleanup code is executed when leaving the current scope.

fn process_file(path: str) -> Result<str, str> {
    let file = fs.open(path)?
    defer { fs.close(file) }

    Ok("Success")
}

This feature simplifies resource management such as file handling.

Variables

let x = 10
mut y = 20
y = y + 1

Functions

fn add(a: i32, b: i32) -> i32 {
    return a + b
}