edn -> dsl

dsl/src/context.rs

@@ -0,0 +1,130 @@
+use crate::*;
+pub trait TryFromAtom<'a, T>: Sized {
+    fn try_from_expr (_state: &'a T, _iter: TokenIter<'a>) -> Option<Self> { None }
+    fn try_from_atom (state: &'a T, value: Value<'a>) -> Option<Self> {
+        if let Exp(0, iter) = value { return Self::try_from_expr(state, iter) }
+        None
+    }
+}
+pub trait TryIntoAtom<T>: Sized {
+    fn try_into_atom (&self) -> Option<Value>;
+}
+/// Map EDN tokens to parameters of a given type for a given context
+pub trait Context<U>: Sized {
+    fn get (&self, _atom: &Value) -> Option<U> {
+        None
+    }
+    fn get_or_fail (&self, atom: &Value) -> U {
+        self.get(atom).expect("no value")
+    }
+}
+impl<T: Context<U>, U> Context<U> for &T {
+    fn get (&self, atom: &Value) -> Option<U> {
+        (*self).get(atom)
+    }
+    fn get_or_fail (&self, atom: &Value) -> U {
+        (*self).get_or_fail(atom)
+    }
+}
+impl<T: Context<U>, U> Context<U> for Option<T> {
+    fn get (&self, atom: &Value) -> Option<U> {
+        self.as_ref().map(|s|s.get(atom)).flatten()
+    }
+    fn get_or_fail (&self, atom: &Value) -> U {
+        self.as_ref().map(|s|s.get_or_fail(atom)).expect("no provider")
+    }
+}
+/// Implement `Context` for a context and type.
+#[macro_export] macro_rules! provide {
+    // Provide a value to the EDN template
+    ($type:ty:|$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
+        impl Context<$type> for $State {
+            #[allow(unreachable_code)]
+            fn get (&$self, atom: &Value) -> Option<$type> {
+                use Value::*;
+                Some(match atom { $(Sym($pat) => $expr,)* _ => return None })
+            }
+        }
+    };
+    // Provide a value more generically
+    ($lt:lifetime: $type:ty:|$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
+        impl<$lt> Context<$lt, $type> for $State {
+            #[allow(unreachable_code)]
+            fn get (&$lt $self, atom: &Value) -> Option<$type> {
+                use Value::*;
+                Some(match atom { $(Sym($pat) => $expr,)* _ => return None })
+            }
+        }
+    };
+}
+/// Implement `Context` for a context and numeric type.
+///
+/// This enables support for numeric literals.
+#[macro_export] macro_rules! provide_num {
+    // Provide a value that may also be a numeric literal in the EDN, to a generic implementation.
+    ($type:ty:|$self:ident:<$T:ident:$Trait:path>|{ $($pat:pat => $expr:expr),* $(,)? }) => {
+        impl<$T: $Trait> Context<$type> for $T {
+            fn get (&$self, atom: &Value) -> Option<$type> {
+                use Value::*;
+                Some(match atom { $(Sym($pat) => $expr,)* Num(n) => *n as $type, _ => return None })
+            }
+        }
+    };
+    // Provide a value that may also be a numeric literal in the EDN, to a concrete implementation.
+    ($type:ty:|$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
+        impl Context<$type> for $State {
+            fn get (&$self, atom: &Value) -> Option<$type> {
+                use Value::*;
+                Some(match atom { $(Sym($pat) => $expr,)* Num(n) => *n as $type, _ => return None })
+            }
+        }
+    };
+}
+/// Implement `Context` for a context and the boolean type.
+///
+/// This enables support for boolean literals.
+#[macro_export] macro_rules! provide_bool {
+    // Provide a value that may also be a numeric literal in the EDN, to a generic implementation.
+    ($type:ty:|$self:ident:<$T:ident:$Trait:path>|{ $($pat:pat => $expr:expr),* $(,)? }) => {
+        impl<$T: $Trait> Context<$type> for $T {
+            fn get (&$self, atom: &Value) -> Option<$type> {
+                use Value::*;
+                Some(match atom {
+                    Num(n) => match *n { 0 => false, _ => true },
+                    Sym(":false") | Sym(":f") => false,
+                    Sym(":true")  | Sym(":t") => true,
+                    $(Sym($pat) => $expr,)*
+                    _ => return Context::get(self, atom)
+                })
+            }
+        }
+    };
+    // Provide a value that may also be a numeric literal in the EDN, to a concrete implementation.
+    ($type:ty:|$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
+        impl Context<$type> for $State {
+            fn get (&$self, atom: &Value) -> Option<$type> {
+                use Value::*;
+                Some(match atom {
+                    Num(n) => match *n { 0 => false, _ => true },
+                    Sym(":false") | Sym(":f") => false,
+                    Sym(":true")  | Sym(":t") => true,
+                    $(Sym($pat) => $expr,)*
+                    _ => return None
+                })
+            }
+        }
+    };
+}
+#[cfg(test)] #[test] fn test_edn_context () {
+    struct Test;
+    provide_bool!(bool: |self: Test|{
+        ":provide-bool" => true
+    });
+    let test = Test;
+    assert_eq!(test.get(&Value::Sym(":false")),        Some(false));
+    assert_eq!(test.get(&Value::Sym(":true")),         Some(true));
+    assert_eq!(test.get(&Value::Sym(":provide-bool")), Some(true));
+    assert_eq!(test.get(&Value::Sym(":missing-bool")), None);
+    assert_eq!(test.get(&Value::Num(0)), Some(false));
+    assert_eq!(test.get(&Value::Num(1)), Some(true));
+}