wip: dsl refactor

dsl/src/dsl_ns.rs

@@ -0,0 +1,70 @@
+use crate::*;
+
+/// Define a symbol namespace.
+#[macro_export] macro_rules! dsl_sym_ns (
+    (|$state:ident:$State:ty| -> $type:ty {$($lit:literal => $exp:expr),* $(,)?})=>{
+        impl<'t> DslSymNs<'t, $type> for $State {
+            const SYMS: DslNs<'t, fn (&'t $State)->$type> = DslNs(&[
+                $(($lit, |$state: &$State|$exp)),*
+            ]);
+        }
+    });
+
+/// Define an expression namespace.
+#[macro_export] macro_rules! dsl_exp_ns (
+    (|$state:ident:$State:ty|->$type:ty { $( (
+        $key:literal
+        $(/ $sub:ident : $Sub:ty)?
+        $(, $arg:ident $(?)? : $argtype:ty)*
+        $(, ..$tail:ident)?
+    ) => $body:expr),* $(,)? }) => {
+        impl<'t> DslExpNs<'t, fn (&'t $State, &str)->$type> for $State {
+            const EXPS: DslNs<'t, fn (&'t $State, &str)->$type> = DslNs(&[ $(
+                ($key, |$state: &$State, mut tail: &str|{
+                    $(let $arg = dsl_next(&mut tail)?;)*
+                    $(let $tail = tail;)?
+                    $body
+                })
+            ),* ]);
+        }
+    });
+
+/// Namespace where keys are symbols.
+pub trait DslSymNs<'t, T: 't>: 't {
+    const SYMS: DslNs<'t, fn (&'t Self)->T> = DslNs(&[]);
+    fn from_sym <D: Dsl> (&'t self, dsl: D) -> Perhaps<T> {
+        if let Some(dsl) = dsl.sym()? {
+            for (sym, get) in Self::SYMS.0 {
+                if dsl == *sym {
+                    return Ok(Some(get(self)))
+                }
+            }
+        }
+        return Ok(None)
+    }
+}
+
+/// Namespace where the keys are heads of expressions.
+pub trait DslExpNs<'t, T: 't>: 't {
+    const EXPS: DslNs<'t, fn (&'t Self, &str)->T> = DslNs(&[]);
+    fn from_exp <D: Dsl> (&'t self, dsl: D) -> Perhaps<T> {
+        if let Some(exp) = dsl.exp()? {
+            panic!("exp\n{:?}\n{:?}\n{:?}\n{:?}", exp.src(), exp.head(), exp.head().src(), Self::EXPS.0);
+            for (key, value) in Self::EXPS.0.iter() {
+                println!("{key} {:?}", exp.head());
+                if exp.head() == Ok(Some(key)) {
+                    return Ok(Some(value(self, exp.tail()?.unwrap_or(""))))
+                }
+            }
+        }
+        return Ok(None)
+    }
+}
+
+/// Namespace.
+///
+/// Currently linearly searched.
+/// Maybe it's better to use a trie.
+/// I don't think there's a `const` trie in Rust?
+/// Oughtta be.
+pub struct DslNs<'t, T: 't>(pub &'t [(&'t str, T)]);