amethyst_geode 1.2.0

Turing Machine Programming Language Interpreter
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

use colored::*;
use core::fmt::Display;

#[derive(Debug, Clone)]
pub struct Tape {
    left: Vec<char>,
    right: Vec<char>,
}

impl Default for Tape {
    fn default() -> Self {
        Self {
            left: Vec::new(),
            right: Vec::new(),
        }
    }
}

impl Display for Tape {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "..@{}|{}|@..",
            self.left
                .iter()
                .flat_map(|sym| ['|', *sym])
                .collect::<String>(),
            self.right
                .iter()
                .rev()
                .flat_map(|sym| ['|', *sym])
                .skip(1)
                .collect::<String>()
        )
    }
}

impl Tape {
    pub fn read(&self) -> char {
        *self.right.last().unwrap_or(&'@')
    }
    pub fn write(&mut self, symbol: char) {
        self.right.pop();
        self.right.push(symbol);
    }
    pub fn move_left(&mut self) {
        let character = match self.left.pop() {
            Some(x) => x,
            None => '@',
        };
        self.right.push(character);
    }
    pub fn move_right(&mut self) {
        let character = match self.right.pop() {
            Some(x) => x,
            None => '@',
        };
        self.left.push(character);
    }
    pub fn shift_left(&mut self) {
        self.left.pop();
    }
    pub fn shift_right(&mut self) {
        let character = match self.right.last() {
            Some(x) => *x,
            None => '@',
        };
        self.left.push(character);
    }
    pub fn initialize(&mut self, input: String) {
        input
            .chars()
            .rev()
            .for_each(|character| self.right.push(character));
    }
    pub fn memory(&self) -> usize {
        self.left.len() + self.right.len()
    }
    pub fn show_output(&self) {
        println!("{}", "Output:".bright_blue());
        let output = self
            .right
            .iter()
            .rev()
            .filter(|sym| **sym != '@')
            .collect::<String>();
        println!(
            "{}",
            if output == "" {
                "@".to_string()
            } else {
                output
            }
        );
    }
    pub fn show_tape(&self) {
        println!("{}", "Tape:".bright_blue());
        let header = self.left.len();
        println!(
            "..@{}|{}|@..",
            self.left
                .iter()
                .flat_map(|sym| ['|', *sym])
                .collect::<String>(),
            self.right
                .iter()
                .rev()
                .flat_map(|sym| ['|', *sym])
                .skip(1)
                .collect::<String>()
        );
        println!("{}^", " ".repeat(header * 2 + 4));
    }
}