parser2

src/parser/tree/node.rs

@@ -0,0 +1,63 @@
+use super::*;
+
+pub struct Node<T> {
+    pub data: Option<T>,
+}
+
+pub type BNode<T> = Box<Node<T>>;
+
+pub enum ParseResult<T> {
+    Ok(T),
+    Node(Node<T>),
+    Continue(CompilerMsg),
+    Break(CompilerMsg),
+    SubErr,
+}
+
+pub trait Parsable: Sized {
+    type Data = ();
+    fn parse(ctx: &mut ParserCtx, data: Self::Data) -> ParseResult<Self>;
+}
+
+impl<T> Node<T> {
+    pub fn bx(self) -> Box<Self> {
+        Box::new(self)
+    }
+    pub fn map<U>(self, f: impl FnOnce(T) -> U) -> Node<U> {
+        Node {
+            data: self.data.map(f),
+        }
+    }
+}
+
+use std::convert::Infallible;
+impl<T> std::ops::FromResidual<Option<Infallible>> for ParseResult<T> {
+    fn from_residual(residual: Option<Infallible>) -> Self {
+        match residual {
+            None => ParseResult::SubErr,
+        }
+    }
+}
+impl<T> std::ops::FromResidual<Result<Infallible, CompilerMsg>> for ParseResult<T> {
+    fn from_residual(residual: Result<Infallible, CompilerMsg>) -> Self {
+        match residual {
+            Err(msg) => ParseResult::Break(msg),
+        }
+    }
+}
+
+impl CompilerMsg {
+    pub fn res<T>(self) -> ParseResult<T> {
+        ParseResult::Break(self)
+    }
+}
+
+impl<T: std::fmt::Debug> std::fmt::Debug for Node<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(d) = &self.data {
+            d.fmt(f)
+        } else {
+            f.write_str("{error}")
+        }
+    }
+}