Code shared from the Rust Playground

playground.rs

fn main() {

    // Linjie Zhang 2020
    //
    // T simple turing machine
    //
    // https://plato.stanford.edu/entries/turing-machine/#DefiTuriMach

    #[derive(Debug)]
    struct Machine {
        s1: Vec<char>,
        s2: Vec<char>,
    }

    impl Machine {
        fn new(state: char, symbols: Vec<char>) -> Self {
            Self {
                s1: vec![state],
                s2: symbols,
            }
        }

        fn state(&self) -> char {
            self.s1[0]
        }

        fn symbol(&self) -> char {
            self.s2[0]
        }

        fn set_state(&mut self, state: char) {
            self.s1[0] = state;
        }

        fn set_symbol(&mut self, symbol: char) {
            self.s2[0] = symbol;
        }

        fn print_tape(&self) {
            let tape_left = self.s1[1..].iter().rev().collect::<String>();
            let tape_right = self.s2.iter().collect::<String>();
            println!(
                "state: {:?}\nsymbol: {:?}\nleft tape: {:?}\nright tape: {:?}\n",
                self.state(),
                self.symbol(),
                tape_left,
                tape_right
            );
        }

        fn to_left(&mut self) {
            let n = self.s1.pop().unwrap();
            self.s2.push(n);
        }

        fn to_right(&mut self) {
            let n = self.s2.pop().unwrap();
            self.s1.push(n)
        }

        fn transition(&mut self, rules: &Vec<Vec<char>>) {
            let state = self.state();
            let symbol = self.symbol();
            for rule in rules {
                if rule[0] == state && rule[1] == symbol {
                    self.set_symbol(rule[2]);
                    if rule[3] == 'L' {
                        self.to_left();
                    } else {
                        self.to_right();
                    }
                    self.set_state(rule[4]);
                }
            }
            self.print_tape();
        }
    }

    let mut t_simple = Machine::new('q', vec!['0', '1', '0', '1']);

    let rules = vec![
        vec!['q', '0', '0', 'R', 'Q'],
        vec!['q', '1', '0', 'R', 'Q'],
        vec!['Q', '0', '1', 'R', 'q'],
        vec!['Q', '1', '1', 'R', 'q'],
    ];

    loop {
        t_simple.transition(&rules);
    }
}