uni-core 0.0.12

Core interpreter library for the Uni programming language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

# uni-core

![Version](https://img.shields.io/badge/version-0.0.12-blue)
![License](https://img.shields.io/badge/license-MIT%20OR%20Unlicense-green)

The core interpreter library for the Uni programming language - a homoiconic stack-based language that unifies code and data.

## Features

- **Homoiconic** - Code and data have identical representation
- **Stack-based** - All operations work with a central computation stack
- **Tail-call optimized** - Continuation-based evaluator enables infinite recursion
- **Multiple numeric types** - Integers, rationals, floats, and complex numbers
- **no_std compatible** - Works on embedded systems without the Rust standard library

## Quick Start

Add to your `Cargo.toml`:

```toml
[dependencies]
uni-core = "0.0.12"
```

Basic usage:

```rust
use uni_core::{Interpreter, execute_string};

fn main() {
    let mut interp = Interpreter::new();

    // Execute Uni code
    execute_string("5 3 +", &mut interp).unwrap();

    // Get result from stack
    if let Some(result) = interp.stack.last() {
        println!("Result: {}", result);  // Output: 8
    }
}
```

## Example: Calculator

```rust
use uni_core::{Interpreter, execute_string};

let mut interp = Interpreter::new();

// Define a square function
execute_string("'square [dup *] def", &mut interp).unwrap();

// Use it
execute_string("5 square", &mut interp).unwrap();

println!("{}", interp.stack.last().unwrap());  // Output: 25
```

## Optional Features

- `std` - Standard library support (default: disabled)
- `advanced_math` - Trigonometric functions, exp/log, rounding
- `complex_numbers` - Complex number and Gaussian integer support
- `repl` - REPL (Read-Eval-Print Loop) with line editing support
- `datetime` - Date/time operations (requires `std`)
- `hardware-microbit` - micro:bit v2 hardware primitives
- `hardware-pico2` - Raspberry Pi Pico 2 (RP2350) hardware primitives
- `hardware-stm32h753zi` - STM32H753ZI hardware primitives (async Embassy)

## Using the REPL

To build products with custom primitives and an interactive REPL:

```rust
use uni_core::{Interpreter, repl::run_repl, Value, RuntimeError};
use uni_core::interpreter::DictEntry;
use editline::terminals::StdioTerminal;
use std::rc::Rc;

// Your custom primitive
fn my_op(interp: &mut Interpreter) -> Result<(), RuntimeError> {
    let n = interp.pop_number()?;
    interp.push(Value::Number(n * 42.0));
    Ok(())
}

fn main() {
    let mut interp = Interpreter::new();

    // Register custom primitive
    let atom = interp.intern_atom("my-op");
    interp.dictionary.insert(atom, DictEntry {
        value: Value::Builtin(my_op),
        is_executable: true,
        doc: Some(Rc::from("Multiply by 42\nUsage: n my-op => result")),
    });

    // Start REPL with your custom primitives
    run_repl(interp, StdioTerminal::new());
}
```

Enable the `repl` feature in your `Cargo.toml`:

```toml
[dependencies]
uni-core = { version = "0.0.12", features = ["repl"] }
editline = "0.0.20"
```

## Documentation

For complete documentation, examples, and the command-line REPL, see the main repository:

**GitHub:** https://github.com/edadma/uni

## License

Dual-licensed under MIT OR Unlicense.