wip: overcomplicating it on the way to simplifying it ultimately

edn/src/context.rs

@@ -0,0 +1,101 @@
+use crate::*;
+/// Map EDN tokens to parameters of a given type for a given context
+pub trait Context<U>: Sized {
+    fn get (&self, _atom: &impl Atom) -> Option<U> {
+        None
+    }
+    fn get_or_fail (&self, atom: &impl Atom) -> U {
+        self.get(atom).expect("no value")
+    }
+}
+impl<T: Context<U>, U> Context<U> for &T {
+    fn get (&self, atom: &impl Atom) -> Option<U> {
+        (*self).get(atom)
+    }
+    fn get_or_fail (&self, atom: &impl Atom) -> U {
+        (*self).get_or_fail(atom)
+    }
+}
+impl<T: Context<U>, U> Context<U> for Option<T> {
+    fn get (&self, atom: &impl Atom) -> Option<U> {
+        self.as_ref().map(|s|s.get(atom)).flatten()
+    }
+    fn get_or_fail (&self, atom: &impl Atom) -> 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 {
+            fn get (&$self, atom: &impl Atom) -> Option<$type> {
+                Some(match (atom.kind(), atom.text()) {
+                    $((TokenKind::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 {
+            fn get (&$lt $self, atom: &impl Atom) -> Option<$type> {
+                Some(match (atom.kind(), atom.text()) {
+                    $((TokenKind::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: &impl Atom) -> Option<$type> {
+                Some(match (atom.kind(), atom.text()) {
+                    $((TokenKind::Sym, $pat) => $expr,)*
+                    (TokenKind::Num, _) => atom.num() 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: &impl Atom) -> Option<$type> {
+                Some(match (atom.kind(), atom.text()) {
+                    $((TokenKind::Sym, $pat) => $expr,)*
+                    (TokenKind::Num, _) => atom.num() as $type,
+                    _ => return None
+                })
+            }
+        }
+    };
+}
+/// Implement `Context` for a context and content type.
+///
+/// This enables support for layout expressions.
+#[macro_export] macro_rules! provide_content {
+    (|$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
+        impl<'a, E: Output> Context<'a, Box<dyn Render<E> + 'a>> for $State {
+            fn get (&'a $self, atom: &'a impl Atom) -> Option<Box<dyn Render<E> + 'a>> {
+                use RefAtom::*;
+                Some(match atom.to_ref() { $(RefAtom::Sym($pat) => $expr),*, _ => return None })
+            }
+        }
+    };
+    ($Output:ty: |$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
+        impl<'a> Context<'a, Box<dyn Render<$Output> + 'a>> for $State {
+            fn get (&'a $self, atom: &'a impl Atom) -> Option<Box<dyn Render<$Output> + 'a>> {
+                use RefAtom::*;
+                Some(match atom.to_ref() { $(Sym($pat) => $expr),*, _ => return None })
+            }
+        }
+    }
+}