dsl/src/dsl_parse.rs

@@ -171,3 +171,112 @@ pub const fn to_digit (c: char) -> DslResult<usize> {
         _ => return Result::Err(Unexpected(c))
     })
 }
+
+#[derive(Debug, Copy, Clone, Default, PartialEq)] pub struct Token<'source> {
+    pub source: &'source str,
+    pub start:  usize,
+    pub length: usize,
+    pub value:  Value<'source>,
+}
+
+#[derive(Debug, Copy, Clone, Default, PartialEq)] pub enum Value<'source> {
+    #[default] Nil,
+    Err(DslError),
+    Num(usize),
+    Sym(&'source str),
+    Key(&'source str),
+    Str(&'source str),
+    Exp(usize, TokenIter<'source>),
+}
+
+impl<'source> std::fmt::Display for Value<'source> {
+    fn fmt (&self, out: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        write!(out, "{}", match self {
+            Nil    => String::new(),
+            Err(e) => format!("[error: {e}]"),
+            Num(n) => format!("{n}"),
+            Sym(s) => format!("{s}"),
+            Key(s) => format!("{s}"),
+            Str(s) => format!("{s}"),
+            Exp(_, e) => format!("{e:?}"),
+        })
+    }
+}
+
+impl<'source> Token<'source> {
+    pub const fn new (
+        source: &'source str, start: usize, length: usize, value: Value<'source>
+    ) -> Self {
+        Self { source, start, length, value }
+    }
+    pub const fn end (&self) -> usize {
+        self.start.saturating_add(self.length)
+    }
+    pub const fn slice (&'source self) -> &'source str {
+        self.slice_source(self.source)
+    }
+    pub const fn slice_source <'range> (&'source self, source: &'range str) -> &'range str {
+        str_range(source, self.start, self.end())
+    }
+    pub const fn slice_source_exp <'range> (&'source self, source: &'range str) -> &'range str {
+        str_range(source, self.start.saturating_add(1), self.end())
+    }
+    pub const fn with_value (self, value: Value<'source>) -> Self {
+        Self { value, ..self }
+    }
+    pub const fn value (&self) -> Value {
+        self.value
+    }
+    pub const fn error (self, error: DslError) -> Self {
+        Self { value: Value::Err(error), ..self }
+    }
+    pub const fn grow (self) -> Self {
+        Self { length: self.length.saturating_add(1), ..self }
+    }
+    pub const fn grow_num (self, m: usize, c: char) -> Self {
+        match to_digit(c) {
+            Ok(n) => Self { value: Num(10*m+n), ..self.grow() },
+            Result::Err(e) => Self { value: Err(e), ..self.grow() },
+        }
+    }
+    pub const fn grow_key (self) -> Self {
+        let token = self.grow();
+        token.with_value(Key(token.slice_source(self.source)))
+    }
+    pub const fn grow_sym (self) -> Self {
+        let token = self.grow();
+        token.with_value(Sym(token.slice_source(self.source)))
+    }
+    pub const fn grow_str (self) -> Self {
+        let token = self.grow();
+        token.with_value(Str(token.slice_source(self.source)))
+    }
+    pub const fn grow_exp (self) -> Self {
+        let token = self.grow();
+        if let Exp(depth, _) = token.value {
+            token.with_value(Exp(depth, TokenIter::new(token.slice_source_exp(self.source))))
+        } else {
+            unreachable!()
+        }
+    }
+    pub const fn grow_in (self) -> Self {
+        let token = self.grow_exp();
+        if let Value::Exp(depth, source) = token.value {
+            token.with_value(Value::Exp(depth.saturating_add(1), source))
+        } else {
+            unreachable!()
+        }
+    }
+    pub const fn grow_out (self) -> Self {
+        let token = self.grow_exp();
+        if let Value::Exp(depth, source) = token.value {
+            if depth > 0 {
+                token.with_value(Value::Exp(depth - 1, source))
+            } else {
+                return self.error(Unexpected(')'))
+            }
+        } else {
+            unreachable!()
+        }
+    }
+}

dsl/src/dsl_provide.rs

@@ -1,27 +1,45 @@
 use crate::*;
 
-pub trait Dsl<Other>: Sized {
+/// Implement the [Dsl] trait, which boils down to
-    fn take <'state, 'source: 'state> (
+/// specifying two types and providing an expression.
-        &'state self,
+#[macro_export] macro_rules! dsl {
-        token: &mut TokenIter<'source>
+    ($T:ty: |$self:ident:$S:ty, $iter:ident|$expr:expr) => {
-    )
+        impl ::tengri::dsl::Dsl<$T> for $S {
-        -> Perhaps<Other>;
+            fn take <'state, 'source> (
-    fn take_or_fail <'state, 'source: 'state> (
+                &'state $self, $iter: &mut ::tengri::dsl::TokenIter<'source>,
+            ) -> ::tengri::Perhaps<$T> {
+                $expr
+            }
+        }
+    }
+}
+
+/// Maps a sequencer of EDN tokens to parameters of supported types
+/// for a given context.
+pub trait Dsl<Value>: Sized {
+    fn take <'state, 'source> (&'state self, _: &mut TokenIter<'source>) -> Perhaps<Value> {
+        unimplemented!()
+    }
+    fn take_or_fail <'state, 'source> (
         &'state self,
         token: &mut TokenIter<'source>,
         error: impl Into<Box<dyn std::error::Error>>
-    ) -> Usually<Other> {
+    ) -> Usually<Value> {
-        if let Some(value) = Dsl::<Other>::take(self, token)? {
+        if let Some(value) = Dsl::<Value>::take(self, token)? {
             Ok(value)
         } else {
             Result::Err(error.into())
         }
     }
 }
-pub trait FromDsl<'source, State>: Sized {
+
-    fn take_from <'state> (state: &'state State, token: &mut TokenIter<'source>)
+pub trait FromDsl<'state, State>: Sized {
-        -> Perhaps<Self>;
+    fn take_from <'source: 'state> (state: &'state State, _token: &mut TokenIter<'source>)
-    fn take_from_or_fail <'state> (
+        -> Perhaps<Self>
+    {
+        unimplemented!()
+    }
+    fn take_from_or_fail <'source: 'state> (
         state: &'state State,
         token: &mut TokenIter<'source>,
         error: impl Into<Box<dyn std::error::Error>>
@@ -33,67 +51,6 @@ pub trait FromDsl<'source, State>: Sized {
         }
     }
 }
-//impl<State: Dsl<T>, T> FromDsl<State> for T {
-    //fn take_from <'state, 'source: 'state> (state: &'state State, token: &mut TokenIter<'source>)
-        //-> Perhaps<Self>
-    //{
-        //Dsl::take(state, token)
-    //}
-//}
-
-/// Implement the [Dsl] trait, which boils down to
-/// specifying two types and providing an expression.
-#[macro_export] macro_rules! from_dsl {
-    (@a: $T:ty: |$state:ident, $words:ident|$expr:expr) => {
-        impl<'source, State: Dsl<A>, A> FromDsl<'source, State> for $T {
-            fn take_from <'state> (
-                $state: &'state State,
-                $words: &mut TokenIter<'source>,
-            ) -> Perhaps<$T> {
-                $expr
-            }
-        }
-    };
-    (@ab: $T:ty: |$state:ident, $words:ident|$expr:expr) => {
-        impl<'source, State: Dsl<A> + Dsl<B>, A, B> FromDsl<'source, State> for $T {
-            fn take_from <'state> (
-                $state: &'state State,
-                $words: &mut TokenIter<'source>,
-            ) -> Perhaps<$T> {
-                $expr
-            }
-        }
-    };
-    ($T:ty: |$state:ident:$S:ty, $words:ident|$expr:expr) => {
-        impl<'source> FromDsl<'source, $S> for $T {
-            fn take_from <'state> (
-                $state: &'state $S,
-                $words: &mut TokenIter<'source>,
-            ) -> Perhaps<$T> {
-                $expr
-            }
-        }
-    };
-}
-
-///// Maps a sequencer of EDN tokens to parameters of supported types
-///// for a given context.
-//pub trait Dsl<Value>: Sized {
-    //fn take <'state, 'source> (&'state self, _: &mut TokenIter<'source>) -> Perhaps<Value> {
-        //unimplemented!()
-    //}
-    //fn take_or_fail <'state, 'source> (
-        //&'state self,
-        //token: &mut TokenIter<'source>,
-        //error: impl Into<Box<dyn std::error::Error>>
-    //) -> Usually<Value> {
-        //if let Some(value) = Dsl::<Value>::take(self, token)? {
-            //Ok(value)
-        //} else {
-            //Result::Err(error.into())
-        //}
-    //}
-//}
 
 //impl<T: Dsl<U>, U> Dsl<U> for &T {
     //fn take <'state, 'source> (&'state self, iter: &mut TokenIter<'source>) -> Perhaps<U> {
@@ -107,8 +64,8 @@ pub trait FromDsl<'source, State>: Sized {
     //}
 //}
 
-//impl<'state, X, Y> Dsl<X> for Y where Y: Dsl<'state, X> {
+impl<'state, X, Y> Dsl<X> for Y where Y: FromDsl<'state, X> {
-//}
+}
 
-//impl<T, U: Dsl<T>> Dsl<U> for T {
+//impl<T, U: FromDsl<T>> Dsl<U> for T {
 //}

dsl/src/dsl_token.rs

@@ -1,110 +0,0 @@
-use crate::*;
-
-#[derive(Debug, Copy, Clone, Default, PartialEq)] pub struct Token<'source> {
-    pub source: &'source str,
-    pub start:  usize,
-    pub length: usize,
-    pub value:  Value<'source>,
-}
-
-#[derive(Debug, Copy, Clone, Default, PartialEq)] pub enum Value<'source> {
-    #[default] Nil,
-    Err(DslError),
-    Num(usize),
-    Sym(&'source str),
-    Key(&'source str),
-    Str(&'source str),
-    Exp(usize, TokenIter<'source>),
-}
-
-impl<'source> std::fmt::Display for Value<'source> {
-    fn fmt (&self, out: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-        write!(out, "{}", match self {
-            Nil    => String::new(),
-            Err(e) => format!("[error: {e}]"),
-            Num(n) => format!("{n}"),
-            Sym(s) => format!("{s}"),
-            Key(s) => format!("{s}"),
-            Str(s) => format!("{s}"),
-            Exp(_, e) => format!("{e:?}"),
-        })
-    }
-}
-
-impl<'source> Token<'source> {
-    pub const fn new (
-        source: &'source str, start: usize, length: usize, value: Value<'source>
-    ) -> Self {
-        Self { source, start, length, value }
-    }
-    pub const fn end (&self) -> usize {
-        self.start.saturating_add(self.length)
-    }
-    pub const fn slice (&'source self) -> &'source str {
-        self.slice_source(self.source)
-    }
-    pub const fn slice_source <'range> (&'source self, source: &'range str) -> &'range str {
-        str_range(source, self.start, self.end())
-    }
-    pub const fn slice_source_exp <'range> (&'source self, source: &'range str) -> &'range str {
-        str_range(source, self.start.saturating_add(1), self.end())
-    }
-    pub const fn with_value (self, value: Value<'source>) -> Self {
-        Self { value, ..self }
-    }
-    pub const fn value (&self) -> Value {
-        self.value
-    }
-    pub const fn error (self, error: DslError) -> Self {
-        Self { value: Value::Err(error), ..self }
-    }
-    pub const fn grow (self) -> Self {
-        Self { length: self.length.saturating_add(1), ..self }
-    }
-    pub const fn grow_num (self, m: usize, c: char) -> Self {
-        match to_digit(c) {
-            Ok(n) => Self { value: Num(10*m+n), ..self.grow() },
-            Result::Err(e) => Self { value: Err(e), ..self.grow() },
-        }
-    }
-    pub const fn grow_key (self) -> Self {
-        let token = self.grow();
-        token.with_value(Key(token.slice_source(self.source)))
-    }
-    pub const fn grow_sym (self) -> Self {
-        let token = self.grow();
-        token.with_value(Sym(token.slice_source(self.source)))
-    }
-    pub const fn grow_str (self) -> Self {
-        let token = self.grow();
-        token.with_value(Str(token.slice_source(self.source)))
-    }
-    pub const fn grow_exp (self) -> Self {
-        let token = self.grow();
-        if let Exp(depth, _) = token.value {
-            token.with_value(Exp(depth, TokenIter::new(token.slice_source_exp(self.source))))
-        } else {
-            unreachable!()
-        }
-    }
-    pub const fn grow_in (self) -> Self {
-        let token = self.grow_exp();
-        if let Value::Exp(depth, source) = token.value {
-            token.with_value(Value::Exp(depth.saturating_add(1), source))
-        } else {
-            unreachable!()
-        }
-    }
-    pub const fn grow_out (self) -> Self {
-        let token = self.grow_exp();
-        if let Value::Exp(depth, source) = token.value {
-            if depth > 0 {
-                token.with_value(Value::Exp(depth - 1, source))
-            } else {
-                return self.error(Unexpected(')'))
-            }
-        } else {
-            unreachable!()
-        }
-    }
-}

dsl/src/lib.rs

@@ -46,7 +46,6 @@ pub(crate) use self::Value::*;
 pub(crate) use self::DslError::*;
 
 mod dsl_error;   pub use self::dsl_error::*;
-mod dsl_token;   pub use self::dsl_token::*;
 mod dsl_parse;   pub use self::dsl_parse::*;
 mod dsl_provide; pub use self::dsl_provide::*;
 

input/src/input_dsl.rs

@@ -5,15 +5,13 @@ use std::marker::PhantomData;
 pub trait DslInput: Input { fn matches_dsl (&self, token: &str) -> bool; }
 
 /// A pre-configured mapping of input events to commands.
-pub trait KeyMap<'source, S, C: FromDsl<'source, S> + Command<S>, I: DslInput> {
+pub trait KeyMap<S: Dsl<C>, C: Command<S>, I: DslInput> {
     /// Try to find a command that matches the current input event.
     fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C>;
 }
 
 /// A [SourceIter] can be a [KeyMap].
-impl<'source, S, C: FromDsl<'source, S> + Command<S>, I: DslInput>
+impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for SourceIter<'source> {
-KeyMap<'source, S, C, I>
-for SourceIter<'source> {
     fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
         let mut iter = self.clone();
         while let Some((token, rest)) = iter.next() {
@@ -24,7 +22,7 @@ for SourceIter<'source> {
                     match exp_iter.next() {
                         Some(Token { value: Value::Sym(binding), .. }) => {
                             if input.matches_dsl(binding) {
-                                if let Some(command) = FromDsl::take_from(state, &mut exp_iter)? {
+                                if let Some(command) = Dsl::<C>::take(state, &mut exp_iter)? {
                                     return Ok(Some(command))
                                 }
                             }
@@ -40,9 +38,7 @@ for SourceIter<'source> {
 }
 
 /// A [TokenIter] can be a [KeyMap].
-impl<'source, S, C: FromDsl<'source, S> + Command<S>, I: DslInput>
+impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for TokenIter<'source> {
-KeyMap<'source, S, C, I>
-for TokenIter<'source> {
     fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
         let mut iter = self.clone();
         while let Some(next) = iter.next() {
@@ -52,7 +48,7 @@ for TokenIter<'source> {
                     match e.next() {
                         Some(Token { value: Value::Sym(binding), .. }) => {
                             if input.matches_dsl(binding) {
-                                if let Some(command) = FromDsl::take_from(state, &mut e)? {
+                                if let Some(command) = Dsl::<C>::take(state, &mut e)? {
                                     return Ok(Some(command))
                                 }
                             }
@@ -67,37 +63,25 @@ for TokenIter<'source> {
     }
 }
 
-pub type InputLayerCond<'source, S> = Box<dyn Fn(&S)->Usually<bool> + 'source>;
+pub type InputLayerCond<S> = Box<dyn Fn(&S)->Usually<bool> + Send + Sync>;
 
 /// A collection of pre-configured mappings of input events to commands,
 /// which may be made available subject to given conditions.
-pub struct InputMap<'source,
+pub struct InputMap<S, C, I, M>
-    S,
+where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
-    C: Command<S> + FromDsl<'source, S>,
+    __: PhantomData<(S, C, I)>,
-    I: DslInput,
+    pub layers: Vec<(InputLayerCond<S>, M)>,
-    M: KeyMap<'source, S, C, I>
-> {
-    __: PhantomData<&'source (S, C, I)>,
-    pub layers: Vec<(InputLayerCond<'source, S>, M)>,
 }
 
-impl<'source,
+impl<S, C, I, M> Default for InputMap<S, C, I, M>
-    S,
+where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
-    C: Command<S> + FromDsl<'source, S>,
-    I: DslInput,
-    M: KeyMap<'source, S, C, I>
-> Default for InputMap<'source, S, C, I, M>{
     fn default () -> Self {
         Self { __: PhantomData, layers: vec![] }
     }
 }
 
-impl<'source,
+impl<S, C, I, M> InputMap<S, C, I, M>
-    S,
+where S: Dsl<C> + 'static, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
-    C: Command<S> + FromDsl<'source, S>,
-    I: DslInput,
-    M: KeyMap<'source, S, C, I>
-> InputMap<'source, S, C, I, M> {
     pub fn new (keymap: M) -> Self {
         Self::default().layer(keymap)
     }
@@ -109,34 +93,26 @@ impl<'source,
         self.add_layer_if(Box::new(|_|Ok(true)), keymap);
         self
     }
-    pub fn layer_if (mut self, condition: InputLayerCond<'source, S>, keymap: M) -> Self {
+    pub fn layer_if (mut self, condition: InputLayerCond<S>, keymap: M) -> Self {
         self.add_layer_if(condition, keymap);
         self
     }
-    pub fn add_layer_if (&mut self, condition: InputLayerCond<'source, S>, keymap: M) -> &mut Self {
+    pub fn add_layer_if (&mut self, condition: InputLayerCond<S>, keymap: M) -> &mut Self {
         self.layers.push((Box::new(condition), keymap));
         self
     }
 }
 
-impl<'source,
+impl<S, C, I, M> std::fmt::Debug for InputMap<S, C, I, M>
-    S,
+where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
-    C: Command<S> + FromDsl<'source, S>,
-    I: DslInput,
-    M: KeyMap<'source, S, C, I>
-> std::fmt::Debug for InputMap<'source, S, C, I, M> {
     fn fmt (&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         write!(f, "[InputMap: {} layer(s)]", self.layers.len())
     }
 }
 
 /// An [InputMap] can be a [KeyMap].
-impl<'source,
+impl<S, C, I, M> KeyMap<S, C, I> for InputMap<S, C, I, M>
-    S,
+where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
-    C: Command<S> + FromDsl<'source, S>,
-    I: DslInput,
-    M: KeyMap<'source, S, C, I>
-> KeyMap<'source, S, C, I> for InputMap<'source, S, C, I, M> {
     fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
         for (condition, keymap) in self.layers.iter() {
             if !condition(state)? {

input/src/input_handle.rs

@@ -2,7 +2,7 @@ use crate::*;
 use std::sync::{Mutex, Arc, RwLock};
 
 /// Event source
-pub trait Input: Sized {
+pub trait Input: Send + Sync + Sized {
     /// Type of input event
     type Event;
     /// Result of handling input
@@ -36,7 +36,7 @@ pub trait Input: Sized {
 }
 
 /// Handle input
-pub trait Handle<E: Input> {
+pub trait Handle<E: Input>: Send + Sync {
     fn handle (&mut self, _input: &E) -> Perhaps<E::Handled> {
         Ok(None)
     }

output/src/ops/align.rs

@@ -36,33 +36,42 @@ pub enum Alignment { #[default] Center, X, Y, NW, N, NE, E, SE, S, SW, W }
 pub struct Align<A>(Alignment, A);
 
 #[cfg(feature = "dsl")]
-from_dsl!(@a: Align<A>: |state, iter|if let Some(Token { value: Value::Key(key), .. }) = iter.peek() {
+impl<'state, E: Output + 'state, T: ViewContext<'state, E>>
-    match key {
+FromDsl<'state, T> for Align<RenderBox<'state, E>> {
-        "align/c"|"align/x"|"align/y"|
+    fn take_from <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
-        "align/n"|"align/s"|"align/e"|"align/w"|
+        if let Some(Token { value: Value::Key(key), .. }) = iter.peek() {
-        "align/nw"|"align/sw"|"align/ne"|"align/se" => {
+            match key {
-            let _ = iter.next().unwrap();
+                "align/c"|"align/x"|"align/y"|
-            let content = state.take_or_fail(&mut iter.clone(), "expected content")?;
+                "align/n"|"align/s"|"align/e"|"align/w"|
-            return Ok(Some(match key {
+                "align/nw"|"align/sw"|"align/ne"|"align/se" => {
-                "align/c"  => Self::c(content),
+                    let _ = iter.next().unwrap();
-                "align/x"  => Self::x(content),
+                    let content = if let Some(content) = state.get_content(&mut iter.clone())? {
-                "align/y"  => Self::y(content),
+                        content
-                "align/n"  => Self::n(content),
+                    } else {
-                "align/s"  => Self::s(content),
+                        panic!("no content corresponding to {:?}", &iter);
-                "align/e"  => Self::e(content),
+                    };
-                "align/w"  => Self::w(content),
+                    return Ok(Some(match key {
-                "align/nw" => Self::nw(content),
+                        "align/c"  => Self::c(content),
-                "align/ne" => Self::ne(content),
+                        "align/x"  => Self::x(content),
-                "align/sw" => Self::sw(content),
+                        "align/y"  => Self::y(content),
-                "align/se" => Self::se(content),
+                        "align/n"  => Self::n(content),
-                _ => unreachable!()
+                        "align/s"  => Self::s(content),
-            }))
+                        "align/e"  => Self::e(content),
-        },
+                        "align/w"  => Self::w(content),
-        _ => return Ok(None)
+                        "align/nw" => Self::nw(content),
+                        "align/ne" => Self::ne(content),
+                        "align/sw" => Self::sw(content),
+                        "align/se" => Self::se(content),
+                        _ => unreachable!()
+                    }))
+                },
+                _ => return Ok(None)
+            }
+        } else {
+            Ok(None)
+        }
     }
-} else {
+}
-    Ok(None)
-});
 
 impl<A> Align<A> {
     #[inline] pub const fn c  (a: A) -> Self { Self(Alignment::Center, a) }
@@ -79,7 +88,7 @@ impl<A> Align<A> {
 }
 
 impl<E: Output, A: Content<E>> Content<E> for Align<A> {
-    fn content (&self) -> impl Render<E> + '_ {
+    fn content (&self) -> impl Render<E> {
         &self.1
     }
     fn layout (&self, on: E::Area) -> E::Area {

output/src/ops/bsp.rs

@@ -21,35 +21,40 @@ impl<E: Output, A: Content<E>, B: Content<E>> Content<E> for Bsp<A, B> {
     }
 }
 #[cfg(feature = "dsl")]
-from_dsl!(@ab: Bsp<A, B>: |state, iter|Ok(if let Some(Token {
+impl<'state, E: Output + 'state, T: ViewContext<'state, E>>
-    value: Value::Key("bsp/n"|"bsp/s"|"bsp/e"|"bsp/w"|"bsp/a"|"bsp/b"),
+FromDsl<'state, T> for Bsp<RenderBox<'state, E>, RenderBox<'state, E>> {
-    ..
+    fn take_from <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
-}) = iter.peek() {
+        Ok(if let Some(Token {
-    let base = iter.clone();
+            value: Value::Key("bsp/n"|"bsp/s"|"bsp/e"|"bsp/w"|"bsp/a"|"bsp/b"),
-    return Ok(Some(match iter.next() {
+            ..
-        Some(Token { value: Value::Key("bsp/n"), .. }) =>
+        }) = iter.peek() {
-            Self::n(state.take_or_fail(iter, "expected content 1")?,
+            let base = iter.clone();
-                    state.take_or_fail(iter, "expected content 2")?),
+            return Ok(Some(match iter.next() {
-        Some(Token { value: Value::Key("bsp/s"), .. }) =>
+                Some(Token { value: Value::Key("bsp/n"), .. }) =>
-            Self::s(state.take_or_fail(iter, "expected content 1")?,
+                    Self::n(state.get_content_or_fail(iter)?,
-                    state.take_or_fail(iter, "expected content 2")?),
+                            state.get_content_or_fail(iter)?),
-        Some(Token { value: Value::Key("bsp/e"), .. }) =>
+                Some(Token { value: Value::Key("bsp/s"), .. }) =>
-            Self::e(state.take_or_fail(iter, "expected content 1")?,
+                    Self::s(state.get_content_or_fail(iter)?,
-                    state.take_or_fail(iter, "expected content 2")?),
+                            state.get_content_or_fail(iter)?),
-        Some(Token { value: Value::Key("bsp/w"), .. }) =>
+                Some(Token { value: Value::Key("bsp/e"), .. }) =>
-            Self::w(state.take_or_fail(iter, "expected content 1")?,
+                    Self::e(state.get_content_or_fail(iter)?,
-                    state.take_or_fail(iter, "expected content 2")?),
+                            state.get_content_or_fail(iter)?),
-        Some(Token { value: Value::Key("bsp/a"), .. }) =>
+                Some(Token { value: Value::Key("bsp/w"), .. }) =>
-            Self::a(state.take_or_fail(iter, "expected content 1")?,
+                    Self::w(state.get_content_or_fail(iter)?,
-                    state.take_or_fail(iter, "expected content 2")?),
+                            state.get_content_or_fail(iter)?),
-        Some(Token { value: Value::Key("bsp/b"), .. }) =>
+                Some(Token { value: Value::Key("bsp/a"), .. }) =>
-            Self::b(state.take_or_fail(iter, "expected content 1")?,
+                    Self::a(state.get_content_or_fail(iter)?,
-                    state.take_or_fail(iter, "expected content 2")?),
+                            state.get_content_or_fail(iter)?),
-        _ => unreachable!(),
+                Some(Token { value: Value::Key("bsp/b"), .. }) =>
-    }))
+                    Self::b(state.get_content_or_fail(iter)?,
-} else {
+                            state.get_content_or_fail(iter)?),
-    None
+                _ => unreachable!(),
-}));
+            }))
+        } else {
+            None
+        })
+    }
+}
 impl<A, B> Bsp<A, B> {
     #[inline] pub const fn n (a: A, b: B) -> Self { Self(North, a, b) }
     #[inline] pub const fn s (a: A, b: B) -> Self { Self(South, a, b) }

output/src/ops/cond.rs

@@ -17,26 +17,44 @@ impl<A, B> Either<A, B> {
         Self(c, a, b) 
     }
 }
+
 #[cfg(feature = "dsl")]
-impl<'source, A, T: Dsl<bool> + Dsl<A>> FromDsl<'source, T> for When<A> {
+impl<'state, E: Output + 'state, T: ViewContext<'state, E>>
-    fn take_from <'state> (
+FromDsl<'state, T> for When<RenderBox<'state, E>> {
-        state: &'state T,
+    fn take_from <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
-        token: &mut TokenIter<'source>
-    ) -> Perhaps<Self> {
         Ok(if let Some(Token {
             value: Value::Key("when"),
             ..
-        }) = token.peek() {
+        }) = iter.peek() {
-            let base = token.clone();
+            let base = iter.clone();
             return Ok(Some(Self(
-                state.take_or_fail(token, "cond: no condition")?,
+                state.take(iter)?.unwrap_or_else(||panic!("cond: no condition: {base:?}")),
-                state.take_or_fail(token, "cond: no content")?,
+                state.get_content_or_fail(iter)?
             )))
         } else {
             None
         })
     }
 }
+
+#[cfg(feature = "dsl")]
+impl<'state, E: Output + 'state, T: ViewContext<'state, E>>
+FromDsl<'state, T> for Either<RenderBox<'state, E>, RenderBox<'state, E>> {
+    fn take_from <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
+        if let Some(Token { value: Value::Key("either"), .. }) = iter.peek() {
+            let base = iter.clone();
+            let _ = iter.next().unwrap();
+            //panic!("{iter:?}");
+            return Ok(Some(Self(
+                state.take(iter)?.unwrap_or_else(||panic!("either: no condition: {base:?}")),
+                state.get_content_or_fail(iter)?,
+                state.get_content_or_fail(iter)?,
+            )))
+        }
+        Ok(None)
+    }
+}
+
 impl<E: Output, A: Render<E>> Content<E> for When<A> {
     fn layout (&self, to: E::Area) -> E::Area {
         let Self(cond, item) = self;
@@ -55,24 +73,7 @@ impl<E: Output, A: Render<E>> Content<E> for When<A> {
         if *cond { item.render(to) }
     }
 }
-#[cfg(feature = "dsl")]
+
-impl<'source, A, B, T: Dsl<bool> + Dsl<A> + Dsl<B>> FromDsl<'source, T> for Either<A, B> {
-    fn take_from <'state> (
-        state: &'state T,
-        token: &mut TokenIter<'source>
-    ) -> Perhaps<Self> {
-        if let Some(Token { value: Value::Key("either"), .. }) = token.peek() {
-            let base = token.clone();
-            let _ = token.next().unwrap();
-            return Ok(Some(Self(
-                state.take_or_fail(token, "either: no condition")?,
-                state.take_or_fail(token, "either: no content 1")?,
-                state.take_or_fail(token, "either: no content 2")?,
-            )))
-        }
-        Ok(None)
-    }
-}
 impl<E: Output, A: Render<E>, B: Render<E>> Content<E> for Either<A, B> {
     fn layout (&self, to: E::Area) -> E::Area {
         let Self(cond, a, b) = self;

output/src/ops/stack.rs

@@ -1,5 +1,4 @@
 use crate::*;
-use Direction::*;
 
 pub struct Stack<E, F> {
     __: PhantomData<E>,
@@ -11,76 +10,68 @@ impl<E, F> Stack<E, F> {
         Self { direction, callback, __: Default::default(), }
     }
     pub fn north (callback: F) -> Self {
-        Self::new(North, callback)
+        Self::new(Direction::North, callback)
     }
     pub fn south (callback: F) -> Self {
-        Self::new(South, callback)
+        Self::new(Direction::South, callback)
     }
     pub fn east (callback: F) -> Self {
-        Self::new(East, callback)
+        Self::new(Direction::East, callback)
     }
     pub fn west (callback: F) -> Self {
-        Self::new(West, callback)
+        Self::new(Direction::West, callback)
     }
 }
 impl<E: Output, F: Fn(&mut dyn FnMut(&dyn Render<E>)->())->()> Content<E> for Stack<E, F> {
     fn layout (&self, mut to: E::Area) -> E::Area {
         let mut x = to.x();
         let mut y = to.y();
-        let (mut w_used, mut w_remaining) = (E::Unit::zero(), to.w());
+        let mut w = to.w();
-        let (mut h_used, mut h_remaining) = (E::Unit::zero(), to.h());
+        let mut h = to.h();
         (self.callback)(&mut move |component: &dyn Render<E>|{
-            let [_, _, w, h] = component.layout([x, y, w_remaining, h_remaining].into()).xywh();
+            let layout = component.layout([x, y, w, h].into());
             match self.direction {
-                South => {
+                Direction::North => {
-                    y           = y.plus(h);
+                    todo!()
-                    h_used      = h_used.plus(h);
-                    h_remaining = h_remaining.minus(h);
-                    w_used      = w_used.max(w);
                 },
-                East  => {
+                Direction::South => {
-                    x           = x.plus(w);
+                    y = y + layout.h();
-                    w_used      = w_used.plus(w);
+                    h = h.minus(layout.h());
-                    w_remaining = w_remaining.minus(w);
-                    h_used      = h_used.max(h);
                 },
-                North | West  => {
+                Direction::East  => {
+                    x = x + layout.w();
+                    w = w.minus(layout.w());
+                },
+                Direction::West  => {
                     todo!()
                 },
                 _ => unreachable!(),
             }
         });
-        match self.direction {
+        to
-            North | West => {
-                todo!()
-            },
-            South | East => {
-                [to.x(), to.y(), w_used.into(), h_used.into()].into()
-            },
-            _ => unreachable!(),
-        }
     }
     fn render (&self, to: &mut E) {
         let mut x = to.x();
         let mut y = to.y();
-        let (mut w_used, mut w_remaining) = (E::Unit::zero(), to.w());
+        let mut w = to.w();
-        let (mut h_used, mut h_remaining) = (E::Unit::zero(), to.h());
+        let mut h = to.h();
         (self.callback)(&mut move |component: &dyn Render<E>|{
-            let layout = component.layout([x, y, w_remaining, h_remaining].into());
+            let layout = component.layout([x, y, w, h].into());
             match self.direction {
-                South => {
+                Direction::North => {
-                    y           = y.plus(layout.h());
+                    todo!()
-                    h_remaining = h_remaining.minus(layout.h());
+                },
-                    h_used      = h_used.plus(layout.h());
+                Direction::South => {
+                    y = y + layout.h();
+                    h = h.minus(layout.h());
                     to.place(layout, component);
                 },
-                East => {
+                Direction::East  => {
-                    x           = x.plus(layout.w());
+                    x = x + layout.w();
-                    w_remaining = w_remaining.minus(layout.w());
+                    w = w.minus(layout.w());
-                    w_used      = w_used.plus(layout.h());
                     to.place(layout, component);
                 },
-                North | West  => {
+                Direction::West  => {
                     todo!()
                 },
                 _ => unreachable!()

output/src/ops/thunk.rs

@@ -2,67 +2,72 @@ use crate::*;
 use std::marker::PhantomData;
 
 /// Lazily-evaluated [Render]able.
-pub struct Thunk<E: Output, T: Render<E>, F: Fn()->T>(
+pub struct Thunk<E: Output, T: Render<E>, F: Fn()->T + Send + Sync>(
     PhantomData<E>,
     F
 );
-impl<E: Output, T: Render<E>, F: Fn()->T> Thunk<E, T, F> {
+impl<E: Output, T: Render<E>, F: Fn()->T + Send + Sync> Thunk<E, T, F> {
     pub const fn new (thunk: F) -> Self {
         Self(PhantomData, thunk)
     }
 }
-impl<E: Output, T: Render<E>, F: Fn()->T> Content<E> for Thunk<E, T, F> {
+impl<E: Output, T: Render<E>, F: Fn()->T + Send + Sync> Content<E> for Thunk<E, T, F> {
     fn content (&self) -> impl Render<E> { (self.1)() }
 }
 
-pub struct ThunkBox<E: Output>(
+pub struct ThunkBox<'a, E: Output>(
     PhantomData<E>,
-    Box<dyn Fn()->Box<dyn Render<E>>>,
+    Box<dyn Fn()->RenderBox<'a, E> + Send + Sync + 'a>
 );
-impl<E: Output> ThunkBox<E> {
+impl<'a, E: Output> ThunkBox<'a, E> {
-    pub const fn new (thunk: Box<dyn Fn()->Box<dyn Render<E>>>) -> Self {
+    pub const fn new (thunk: Box<dyn Fn()->RenderBox<'a, E> + Send + Sync + 'a>) -> Self {
         Self(PhantomData, thunk)
     }
 }
-impl<E: Output> Content<E> for ThunkBox<E> {
+impl<'a, E: Output> Content<E> for ThunkBox<'a, E> {
-    fn content (&self) -> impl Render<E> { (&self.1)() }
+    fn content (&self) -> impl Render<E> { (self.1)() }
 }
-impl<E: Output> From<Box<dyn Fn()->Box<dyn Render<E>>>> for ThunkBox<E> {
+impl<'a, E, F, T> From<F> for ThunkBox<'a, E>
-    fn from (f: Box<dyn Fn()->Box<dyn Render<E>>>) -> Self {
+where
-        Self(PhantomData, f)
+    E: Output,
+    F: Fn()->T + Send + Sync + 'a,
+    T: Render<E> + Send + Sync + 'a
+{
+    fn from (f: F) -> Self {
+        Self(PhantomData, Box::new(move||f().boxed()))
     }
 }
-//impl<'a, E: Output, F: Fn()->Box<dyn Render<E> + 'a> + 'a> From<F> for ThunkBox<'a, E> {
+//impl<'a, E: Output, F: Fn()->Box<dyn Render<E> + 'a> + Send + Sync + 'a> From<F> for ThunkBox<'a, E> {
     //fn from (f: F) -> Self {
         //Self(Default::default(), Box::new(f))
     //}
 //}
 
-pub struct ThunkRender<E: Output, F: Fn(&mut E)>(PhantomData<E>, F);
+pub struct ThunkRender<E: Output, F: Fn(&mut E) + Send + Sync>(PhantomData<E>, F);
-impl<E: Output, F: Fn(&mut E)> ThunkRender<E, F> {
+impl<E: Output, F: Fn(&mut E) + Send + Sync> ThunkRender<E, F> {
     pub fn new (render: F) -> Self { Self(PhantomData, render) }
 }
-impl<E: Output, F: Fn(&mut E)> Content<E> for ThunkRender<E, F> {
+impl<E: Output, F: Fn(&mut E) + Send + Sync> Content<E> for ThunkRender<E, F> {
     fn render (&self, to: &mut E) { (self.1)(to) }
 }
 
 pub struct ThunkLayout<
     E: Output,
-    F1: Fn(E::Area)->E::Area, 
+    F1: Fn(E::Area)->E::Area + Send + Sync, 
-    F2: Fn(&mut E)
+    F2: Fn(&mut E) + Send + Sync
 >(
     PhantomData<E>, 
     F1,
     F2
 );
-impl<E: Output, F1: Fn(E::Area)->E::Area, F2: Fn(&mut E)> ThunkLayout<E, F1, F2> {
+impl<E: Output, F1: Fn(E::Area)->E::Area + Send + Sync, F2: Fn(&mut E) + Send + Sync> ThunkLayout<E, F1, F2> {
     pub fn new (layout: F1, render: F2) -> Self { Self(PhantomData, layout, render) }
 }
 impl<E, F1, F2> Content<E> for ThunkLayout<E, F1, F2>
 where
     E:  Output,
-    F1: Fn(E::Area)->E::Area,
+    F1: Fn(E::Area)->E::Area + Send + Sync,
-    F2: Fn(&mut E)
+    F2: Fn(&mut E) + Send + Sync
 {
     fn layout (&self, to: E::Area) -> E::Area { (self.1)(to) }
     fn render (&self, to: &mut E) { (self.2)(to) }

output/src/ops/transform.rs

@@ -26,24 +26,31 @@ use crate::*;
 /// along either the X axis, the Y axis, or both.
 macro_rules! transform_xy {
     ($x:literal $y:literal $xy:literal |$self:ident : $Enum:ident, $to:ident|$area:expr) => {
-        pub enum $Enum<A> { X(A), Y(A), XY(A) }
+        pub enum $Enum<T> { X(T), Y(T), XY(T) }
-        impl<A> $Enum<A> {
+        impl<T> $Enum<T> {
-            #[inline] pub const fn x  (item: A) -> Self { Self::X(item)  }
+            #[inline] pub const fn x (item: T) -> Self {
-            #[inline] pub const fn y  (item: A) -> Self { Self::Y(item)  }
+                Self::X(item)
-            #[inline] pub const fn xy (item: A) -> Self { Self::XY(item) }
+            }
+            #[inline] pub const fn y (item: T) -> Self {
+                Self::Y(item)
+            }
+            #[inline] pub const fn xy (item: T) -> Self {
+                Self::XY(item)
+            }
         }
         #[cfg(feature = "dsl")]
-        impl<'source, A, T: Dsl<A>> FromDsl<'source, T> for $Enum<A> {
+        impl<'state, E: Output + 'state, T: ViewContext<'state, E>>
-            fn take_from <'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
+        FromDsl<'state, T> for $Enum<RenderBox<'state, E>> {
+            fn take_from <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
                 if let Some(Token { value: Value::Key(k), .. }) = iter.peek() {
                     let mut base = iter.clone();
                     return Ok(Some(match iter.next() {
                         Some(Token{value:Value::Key($x),..}) =>
-                            Self::x(state.take_or_fail(iter, "x: no content")?),
+                            Self::x(state.get_content_or_fail(iter)?),
                         Some(Token{value:Value::Key($y),..}) =>
-                            Self::y(state.take_or_fail(iter, "y: no content")?),
+                            Self::y(state.get_content_or_fail(iter)?),
                         Some(Token{value:Value::Key($xy),..}) =>
-                            Self::xy(state.take_or_fail(iter, "xy: no content")?),
+                            Self::xy(state.get_content_or_fail(iter)?),
                         _ => unreachable!()
                     }))
                 }
@@ -51,7 +58,7 @@ macro_rules! transform_xy {
             }
         }
         impl<E: Output, T: Content<E>> Content<E> for $Enum<T> {
-            fn content (&self) -> impl Render<E> + '_ {
+            fn content (&self) -> impl Render<E> {
                 match self {
                     Self::X(item)  => item,
                     Self::Y(item)  => item,
@@ -70,30 +77,31 @@ macro_rules! transform_xy {
 /// along either the X axis, the Y axis, or both.
 macro_rules! transform_xy_unit {
     ($x:literal $y:literal $xy:literal |$self:ident : $Enum:ident, $to:ident|$layout:expr) => {
-        pub enum $Enum<U, A> { X(U, A), Y(U, A), XY(U, U, A), }
+        pub enum $Enum<U, T> { X(U, T), Y(U, T), XY(U, U, T), }
-        impl<U, A> $Enum<U, A> {
+        impl<U, T> $Enum<U, T> {
-            #[inline] pub const fn x (x: U, item: A) -> Self { Self::X(x, item) }
+            #[inline] pub const fn x (x: U, item: T) -> Self { Self::X(x, item) }
-            #[inline] pub const fn y (y: U, item: A) -> Self { Self::Y(y, item) }
+            #[inline] pub const fn y (y: U, item: T) -> Self { Self::Y(y, item) }
-            #[inline] pub const fn xy (x: U, y: U, item: A) -> Self { Self::XY(x, y, item) }
+            #[inline] pub const fn xy (x: U, y: U, item: T) -> Self { Self::XY(x, y, item) }
         }
         #[cfg(feature = "dsl")]
-        impl<'source, A, U: Coordinate, T: Dsl<A> + Dsl<U>> FromDsl<'source, T> for $Enum<U, A> {
+        impl<'state, E: Output + 'state, T: ViewContext<'state, E>>
-            fn take_from <'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
+        FromDsl<'state, T> for $Enum<E::Unit, RenderBox<'state, E>> {
+            fn take_from <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
                 Ok(if let Some(Token { value: Value::Key($x|$y|$xy), .. }) = iter.peek() {
                     let mut base = iter.clone();
                     Some(match iter.next() {
                         Some(Token { value: Value::Key($x), .. }) => Self::x(
-                            state.take_or_fail(iter, "x: no unit")?,
+                            state.take_or_fail(iter, "no unit specified")?,
-                            state.take_or_fail(iter, "x: no content")?,
+                            state.get_content_or_fail(iter)?,
                         ),
                         Some(Token { value: Value::Key($y), .. }) => Self::y(
-                            state.take_or_fail(iter, "y: no unit")?,
+                            state.take_or_fail(iter, "no unit specified")?,
-                            state.take_or_fail(iter, "y: no content")?,
+                            state.get_content_or_fail(iter)?,
                         ),
                         Some(Token { value: Value::Key($x), .. }) => Self::xy(
-                            state.take_or_fail(iter, "xy: no unit x")?,
+                            state.take_or_fail(iter, "no unit specified")?,
-                            state.take_or_fail(iter, "xy: no unit y")?,
+                            state.take_or_fail(iter, "no unit specified")?,
-                            state.take_or_fail(iter, "xy: no content")?
+                            state.get_content_or_fail(iter)?
                         ),
                         _ => unreachable!(),
                     })
@@ -103,7 +111,7 @@ macro_rules! transform_xy_unit {
             }
         }
         impl<E: Output, T: Content<E>> Content<E> for $Enum<E::Unit, T> {
-            fn content (&self) -> impl Render<E> + '_ {
+            fn content (&self) -> impl Render<E> {
                 Some(match self {
                     Self::X(_, content) => content,
                     Self::Y(_, content) => content,

output/src/output.rs

@@ -29,8 +29,8 @@ pub trait Render<E: Output> {
     /// Write data to display.
     fn render (&self, output: &mut E);
     /// Perform type erasure, turning `self` into an opaque [RenderBox].
-    fn boxed <'a> (self) -> Box<dyn Render<E> + 'a> where Self: Sized + 'a {
+    fn boxed <'a> (self) -> RenderBox<'a, E> where Self: Send + Sync + Sized + 'a {
-        Box::new(self) as Box<dyn Render<E> + 'a>
+        Box::new(self) as RenderBox<'a, E>
     }
 }
 
@@ -47,20 +47,20 @@ impl<E: Output, C: Content<E>> Render<E> for C {
 /// Opaque pointer to a renderable living on the heap.
 ///
 /// Return this from [Content::content] to use dynamic dispatch.
-pub type RenderBox<E> = Box<RenderDyn<E>>;
+pub type RenderBox<'a, E> = Box<RenderDyn<'a, E>>;
 
 /// You can render from a box.
-impl<E: Output> Content<E> for RenderBox<E> {
+impl<'a, E: Output> Content<E> for RenderBox<'a, E> {
-    fn content (&self) -> impl Render<E> + '_ { self.deref() }
+    fn content (&self) -> impl Render<E> { self.deref() }
     //fn boxed <'b> (self) -> RenderBox<'b, E> where Self: Sized + 'b { self }
 }
 
 /// Opaque pointer to a renderable.
-pub type RenderDyn<E> = dyn Render<E>;
+pub type RenderDyn<'a, E> = dyn Render<E> + Send + Sync + 'a;
 
 /// You can render from an opaque pointer.
-impl<E: Output> Content<E> for &RenderDyn<E> where Self: Sized {
+impl<'a, E: Output> Content<E> for &RenderDyn<'a, E> where Self: Sized {
-    fn content (&self) -> impl Render<E> + '_ {
+    fn content (&self) -> impl Render<E> {
         #[allow(suspicious_double_ref_op)]
         self.deref()
     }
@@ -77,7 +77,7 @@ impl<E: Output> Content<E> for &RenderDyn<E> where Self: Sized {
 /// Composable renderable with static dispatch.
 pub trait Content<E: Output> {
     /// Return a [Render]able of a specific type.
-    fn content (&self) -> impl Render<E> + '_ { () }
+    fn content (&self) -> impl Render<E> { () }
     /// Perform layout. By default, delegates to [Self::content].
     fn layout (&self, area: E::Area) -> E::Area { self.content().layout(area) }
     /// Draw to output. By default, delegates to [Self::content].
@@ -86,7 +86,7 @@ pub trait Content<E: Output> {
 
 /// Every pointer to [Content] is a [Content].
 impl<E: Output, C: Content<E>> Content<E> for &C {
-    fn content (&self) -> impl Render<E> + '_ { (*self).content() }
+    fn content (&self) -> impl Render<E> { (*self).content() }
     fn layout (&self, area: E::Area) -> E::Area { (*self).layout(area) }
     fn render (&self, output: &mut E) { (*self).render(output) }
 }
@@ -98,7 +98,7 @@ impl<E: Output> Content<E> for () {
 }
 
 impl<E: Output, T: Content<E>> Content<E> for Option<T> {
-    fn content (&self) -> impl Render<E> + '_ {
+    fn content (&self) -> impl Render<E> {
         self.as_ref()
     }
     fn layout (&self, area: E::Area) -> E::Area {
@@ -117,7 +117,7 @@ impl<E: Output, T: Content<E>> Content<E> for Option<T> {
     // Implement for all [Output]s.
     (|$self:ident:$Struct:ty| $content:expr) => {
         impl<E: Output> Content<E> for $Struct {
-            fn content (&$self) -> impl Render<E> + '_ { Some($content) }
+            fn content (&$self) -> impl Render<E> { Some($content) }
         }
     };
     // Implement for specific [Output].
@@ -127,7 +127,7 @@ impl<E: Output, T: Content<E>> Content<E> for Option<T> {
     |$content:expr) => {
         impl $(<$($($L)? $($T)? $(:$Trait)?),+>)? Content<$Output>
         for $Struct $(<$($($L)? $($T)?),+>)? {
-            fn content (&$self) -> impl Render<$Output> + '_ { $content }
+            fn content (&$self) -> impl Render<$Output> { $content }
         }
     };
 }

output/src/view.rs

@@ -1,54 +1,63 @@
 use crate::*;
 
-//#[cfg(feature = "dsl")]
+#[cfg(feature = "dsl")]
-//#[macro_export] macro_rules! try_delegate {
+#[macro_export] macro_rules! try_delegate {
-    //($s:ident, $dsl:expr, $T:ty) => {
+    ($s:ident, $dsl:expr, $T:ty) => {
-        //let value: Option<$T> = Dsl::take_from($s, $dsl)?;
+        let value: Option<$T> = FromDsl::take_from($s, $dsl)?;
-        //if let Some(value) = value {
+        if let Some(value) = value {
-            //return Ok(Some(value.boxed()))
+            return Ok(Some(value.boxed()))
-        //}
+        }
-    //}
+    }
-//}
+}
 
-//// Provides components to the view.
+// Provides components to the view.
-//#[cfg(feature = "dsl")]
+#[cfg(feature = "dsl")]
-//pub trait ViewContext<'state, E: Output + 'state>:
+pub trait ViewContext<'state, E: Output + 'state>: Send + Sync
-    //FromDsl<bool> + FromDsl<usize> + FromDsl<E::Unit> + Send + Sync
+    + Dsl<bool>
-//{
+    + Dsl<usize>
-    //fn get_content_sym <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
+    + Dsl<E::Unit>
-        //-> Perhaps<RenderBox<'state, E>>;
+{
-    //fn get_content_exp <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
+    fn get_content_or_fail <'source: 'state> (&'state self, iter: &mut TokenIter<'source>) 
-        //-> Perhaps<RenderBox<'state, E>>
+        -> Usually<RenderBox<'state, E>>
-    //{
+    {
-        //try_delegate!(self, iter, When::<RenderBox<'state, E>>);
+        let base = iter.clone();
-        //try_delegate!(self, iter, Either::<RenderBox<'state, E>, RenderBox<'state, E>>);
+        if let Some(content) = self.get_content(iter)? {
-        //try_delegate!(self, iter, Align::<RenderBox<'state, E>>);
+            Ok(content)
-        //try_delegate!(self, iter, Bsp::<RenderBox<'state, E>, RenderBox<'state, E>>);
+        } else {
-        //try_delegate!(self, iter, Fill::<RenderBox<'state, E>>);
+            Err(format!("not found: {iter:?}").into())
-        //try_delegate!(self, iter, Fixed::<_, RenderBox<'state, E>>);
+        }
-        //try_delegate!(self, iter, Min::<_, RenderBox<'state, E>>);
+    }
-        //try_delegate!(self, iter, Max::<_, RenderBox<'state, E>>);
+    fn get_content <'source: 'state> (&'state self, iter: &mut TokenIter<'source>) 
-        //try_delegate!(self, iter, Shrink::<_, RenderBox<'state, E>>);
+        -> Perhaps<RenderBox<'state, E>>
-        //try_delegate!(self, iter, Expand::<_, RenderBox<'state, E>>);
+    {
-        //try_delegate!(self, iter, Push::<_, RenderBox<'state, E>>);
+        match iter.peek() {
-        //try_delegate!(self, iter, Pull::<_, RenderBox<'state, E>>);
+            Some(Token { value: Value::Sym(_), .. }) =>
-        //try_delegate!(self, iter, Margin::<_, RenderBox<'state, E>>);
+                self.get_content_sym(iter),
-        //try_delegate!(self, iter, Padding::<_, RenderBox<'state, E>>);
+            Some(Token { value: Value::Exp(_, _), .. }) =>
-        //Ok(None)
+                self.get_content_exp(iter),
-    //}
+            None => Ok(None),
-//}
+            _ => panic!("only :symbols and (expressions) accepted here")
-
+        }
-//#[cfg(feature = "dsl")]
+    }
-//impl<'context, O: Output + 'context, T: ViewContext<'context, O>> FromDsl<T> for RenderBox<'context, O> {
+    fn get_content_sym <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
-    //fn take_from <'state, 'source: 'state> (state: &'state T, token: &mut TokenIter<'source>)
+        -> Perhaps<RenderBox<'state, E>>;
-        //-> Perhaps<RenderBox<'context, O>>
+    fn get_content_exp <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
-    //{
+        -> Perhaps<RenderBox<'state, E>>
-        //Ok(if let Some(content) = state.get_content_sym(token)? {
+    {
-            //Some(content)
+        try_delegate!(self, iter, When::<RenderBox<'state, E>>);
-        //} else if let Some(content) = state.get_content_exp(token)? {
+        try_delegate!(self, iter, Either::<RenderBox<'state, E>, RenderBox<'state, E>>);
-            //Some(content)
+        try_delegate!(self, iter, Align::<RenderBox<'state, E>>);
-        //} else {
+        try_delegate!(self, iter, Bsp::<RenderBox<'state, E>, RenderBox<'state, E>>);
-            //None
+        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)
+    }
+}

proc/src/proc_command.rs

@@ -84,7 +84,7 @@ impl ToTokens for CommandDef {
                         let mut out = TokenStream2::new();
                         for (arg, ty) in arm.args() {
                             write_quote_to(&mut out, quote! {
-                                #arg: FromDsl::take_from_or_fail(self, words)?,
+                                #arg: Dsl::take_or_fail(self, words)?,
                             });
                         }
                         out
@@ -137,23 +137,19 @@ impl ToTokens for CommandDef {
             #[derive(Clone, Debug)] pub enum #command_enum { #(#variants)* }
             /// Not generated by [tengri_proc].
             #block
-            /// Generated by [tengri_proc::command].
+            /// Generated by [tengri_proc].
-            ///
-            /// Means [#command_enum] is now a [Command] over [#state].
-            /// Instances of [#command_enum] can be consumed by a 
-            /// mutable pointer to [#state], invoking predefined operations
-            /// and optionally returning undo history data.
             impl ::tengri::input::Command<#state> for #command_enum {
                 fn execute (self, state: &mut #state) -> Perhaps<Self> {
                     match self { #(#implementations)* }
                 }
             }
-            /// Generated by [tengri_proc::command].
+            /// Generated by [tengri_proc].
-            impl<'source> ::tengri::dsl::FromDsl<'source, #state> for #command_enum {
+            impl ::tengri::dsl::Dsl<#command_enum> for #state {
-                fn take_from <'state> (
+                fn take <'source, 'state> (
-                    state: &'state #state,
+                    &'state self, words: &mut TokenIter<'source>
-                    words: &mut ::tengri::dsl::TokenIter<'source>
+                )
-                ) -> Perhaps<Self> {
+                    -> ::tengri::Perhaps<#command_enum>
+                {
                     let mut words = words.clone();
                     let token = words.next();
                     todo!()//Ok(match token { #(#matchers)* _ => None })

proc/src/proc_expose.rs

@@ -60,7 +60,7 @@ impl ToTokens for ExposeDef {
 impl ToTokens for ExposeImpl {
     fn to_tokens (&self, out: &mut TokenStream2) {
         let Self(block, exposed) = self;
-        let state = &block.self_ty;
+        let target = &block.self_ty;
         write_quote_to(out, quote! { #block });
         for (t, variants) in exposed.iter() {
             let formatted_type = format!("{}", quote! { #t }); 
@@ -84,15 +84,14 @@ impl ToTokens for ExposeImpl {
             };
             let values = variants.iter().map(ExposeArm::from);
             write_quote_to(out, quote! {
-                /// Generated by [tengri_proc::expose].
+                /// Generated by [tengri_proc].
-                impl<'source> ::tengri::dsl::FromDsl<'source, #state> for #t {
+                impl ::tengri::dsl::Dsl<#t> for #target {
-                    fn take_from <'state> (
+                    fn take <'state, 'source> (
-                        state: &'state #state,
+                        &'state self, iter: &mut ::tengri::dsl::TokenIter<'source>
-                        words: &mut ::tengri::dsl::TokenIter<'source>
+                    ) -> Perhaps<#t> {
-                    ) -> Perhaps<Self> {
+                        Ok(Some(match iter.next().map(|x|x.value) {
-                        Ok(Some(match words.next().map(|x|x.value) {
                             #predefined
-                            #(#values)*
+                            #(#values,)*
                             _ => return Ok(None)
                         }))
                     }
@@ -116,7 +115,7 @@ impl ToTokens for ExposeArm {
         let Self(key, value) = self;
         let key = LitStr::new(&key, Span::call_site());
         write_quote_to(out, quote! {
-            Some(::tengri::dsl::Value::Sym(#key)) => state.#value(),
+            Some(::tengri::dsl::Value::Sym(#key)) => self.#value()
         })
     }
 }

proc/src/proc_view.rs

@@ -14,6 +14,8 @@ pub(crate) struct ViewImpl {
     exposed: BTreeMap<String, Ident>,
 }
 
+struct ViewArm(String, Ident);
+
 impl Parse for ViewMeta {
     fn parse (input: ParseStream) -> Result<Self> {
         Ok(Self {
@@ -44,70 +46,95 @@ impl ToTokens for ViewDef {
         let Self(ViewMeta { output }, ViewImpl { block, exposed }) = self;
         let view = &block.self_ty;
         let mut available = vec![];
-        let exposed: Vec<_> = exposed.iter().map(|(key, value)|{
+        let exposed: Vec<_> = exposed.iter().map(|(k,v)|{
-            available.push(key.clone());
+            available.push(k.clone());
-            write_quote(quote! { #key => Some(state.#value().boxed()), })
+            ViewArm(k.clone(), v.clone())
         }).collect();
         let available: String = available.join(", ");
         let error_msg = LitStr::new(
             &format!("expected Sym(content), got: {{token:?}}, available: {available}"),
             Span::call_site()
         );
-        write_quote_to(out, quote! {
+        for token in quote! {
             #block
             /// Generated by [tengri_proc].
-            ///
-            /// Delegates the rendering of [#view] to the [#view::view} method,
-            /// which you will need to implement, e.g. passing a [TokenIter]
-            /// containing a layout and keybindings config from user dirs.
             impl ::tengri::output::Content<#output> for #view {
                 fn content (&self) -> impl Render<#output> {
                     self.view()
                 }
             }
             /// Generated by [tengri_proc].
-            ///
+            impl<'state> ::tengri::dsl::FromDsl<'state, #view> for ::tengri::output::RenderBox<'state, #output> {
-            /// Gives [#view] the ability to construct the [Render]able
+                fn take_from <'source: 'state> (
-            /// which might corresponds to a given [TokenStream],
-            /// while taking [#view]'s state into consideration.
-            impl<'source> ::tengri::dsl::FromDsl<'source, #view> for Box<dyn Render<#output> + 'source> {
-                fn take_from <'state> (
                     state: &'state #view,
-                    words: &mut ::tengri::dsl::TokenIter<'source>,
+                    token: &mut ::tengri::dsl::TokenIter<'source>
                 ) -> Perhaps<Self> {
-                    Ok(words.peek().and_then(|::tengri::dsl::Token{ value, .. }|match value {
+                    Ok(match token.peek() { #(#exposed)* _ => None })
-                        ::tengri::dsl::Value::Exp(_, exp) => {
-                            todo!("builtin layout ops");
-                            //#builtins
-                            None
-                        },
-                        ::tengri::dsl::Value::Sym(sym) => match sym {
-                            #(#exposed)*
-                            _ => None
-                        },
-                        _ => None
-                    }))
                 }
             }
-        })
+        } {
+            out.append(token)
+        }
     }
 }
 
-fn builtins () -> [TokenStream2;14] {
+impl ToTokens for ViewArm {
-    [
+    fn to_tokens (&self, out: &mut TokenStream2) {
-        quote! { When::<A>       },
+        let Self(key, value) = self;
-        quote! { Either::<A, B>  },
+        out.append(Ident::new("Some", Span::call_site()));
-        quote! { Align::<A>      },
+        out.append(Group::new(Delimiter::Parenthesis, {
-        quote! { Bsp::<A, B>     },
+            let mut out = TokenStream2::new();
-        quote! { Fill::<A>       },
+            out.append(Punct::new(':', Joint));
-        quote! { Fixed::<_, A>   },
+            out.append(Punct::new(':', Alone));
-        quote! { Min::<_, A>     },
+            out.append(Ident::new("tengri", Span::call_site()));
-        quote! { Max::<_, A>     },
+            out.append(Punct::new(':', Joint));
-        quote! { Shrink::<_, A>  },
+            out.append(Punct::new(':', Alone));
-        quote! { Expand::<_, A>  },
+            out.append(Ident::new("dsl", Span::call_site()));
-        quote! { Push::<_, A>    },
+            out.append(Punct::new(':', Joint));
-        quote! { Pull::<_, A>    },
+            out.append(Punct::new(':', Alone));
-        quote! { Margin::<_, A>  },
+            out.append(Ident::new("Token", Span::call_site()));
-        quote! { Padding::<_, A> },
+            out.append(Group::new(Delimiter::Brace, {
-    ]
+                let mut out = TokenStream2::new();
+                out.append(Ident::new("value", Span::call_site()));
+                out.append(Punct::new(':', Alone));
+                out.append(Punct::new(':', Joint));
+                out.append(Punct::new(':', Alone));
+                out.append(Ident::new("tengri", Span::call_site()));
+                out.append(Punct::new(':', Joint));
+                out.append(Punct::new(':', Alone));
+                out.append(Ident::new("dsl", Span::call_site()));
+                out.append(Punct::new(':', Joint));
+                out.append(Punct::new(':', Alone));
+                out.append(Ident::new("Value", Span::call_site()));
+                out.append(Punct::new(':', Joint));
+                out.append(Punct::new(':', Alone));
+                out.append(Ident::new("Sym", Span::call_site()));
+                out.append(Group::new(Delimiter::Parenthesis, {
+                    let mut out = TokenStream2::new();
+                    out.append(LitStr::new(key, Span::call_site()).token());
+                    out
+                }));
+                out.append(Punct::new(',', Alone));
+                out.append(Punct::new('.', Joint));
+                out.append(Punct::new('.', Alone));
+                out
+            }));
+            out
+        }));
+        out.append(Punct::new('=', Joint));
+        out.append(Punct::new('>', Alone));
+        out.append(Ident::new("Some", Span::call_site()));
+        out.append(Group::new(Delimiter::Parenthesis, {
+            let mut out = TokenStream2::new();
+            out.append(Ident::new("state", Span::call_site()));
+            out.append(Punct::new('.', Alone));
+            out.append(value.clone());
+            out.append(Group::new(Delimiter::Parenthesis, TokenStream2::new()));
+            out.append(Punct::new('.', Alone));
+            out.append(Ident::new("boxed", Span::call_site()));
+            out.append(Group::new(Delimiter::Parenthesis, TokenStream2::new()));
+            out
+        }));
+        out.append(Punct::new(',', Alone));
+    }
 }

tui/src/tui_engine.rs

@@ -72,8 +72,7 @@ pub trait TuiRun<R: Render<TuiOut> + Handle<TuiIn> + 'static> {
     fn run (&self, state: &Arc<RwLock<R>>) -> Usually<()>;
 }
 
-impl<T: Render<TuiOut> + Handle<TuiIn> + Send + Sync + 'static>
+impl<T: Render<TuiOut> + Handle<TuiIn> + 'static> TuiRun<T> for Arc<RwLock<Tui>> {
-TuiRun<T> for Arc<RwLock<Tui>> {
     fn run (&self, state: &Arc<RwLock<T>>) -> Usually<()> {
         let _input_thread = TuiIn::run_input(self, state, Duration::from_millis(100));
         self.write().unwrap().setup()?;

tui/src/tui_engine/tui_input.rs

@@ -21,7 +21,7 @@ impl Input for TuiIn {
 
 impl TuiIn {
     /// Spawn the input thread.
-    pub fn run_input <T: Handle<TuiIn> + Send + Sync + 'static> (
+    pub fn run_input <T: Handle<TuiIn> + 'static> (
         engine: &Arc<RwLock<Tui>>,
         state:  &Arc<RwLock<T>>,
         timer:  Duration