wip: ast/cst

output/src/ops_dsl.rs

@@ -0,0 +1,185 @@
+use crate::*;
+
+impl<I: Ast, S, A> Eval<I, When<A>> for S where
+    S: Eval<AstValue, bool> + Eval<AstValue, A>
+{
+    fn eval (&self, source: I) -> Perhaps<Self> {
+        Ok(match source.peek() {
+            Some(Value::Key("when")) => Some(Self(
+                self.provide(source, ||"when: expected condition")?,
+                self.provide(source, ||"when: expected content")?,
+            )),
+            _ => None
+        })
+    }
+}
+
+impl<I: Ast, S, A, B> Eval<I, Either<A, B>> for S where
+    S: Eval<AstValue, bool> + Eval<AstValue, A> + Eval<AstValue, B>
+{
+    fn eval (&self, source: I) -> Perhaps<Self> {
+        Ok(match source.peek() {
+            Some(Value::Key("either")) => Some(Self(
+                self.provide(source, ||"either: expected condition")?,
+                self.provide(source, ||"either: expected content 1")?,
+                self.provide(source, ||"either: expected content 2")?
+            )),
+            _ => None
+        })
+    }
+}
+
+impl<I: Ast, S, A, B> Eval<I, Bsp<A, B>> for S where
+    S: Eval<AstValue, A> + Eval<AstValue, B>
+{
+    fn eval (&self, source: I) -> Perhaps<Self> {
+        Ok(if let Some(Value::Key(key)) = source.peek() {
+            Some(match key {
+                "bsp/n" => {
+                    let _ = source.next();
+                    let a: A = self.provide(source, ||"bsp/n: expected content 1")?;
+                    let b: B = self.provide(source, ||"bsp/n: expected content 2")?;
+                    Self::n(a, b)
+                },
+                "bsp/s" => {
+                    let _ = source.next();
+                    let a: A = self.provide(source, ||"bsp/s: expected content 1")?;
+                    let b: B = self.provide(source, ||"bsp/s: expected content 2")?;
+                    Self::s(a, b)
+                },
+                "bsp/e" => {
+                    let _ = source.next();
+                    let a: A = self.provide(source, ||"bsp/e: expected content 1")?;
+                    let b: B = self.provide(source, ||"bsp/e: expected content 2")?;
+                    Self::e(a, b)
+                },
+                "bsp/w" => {
+                    let _ = source.next();
+                    let a: A = self.provide(source, ||"bsp/w: expected content 1")?;
+                    let b: B = self.provide(source, ||"bsp/w: expected content 2")?;
+                    Self::w(a, b)
+                },
+                "bsp/a" => {
+                    let _ = source.next();
+                    let a: A = self.provide(source, ||"bsp/a: expected content 1")?;
+                    let b: B = self.provide(source, ||"bsp/a: expected content 2")?;
+                    Self::a(a, b)
+                },
+                "bsp/b" => {
+                    let _ = source.next();
+                    let a: A = self.provide(source, ||"bsp/b: expected content 1")?;
+                    let b: B = self.provide(source, ||"bsp/b: expected content 2")?;
+                    Self::b(a, b)
+                },
+                _ => return Ok(None),
+            })
+        } else {
+            None
+        })
+    }
+}
+
+impl<I: Ast, S, A> Eval<I, Align<A>> for S where
+    S: Eval<AstValue, A>
+{
+    fn eval (&self, source: I) -> Perhaps<Self> {
+        Ok(if let Some(Value::Key(key)) = source.peek() {
+            Some(match key {
+                "align/c"  => {
+                    let _ = source.next();
+                    let content: A = self.provide(source, ||"align/c: expected content")?;
+                    Self::c(content)
+                },
+                "align/x"  => {
+                    let _ = source.next();
+                    let content: A = self.provide(source, ||"align/x: expected content")?;
+                    Self::x(content)
+                },
+                "align/y"  => {
+                    let _ = source.next();
+                    let content: A = self.provide(source, ||"align/y: expected content")?;
+                    Self::y(content)
+                },
+                "align/n"  => {
+                    let _ = source.next();
+                    let content: A = self.provide(source, ||"align/n: expected content")?;
+                    Self::n(content)
+                },
+                "align/s"  => {
+                    let _ = source.next();
+                    let content: A = self.provide(source, ||"align/s: expected content")?;
+                    Self::s(content)
+                },
+                "align/e"  => {
+                    let _ = source.next();
+                    let content: A = self.provide(source, ||"align/e: expected content")?;
+                    Self::e(content)
+                },
+                "align/w"  => {
+                    let _ = source.next();
+                    let content: A = self.provide(source, ||"align/w: expected content")?;
+                    Self::w(content)
+                },
+                "align/nw" => {
+                    let _ = source.next();
+                    let content: A = self.provide(source, ||"align/nw: expected content")?;
+                    Self::nw(content)
+                },
+                "align/ne" => {
+                    let _ = source.next();
+                    let content: A = self.provide(source, ||"align/ne: expected content")?;
+                    Self::ne(content)
+                },
+                "align/sw" => {
+                    let _ = source.next();
+                    let content: A = self.provide(source, ||"align/sw: expected content")?;
+                    Self::sw(content)
+                },
+                "align/se" => {
+                    let _ = source.next();
+                    let content: A = self.provide(source, ||"align/se: expected content")?;
+                    Self::se(content)
+                },
+                _ => return Ok(None),
+            })
+        } else {
+            None
+        })
+    }
+}
+
+        //#[cfg(feature = "dsl")] take!($Enum<A>, A|state, words|Ok(
+            //if let Some(Token { value: Value::Key(k), .. }) = words.peek() {
+                //let mut base = words.clone();
+                //let content = state.give_or_fail(words, ||format!("{k}: no content"))?;
+                //return Ok(Some(match words.next() {
+                    //Some(Token{value: Value::Key($x),..})  => Self::x(content),
+                    //Some(Token{value: Value::Key($y),..})  => Self::y(content),
+                    //Some(Token{value: Value::Key($xy),..}) => Self::xy(content),
+                    //_ => unreachable!()
+                //}))
+            //} else {
+                //None
+            //}));
+        //#[cfg(feature = "dsl")] take!($Enum<U, A>, U, A|state, words|Ok(
+            //if let Some(Token { value: Value::Key($x|$y|$xy), .. }) = words.peek() {
+                //let mut base = words.clone();
+                //Some(match words.next() {
+                    //Some(Token { value: Value::Key($x), .. }) => Self::x(
+                        //state.give_or_fail(words, ||"x: no unit")?,
+                        //state.give_or_fail(words, ||"x: no content")?,
+                    //),
+                    //Some(Token { value: Value::Key($y), .. }) => Self::y(
+                        //state.give_or_fail(words, ||"y: no unit")?,
+                        //state.give_or_fail(words, ||"y: no content")?,
+                    //),
+                    //Some(Token { value: Value::Key($x), .. }) => Self::xy(
+                        //state.give_or_fail(words, ||"xy: no unit x")?,
+                        //state.give_or_fail(words, ||"xy: no unit y")?,
+                        //state.give_or_fail(words, ||"xy: no content")?
+                    //),
+                    //_ => unreachable!(),
+                //})
+            //} else {
+                //None
+            //}));