Rune Programming Language

Rune is an embeddable dynamic programming language for Rust. Key features include:

• Execution Model: Runs a compact language representation on an efficient stack-based virtual machine with stack isolation between function calls.
• Concurrency & Async: Supports multithreaded execution and first-class async support with Generators.
• Memory Management: Memory safe through reference counting.
• Language Features: Pattern matching, try operators, structs/enums with associated data, template literals, and awesome macros.
• Data Types: Dynamic containers like vectors, objects, and tuples, all with out-of-the-box serde support.
• Integration: Clean Rust integration and support for hot reloading.

Rune supports pattern matching on external enums out of the box. However, pattern matching will only recognize and allow access to fields that are explicitly annotated with #[rune(get)] in the Rust definition.

This applies to:

• Tuple variants: Only the annotated fields are visible in the pattern.
• Struct variants: Only the annotated named fields are visible in the pattern.

Example of pattern matching on a tuple variant where only the first field is visible:

enum External {
    First(#[rune(get)] u32, u32),
    Second(#[rune(get)] u32),
}

pub fn main(external) {
    match external {
        External::First(a) => a,
        External::Second(b) => b,
    }
}