Add rust-gc-sample

Author: nojima

rust-calc/Cargo.lock

@@ -6,4 +6,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-anyhow = "1.0.52"
+regex = "1"
+once_cell = "1"
+anyhow = "1"

rust-calc/Cargo.toml

@@ -1,13 +1,11 @@
-mod parse;
-mod tokenize;
+mod parsers;
+mod json;
 
-use crate::parse::parse;
-use crate::tokenize::tokenize;
 use anyhow::Result;
 use std::io::{self, Write};
 
 fn print_prompt() -> io::Result<()> {
-    print!("expr> ");
+    print!("json> ");
     io::stdout().flush()?;
     Ok(())
 }
@@ -20,38 +18,15 @@ fn read_line() -> io::Result<Option<String>> {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum Token {
-    Eof,
-    Integer(i64),
-    Plus,
-    Minus,
-    Asterisk,
-    Slash,
-    LeftParen,
-    RightParen,
-}
-
-impl Default for Token {
-    fn default() -> Self {
-        Token::Eof
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Node {
-    Integer(i64),
-    Add(Box<Node>, Box<Node>),
-    Sub(Box<Node>, Box<Node>),
-    Mul(Box<Node>, Box<Node>),
-    Div(Box<Node>, Box<Node>),
-}
-
 fn do_something(line: &str) -> Result<()> {
-    let tokens = tokenize(&line)?;
-    println!("Tokens: {:?}", tokens);
-    let node = parse(tokens.into_iter())?;
-    println!("AST: {:?}", node);
+    match crate::json::parse(line) {
+        Some(value) => {
+            print!("{:?}\n\n", value);
+        }
+        None => {
+            eprintln!("parse error");
+        }
+    }
     Ok(())
 }
 

rust-calc/src/main.rs

@@ -0,0 +1,9 @@
+[package]
+name = "rust-gc-sample"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+gc = { version = "0.4", features = ["derive"] }

rust-gc-sample/Cargo.lock

@@ -0,0 +1,73 @@
+use gc::{Finalize, Gc, GcCell, Trace};
+
+#[derive(Trace, Finalize)]
+struct Node {
+    prev: GcCell<Option<Gc<Node>>>,
+    next: GcCell<Option<Gc<Node>>>,
+    value: String,
+}
+
+#[derive(Trace, Finalize)]
+struct DoublyLinkedList {
+    head: Option<Gc<Node>>,
+    tail: Option<Gc<Node>>,
+}
+
+impl DoublyLinkedList {
+    fn new() -> Self {
+        Self { head: None, tail: None }
+    }
+
+    fn push(&mut self, value: String) {
+        match &self.tail {
+            None => {
+                let node = Gc::new(Node {
+                    prev: GcCell::new(None),
+                    next: GcCell::new(None),
+                    value,
+                });
+                self.head = Some(node.clone());
+                self.tail = Some(node);
+            }
+            Some(tail) => {
+                let node = Gc::new(Node {
+                    prev: GcCell::new(Some(tail.clone())),
+                    next: GcCell::new(None),
+                    value,
+                });
+                *tail.next.borrow_mut() = Some(node.clone());
+                self.tail = Some(node);
+            }
+        }
+    }
+
+    fn iterate_forward(&self, mut f: impl FnMut(&str)) {
+        let mut p = self.head.clone();
+        while let Some(node) = p {
+            f(&node.value);
+            p = node.next.borrow().clone();
+        }
+    }
+
+    fn iterate_backward(&self, mut f: impl FnMut(&str)) {
+        let mut p = self.tail.clone();
+        while let Some(node) = p {
+            f(&node.value);
+            p = node.prev.borrow().clone();
+        }
+    }
+}
+
+fn main() {
+    let mut list = DoublyLinkedList::new();
+
+    for value in &vec!["foo", "bar", "fizz", "buzz"] {
+        list.push(value.to_string());
+    }
+
+    println!("Iterate forward:");
+    list.iterate_forward(|value| println!("  {}", value));
+
+    println!("Iterate backward:");
+    list.iterate_backward(|value| println!("  {}", value));
+}