wip: fix(dsl): maybe getting somewhere?

input/src/input_dsl.rs

@@ -5,51 +5,77 @@ use crate::*;
 /// Each contained layer defines a mapping from input event to command invocation
 /// over a given state. Furthermore, each layer may have an associated condition,
 /// so that only certain layers are active at a given time depending on state.
-#[derive(Default, Debug)] pub struct InputLayers(Vec<InputLayer>);
-
+#[derive(Debug)] pub struct InputLayers<T: Dsl>(Vec<InputLayer<T>>);
 /// A single input binding layer.
-#[derive(Default, Debug)] struct InputLayer { condition: Option<Ast>, bindings: Ast, }
+#[derive(Default, Debug)] struct InputLayer<T: Dsl> {
+    condition: Option<DslVal<T::Str, T::Exp>>,
+    bindings:  DslVal<T::Str, T::Exp>,
+}
+/// Input layers start out empty regardless if `T` implements [Default].
+impl<T: Dsl> Default for InputLayers<T> { fn default () -> Self { Self(vec![]) } }
+/// Bring up an input layer map from a string representation.
+impl<'s> From<&'s str> for InputLayers<Ast> {
+    fn from (source: &'s str) -> Self {
+        let mut layers = vec![];
+        let mut source = CstIter::from(source);
+        while let Some(cst) = source.next() {
+            panic!("{:?}", cst.value);
+            layers.push(match cst.value.exp_head().map(|x|x.as_key()).flatten() {
+                Some("layer") => InputLayer {
+                    condition: None,
+                    bindings:  dsl_val(source.nth(1).unwrap()),
+                },
+                Some("layer-if") => InputLayer {
+                    condition: Some(dsl_val(source.nth(1).unwrap())),
+                    bindings:  dsl_val(source.nth(2).unwrap()),
+                },
+                _ => panic!("this shoulda been a TryFrom"),
+            });
+        }
+        Self(layers)
+    }
+}
 
-impl InputLayers {
+impl<T: Dsl> InputLayers<T> {
     /// Create an input map with a single non-conditional layer.
     /// (Use [Default::default] to get an empty map.)
-    pub fn new (layer: Ast) -> Self {
+    pub fn new (layer: DslVal<T::Str, T::Exp>) -> Self {
         Self::default().layer(layer)
     }
     /// Add layer, return `Self`.
-    pub fn layer (mut self, layer: Ast) -> Self {
+    pub fn layer (mut self, layer: DslVal<T::Str, T::Exp>) -> Self {
         self.add_layer(layer); self
     }
     /// Add conditional layer, return `Self`.
-    pub fn layer_if (mut self, condition: Ast, layer: Ast) -> Self {
+    pub fn layer_if (mut self, condition: DslVal<T::Str, T::Exp>, layer: DslVal<T::Str, T::Exp>) -> Self {
         self.add_layer_if(Some(condition), layer); self
     }
     /// Add layer, return `&mut Self`.
-    pub fn add_layer (&mut self, layer: Ast) -> &mut Self {
+    pub fn add_layer (&mut self, layer: DslVal<T::Str, T::Exp>) -> &mut Self {
         self.add_layer_if(None, layer.into()); self
     }
     /// Add conditional layer, return `&mut Self`.
-    pub fn add_layer_if (&mut self, condition: Option<Ast>, bindings: Ast) -> &mut Self {
+    pub fn add_layer_if (&mut self, condition: Option<DslVal<T::Str, T::Exp>>, bindings: DslVal<T::Str, T::Exp>) -> &mut Self {
         self.0.push(InputLayer { condition, bindings });
         self
     }
     /// Evaluate the active layers for a given state,
     /// returning the command to be executed, if any.
     pub fn handle <S, I, O> (&self, state: &mut S, input: I) -> Perhaps<O> where
-        S: Eval<Ast, bool> + Eval<Ast, O>,
-        I: Eval<Ast, bool>,
+        S: DslInto<bool> + DslInto<O>,
+        I: DslInto<bool>,
         O: Command<S>
     {
         let layers = self.0.as_slice();
         for InputLayer { condition, bindings } in layers.iter() {
             let mut matches = true;
             if let Some(condition) = condition {
-                matches = state.eval(condition.clone(), ||"input: no condition")?;
+                matches = state.dsl_into(condition, ||format!("input: no condition").into())?;
             }
             if matches
-            && let Some(exp) = bindings.0.exp_head()
-            && input.eval(Ast(exp.clone()), ||"InputLayers: input.eval(binding) failed")?
-            && let Some(command) = state.try_eval(exp)? {
+            && let Some(exp) = bindings.val().exp_head()
+            && input.dsl_into(exp, ||format!("InputLayers: input.eval(binding) failed").into())?
+            && let Some(command) = state.try_dsl_into(exp)? {
                 return Ok(Some(command))
             }
         }