dsl: use only Dsl trait

output/src/view.rs

@@ -8,15 +8,15 @@ use crate::*;
             fn content (&$self) -> impl Render<$Output> { $expr }
         }
         impl<'a> ViewContext<'a, $Output> for $State {
-            fn get_content_sym (&'a $self, value: &Value<'a>) -> Option<RenderBox<'a, $Output>> {
-                if let Value::Sym(s) = value {
+            fn get_content_sym (&'a $self, iter: &Value<'a>) -> Perhaps<RenderBox<'a, $Output>> {
+                Ok(if let Value::Sym(s) = value {
                     match *s {
                         $($sym => Some($body.boxed()),)*
                         _ => None
                     }
                 } else {
-                    panic!("expected content, got: {value:?}")
-                }
+                    return Err(format!("expected content, got: {iter:?}").into())
+                })
             }
         }
     }
@@ -34,9 +34,11 @@ pub struct View<'a, T>(
 impl<'a, O: Output + 'a, T: ViewContext<'a, O>> Content<O> for View<'a, T> {
     fn content (&self) -> impl Render<O> {
         let mut iter = self.1.clone();
-        while let Some(Token { value, .. }) = iter.next() {
-            if let Some(content) = self.0.get_content(&value) {
+        while let Some(Token { value, .. }) = iter.peek() {
+            if let Ok(Some(content)) = self.0.get_content(&mut iter) {
                 return Some(content)
+                // TODO handle errors here, how?
+                // error receiver trait in viewcontext?
             }
         }
         return None
@@ -46,69 +48,61 @@ impl<'a, O: Output + 'a, T: ViewContext<'a, O>> Content<O> for View<'a, T> {
 // Provides components to the view.
 #[cfg(feature = "dsl")]
 pub trait ViewContext<'state, E: Output + 'state>: Send + Sync
-    + Context<'state, bool>
-    + Context<'state, usize>
-    + Context<'state, E::Unit>
+    + Dsl<bool>
+    + Dsl<usize>
+    + Dsl<E::Unit>
 {
-    fn get_content <'source: 'state> (&'state self, value: &Value<'source>) -> Option<RenderBox<'state, E>> {
-        match value {
-            Value::Sym(_) => self.get_content_sym(value),
-            Value::Exp(_, _) => self.get_content_exp(value),
-            _ => panic!("only :symbols and (expressions) accepted here, got: {value:?}")
+    fn get_content_or_fail <'source: 'state> (&'state self, iter: &mut TokenIter<'source>) 
+        -> Usually<RenderBox<'state, E>>
+    {
+        let base = iter.clone();
+        if let Some(content) = self.get_content(iter)? {
+            Ok(content)
+        } else {
+            Err(format!("not found: {iter:?}").into())
         }
     }
-    fn get_content_sym <'source: 'state> (&'state self, value: &Value<'source>)
-        -> Option<RenderBox<'state, E>>;
-    fn get_content_exp <'source: 'state> (&'state self, value: &Value<'source>)
-        -> Option<RenderBox<'state, E>>
+    fn get_content <'source: 'state> (&'state self, iter: &mut TokenIter<'source>) 
+        -> Perhaps<RenderBox<'state, E>>
     {
-        try_delegate!(self, *value, When::<RenderBox<'state, E>>);
-        try_delegate!(self, *value, Either::<RenderBox<'state, E>, RenderBox<'state, E>>);
-        try_delegate!(self, *value, Align::<RenderBox<'state, E>>);
-        try_delegate!(self, *value, Bsp::<RenderBox<'state, E>, RenderBox<'state, E>>);
-        try_delegate!(self, *value, Fill::<RenderBox<'state, E>>);
-        try_delegate!(self, *value, Fixed::<_, RenderBox<'state, E>>);
-        try_delegate!(self, *value, Min::<_, RenderBox<'state, E>>);
-        try_delegate!(self, *value, Max::<_, RenderBox<'state, E>>);
-        try_delegate!(self, *value, Shrink::<_, RenderBox<'state, E>>);
-        try_delegate!(self, *value, Expand::<_, RenderBox<'state, E>>);
-        try_delegate!(self, *value, Push::<_, RenderBox<'state, E>>);
-        try_delegate!(self, *value, Pull::<_, RenderBox<'state, E>>);
-        try_delegate!(self, *value, Margin::<_, RenderBox<'state, E>>);
-        try_delegate!(self, *value, Padding::<_, RenderBox<'state, E>>);
-        None
+        match iter.peek() {
+            Some(Token { value: Value::Sym(_), .. }) =>
+                self.get_content_sym(iter),
+            Some(Token { value: Value::Exp(_, _), .. }) =>
+                self.get_content_exp(iter),
+            None => Ok(None),
+            _ => panic!("only :symbols and (expressions) accepted here")
+        }
+    }
+    fn get_content_sym <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
+        -> Perhaps<RenderBox<'state, E>>;
+    fn get_content_exp <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
+        -> Perhaps<RenderBox<'state, E>>
+    {
+        try_delegate!(self, iter, When::<RenderBox<'state, E>>);
+        try_delegate!(self, iter, Either::<RenderBox<'state, E>, RenderBox<'state, E>>);
+        try_delegate!(self, iter, Align::<RenderBox<'state, E>>);
+        try_delegate!(self, iter, Bsp::<RenderBox<'state, E>, RenderBox<'state, E>>);
+        try_delegate!(self, iter, Fill::<RenderBox<'state, E>>);
+        try_delegate!(self, iter, Fixed::<_, RenderBox<'state, E>>);
+        try_delegate!(self, iter, Min::<_, RenderBox<'state, E>>);
+        try_delegate!(self, iter, Max::<_, RenderBox<'state, E>>);
+        try_delegate!(self, iter, Shrink::<_, RenderBox<'state, E>>);
+        try_delegate!(self, iter, Expand::<_, RenderBox<'state, E>>);
+        try_delegate!(self, iter, Push::<_, RenderBox<'state, E>>);
+        try_delegate!(self, iter, Pull::<_, RenderBox<'state, E>>);
+        try_delegate!(self, iter, Margin::<_, RenderBox<'state, E>>);
+        try_delegate!(self, iter, Padding::<_, RenderBox<'state, E>>);
+        Ok(None)
     }
 }
 
 #[cfg(feature = "dsl")]
 #[macro_export] macro_rules! try_delegate {
     ($s:ident, $dsl:expr, $T:ty) => {
-        if let Some(value) = <$T>::try_from_atom($s, $dsl) {
-            return Some(value.boxed())
-        }
-    }
-}
-
-#[cfg(feature = "dsl")]
-#[macro_export] macro_rules! try_from_expr {
-    (<
-        $lt_source:lifetime,
-        $lt_state:lifetime,
-        $Output:ident
-    >: $Struct:ty: |$state:ident, $iter:ident|$body:expr) => {
-        impl<
-            $lt_state,
-            $Output: Output + $lt_state,
-            T: ViewContext<$lt_state, $Output>
-        > TryFromDsl<$lt_state, T> for $Struct {
-            fn try_from_expr <$lt_source: $lt_state> (
-                $state: &$lt_state T,
-                $iter: &mut TokenIter<$lt_source>
-            ) -> Option<Self> {
-                let mut $iter = $iter.clone();
-                $body;
-                None
-            }
+        let value: Option<$T> = FromDsl::take_from($s, $dsl)?;
+        if let Some(value) = value {
+            return Ok(Some(value.boxed()))
         }
     }
 }