wip: fix(dsl): maybe getting somewhere?

input/src/input_dsl.rs

@@ -5,51 +5,52 @@ 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>>);
+impl<T: Dsl> Default for InputLayers<T> { fn default () -> Self { Self(vec![]) } }
 
 /// A single input binding layer.
-#[derive(Default, Debug)] struct InputLayer { condition: Option<Ast>, bindings: Ast, }
+#[derive(Default, Debug)] struct InputLayer<T: Dsl> { condition: Option<T>, bindings: T, }
 
-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: T) -> Self {
         Self::default().layer(layer)
     }
     /// Add layer, return `Self`.
-    pub fn layer (mut self, layer: Ast) -> Self {
+    pub fn layer (mut self, layer: T) -> 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: T, layer: T) -> 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: T) -> &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<T>, bindings: T) -> &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))
             }
         }