rune 0.14.2

The Rune Language, an embeddable dynamic programming language for Rust.
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

enum Op {
    Inc(v),
    Move(v),
    Loop(ops),
    Input,
    Print,
}

struct Tape {
    pos,
    tape,
}

impl Tape {
    fn new() {
        Tape { pos: 0, tape: [0] }
    }

    fn get(self) {
        self.tape[self.pos]
    }

    fn inc(self, x) {
        self.tape[self.pos] = (self.tape[self.pos] + x) % 256;

        if self.tape[self.pos] < 0 {
            self.tape[self.pos] = self.tape[self.pos] + 256;
        }
    }

    fn mov(self, x) {
        self.pos += x;

        while self.pos >= self.tape.len() {
            self.tape.push(0);
        }
    }

    fn set(self, v) {
        self.tape[self.pos] = v;
    }
}

fn run(program, tape, inputs) {
    for op in program {
        match op {
            Op::Inc(x) => tape.inc(x),
            Op::Move(x) => tape.mov(x),
            Op::Loop(program) => while tape.get() != 0 {
                run(program, tape, inputs);
            },
            Op::Print => {
                let c = char::from_i64(tape.get()).expect("A valid char");
                print!("{c}");
            }
            Op::Input => {
                tape.set(0)
            }
        }
    }
}

fn parse(it) {
    let buf = Vec::new();

    while let Some(c) = it.next() {
        let op = match c {
            '+' => Op::Inc(1),
            '-' => Op::Inc(-1),
            '>' => Op::Move(1),
            '<' => Op::Move(-1),
            '.' => Op::Print,
            '[' => Op::Loop(parse(it)),
            ',' => Op::Input,
            ']' => break,
            _ => continue,
        };

        buf.push(op);
    }

    buf
}

struct Program {
    ops,
    inputs,
}

impl Program {
    fn new(code, inputs) {
        Program { ops: parse(code), inputs }
    }

    fn run(self) {
        let tape = Tape::new();
        run(self.ops, tape, self.inputs);
    }
}

fn bf(s, i) {
    let program = Program::new(s.chars(), i);
    program.run();
}

#[bench]
pub fn bf_hello_world(b) {
    b.iter(
        || {
            bf(
                "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.",
                0,
            )
        },
    )
}