read explicit lifetime to FromDsl

dsl/src/dsl_provide.rs

@@ -18,10 +18,10 @@ pub trait Dsl<Other>: Sized {
         }
     }
 }
-pub trait FromDsl<State>: Sized {
-    fn take_from <'state, 'source: 'state> (state: &'state State, token: &mut TokenIter<'source>)
+pub trait FromDsl<'source, State>: Sized {
+    fn take_from <'state> (state: &'state State, token: &mut TokenIter<'source>)
         -> Perhaps<Self>;
-    fn take_from_or_fail <'state, 'source: 'state> (
+    fn take_from_or_fail <'state> (
         state: &'state State,
         token: &mut TokenIter<'source>,
         error: impl Into<Box<dyn std::error::Error>>
@@ -33,13 +33,6 @@ pub trait FromDsl<State>: Sized {
         }
     }
 }
-impl<T: FromDsl<State>, State> Dsl<T> for State {
-    fn take <'state, 'source: 'state> (&'state self, token: &mut TokenIter<'source>)
-        -> Perhaps<T>
-    {
-        FromDsl::take_from(self, token)
-    }
-}
 //impl<State: Dsl<T>, T> FromDsl<State> for T {
     //fn take_from <'state, 'source: 'state> (state: &'state State, token: &mut TokenIter<'source>)
         //-> Perhaps<Self>
@@ -51,17 +44,37 @@ impl<T: FromDsl<State>, State> Dsl<T> for State {
 /// Implement the [Dsl] trait, which boils down to
 /// specifying two types and providing an expression.
 #[macro_export] macro_rules! from_dsl {
-    ($T:ty: |$state:ident:$S:ty, $words:ident|$expr:expr) => {
-        impl ::tengri::dsl::FromDsl<$S> for $T {
-            fn take_from <'state, 'source: 'state> (
-                $state: &'state $S,
-                $words: &mut ::tengri::dsl::TokenIter<'source>,
-            ) -> ::tengri::Perhaps<$T> {
+    (@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.

input/src/input_dsl.rs

@@ -5,13 +5,15 @@ 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<S: Dsl<C>, C: Command<S>, I: DslInput> {
+pub trait KeyMap<'source, S, C: FromDsl<'source, S> + 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: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for SourceIter<'source> {
+impl<'source, S, C: FromDsl<'source, S> + Command<S>, I: DslInput>
+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() {
@@ -22,7 +24,7 @@ impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for SourceI
                     match exp_iter.next() {
                         Some(Token { value: Value::Sym(binding), .. }) => {
                             if input.matches_dsl(binding) {
-                                if let Some(command) = state.take(&mut exp_iter)? {
+                                if let Some(command) = FromDsl::take_from(state, &mut exp_iter)? {
                                     return Ok(Some(command))
                                 }
                             }
@@ -38,7 +40,9 @@ impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for SourceI
 }
 
 /// A [TokenIter] can be a [KeyMap].
-impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for TokenIter<'source> {
+impl<'source, S, C: FromDsl<'source, S> + Command<S>, I: DslInput>
+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() {
@@ -48,7 +52,7 @@ impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for TokenIt
                     match e.next() {
                         Some(Token { value: Value::Sym(binding), .. }) => {
                             if input.matches_dsl(binding) {
-                                if let Some(command) = state.take(&mut e)? {
+                                if let Some(command) = FromDsl::take_from(state, &mut e)? {
                                     return Ok(Some(command))
                                 }
                             }
@@ -63,25 +67,37 @@ impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for TokenIt
     }
 }
 
-pub type InputLayerCond<S> = Box<dyn Fn(&S)->Usually<bool> + Send + Sync>;
+pub type InputLayerCond<'source, S> = Box<dyn Fn(&S)->Usually<bool> + 'source>;
 
 /// A collection of pre-configured mappings of input events to commands,
 /// which may be made available subject to given conditions.
-pub struct InputMap<S, C, I, M>
-where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
-    __: PhantomData<(S, C, I)>,
-    pub layers: Vec<(InputLayerCond<S>, M)>,
+pub struct InputMap<'source,
+    S,
+    C: Command<S> + FromDsl<'source, S>,
+    I: DslInput,
+    M: KeyMap<'source, S, C, I>
+> {
+    __: PhantomData<&'source (S, C, I)>,
+    pub layers: Vec<(InputLayerCond<'source, S>, M)>,
 }
 
-impl<S, C, I, M> Default for InputMap<S, C, I, M>
-where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
+impl<'source,
+    S,
+    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<S: 'static, C, I, M> InputMap<S, C, I, M>
-where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
+impl<'source,
+    S,
+    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)
     }
@@ -93,26 +109,34 @@ where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
         self.add_layer_if(Box::new(|_|Ok(true)), keymap);
         self
     }
-    pub fn layer_if (mut self, condition: InputLayerCond<S>, keymap: M) -> Self {
+    pub fn layer_if (mut self, condition: InputLayerCond<'source, S>, keymap: M) -> Self {
         self.add_layer_if(condition, keymap);
         self
     }
-    pub fn add_layer_if (&mut self, condition: InputLayerCond<S>, keymap: M) -> &mut Self {
+    pub fn add_layer_if (&mut self, condition: InputLayerCond<'source, S>, keymap: M) -> &mut Self {
         self.layers.push((Box::new(condition), keymap));
         self
     }
 }
 
-impl<S, C, I, M> std::fmt::Debug for InputMap<S, C, I, M>
-where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
+impl<'source,
+    S,
+    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<S, C, I, M> KeyMap<S, C, I> for InputMap<S, C, I, M>
-where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
+impl<'source,
+    S,
+    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: Send + Sync + Sized {
+pub trait Input: Sized {
     /// Type of input event
     type Event;
     /// Result of handling input
@@ -36,7 +36,7 @@ pub trait Input: Send + Sync + Sized {
 }
 
 /// Handle input
-pub trait Handle<E: Input>: Send + Sync {
+pub trait Handle<E: Input> {
     fn handle (&mut self, _input: &E) -> Perhaps<E::Handled> {
         Ok(None)
     }

output/src/ops/align.rs

@@ -36,11 +36,7 @@ pub enum Alignment { #[default] Center, X, Y, NW, N, NE, E, SE, S, SW, W }
 pub struct Align<A>(Alignment, A);
 
 #[cfg(feature = "dsl")]
-impl<State: Dsl<A>, A> FromDsl<State> for Align<A> {
-    fn take_from <'state, 'source: 'state> (state: &'state State, iter: &mut TokenIter<'source>)
-        -> Perhaps<Self>
-    {
-        if let Some(Token { value: Value::Key(key), .. }) = iter.peek() {
+from_dsl!(@a: Align<A>: |state, iter|if let Some(Token { value: Value::Key(key), .. }) = iter.peek() {
     match key {
         "align/c"|"align/x"|"align/y"|
         "align/n"|"align/s"|"align/e"|"align/w"|
@@ -66,9 +62,7 @@ impl<State: Dsl<A>, A> FromDsl<State> for Align<A> {
     }
 } else {
     Ok(None)
-        }
-    }
-}
+});
 
 impl<A> Align<A> {
     #[inline] pub const fn c  (a: A) -> Self { Self(Alignment::Center, a) }
@@ -85,7 +79,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,9 +21,7 @@ impl<E: Output, A: Content<E>, B: Content<E>> Content<E> for Bsp<A, B> {
     }
 }
 #[cfg(feature = "dsl")]
-impl<A, B, T: Dsl<A> + Dsl<B>> FromDsl<T> for Bsp<A, B> {
-    fn take_from <'state, 'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
-        Ok(if let Some(Token {
+from_dsl!(@ab: Bsp<A, B>: |state, iter|Ok(if let Some(Token {
     value: Value::Key("bsp/n"|"bsp/s"|"bsp/e"|"bsp/w"|"bsp/a"|"bsp/b"),
     ..
 }) = iter.peek() {
@@ -51,9 +49,7 @@ impl<A, B, T: Dsl<A> + Dsl<B>> FromDsl<T> for Bsp<A, B> {
     }))
 } 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

@@ -18,8 +18,8 @@ impl<A, B> Either<A, B> {
     }
 }
 #[cfg(feature = "dsl")]
-impl<A, T: Dsl<bool> + Dsl<A>> FromDsl<T> for When<A> {
-    fn take_from <'state, 'source: 'state> (
+impl<'source, A, T: Dsl<bool> + Dsl<A>> FromDsl<'source, T> for When<A> {
+    fn take_from <'state> (
         state: &'state T,
         token: &mut TokenIter<'source>
     ) -> Perhaps<Self> {
@@ -56,8 +56,8 @@ impl<E: Output, A: Render<E>> Content<E> for When<A> {
     }
 }
 #[cfg(feature = "dsl")]
-impl<A, B, T: Dsl<bool> + Dsl<A> + Dsl<B>> FromDsl<T> for Either<A, B> {
-    fn take_from <'state, 'source: 'state> (
+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> {

output/src/ops/thunk.rs

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

@@ -33,8 +33,8 @@ macro_rules! transform_xy {
             #[inline] pub const fn xy (item: A) -> Self { Self::XY(item) }
         }
         #[cfg(feature = "dsl")]
-        impl<A, T: Dsl<A>> FromDsl<T> for $Enum<A> {
-            fn take_from <'state, 'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
+        impl<'source, A, T: Dsl<A>> FromDsl<'source, T> for $Enum<A> {
+            fn take_from <'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() {
@@ -51,7 +51,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,
@@ -77,8 +77,8 @@ macro_rules! transform_xy_unit {
             #[inline] pub const fn xy (x: U, y: U, item: A) -> Self { Self::XY(x, y, item) }
         }
         #[cfg(feature = "dsl")]
-        impl<A, U: Coordinate, T: Dsl<A> + Dsl<U>> FromDsl<T> for $Enum<U, A> {
-            fn take_from <'state, 'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
+        impl<'source, A, U: Coordinate, T: Dsl<A> + Dsl<U>> FromDsl<'source, T> for $Enum<U, A> {
+            fn take_from <'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() {
@@ -103,7 +103,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) -> RenderBox<'a, E> where Self: Send + Sync + Sized + 'a {
-        Box::new(self) as RenderBox<'a, E>
+    fn boxed <'a> (self) -> Box<dyn Render<E> + 'a> where Self: Sized + 'a {
+        Box::new(self) as Box<dyn Render<E> + 'a>
     }
 }
 
@@ -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<'a, E> = Box<RenderDyn<'a, E>>;
+pub type RenderBox<E> = Box<RenderDyn<E>>;
 
 /// You can render from a box.
-impl<'a, E: Output> Content<E> for RenderBox<'a, E> {
-    fn content (&self) -> impl Render<E> { self.deref() }
+impl<E: Output> Content<E> for RenderBox<E> {
+    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<'a, E> = dyn Render<E> + Send + Sync + 'a;
+pub type RenderDyn<E> = dyn Render<E>;
 
 /// You can render from an opaque pointer.
-impl<'a, E: Output> Content<E> for &RenderDyn<'a, E> where Self: Sized {
-    fn content (&self) -> impl Render<E> {
+impl<E: Output> Content<E> for &RenderDyn<E> where Self: Sized {
+    fn content (&self) -> impl Render<E> + '_ {
         #[allow(suspicious_double_ref_op)]
         self.deref()
     }
@@ -77,7 +77,7 @@ impl<'a, E: Output> Content<E> for &RenderDyn<'a, 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 }
         }
     };
 }

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: Dsl::take_or_fail(self, words)?,
+                                #arg: FromDsl::take_from_or_fail(self, words)?,
                             });
                         }
                         out
@@ -137,17 +137,22 @@ impl ToTokens for CommandDef {
             #[derive(Clone, Debug)] pub enum #command_enum { #(#variants)* }
             /// Not generated by [tengri_proc].
             #block
-            /// Generated by [tengri_proc].
+            /// Generated by [tengri_proc::command].
+            ///
+            /// 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].
-            impl ::tengri::dsl::FromDsl<#state> for #command_enum {
-                fn take_from <'state, 'source: 'state> (
+            /// Generated by [tengri_proc::command].
+            impl<'source> ::tengri::dsl::FromDsl<'source, #state> for #command_enum {
+                fn take_from <'state> (
                     state: &'state #state,
-                    words: &mut TokenIter<'source>,
+                    words: &mut ::tengri::dsl::TokenIter<'source>
                 ) -> Perhaps<Self> {
                     let mut words = words.clone();
                     let token = words.next();

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

proc/src/proc_view.rs

@@ -14,8 +14,6 @@ pub(crate) struct ViewImpl {
     exposed: BTreeMap<String, Ident>,
 }
 
-struct ViewArm(String, Ident);
-
 impl Parse for ViewMeta {
     fn parse (input: ParseStream) -> Result<Self> {
         Ok(Self {
@@ -41,6 +39,60 @@ impl Parse for ViewImpl {
     }
 }
 
+impl ToTokens for ViewDef {
+    fn to_tokens (&self, out: &mut TokenStream2) {
+        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)|{
+            available.push(key.clone());
+            write_quote(quote! { #key => Some(state.#value().boxed()), })
+        }).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! {
+            #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].
+            ///
+            /// Gives [#view] the ability to construct the [Render]able
+            /// 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>,
+                ) -> Perhaps<Self> {
+                    Ok(words.peek().and_then(|::tengri::dsl::Token{ value, .. }|match value {
+                        ::tengri::dsl::Value::Exp(_, exp) => {
+                            todo!("builtin layout ops");
+                            //#builtins
+                            None
+                        },
+                        ::tengri::dsl::Value::Sym(sym) => match sym {
+                            #(#exposed)*
+                            _ => None
+                        },
+                        _ => None
+                    }))
+                }
+            }
+        })
+    }
+}
+
 fn builtins () -> [TokenStream2;14] {
     [
         quote! { When::<A>       },
@@ -59,117 +111,3 @@ fn builtins () -> [TokenStream2;14] {
         quote! { Padding::<_, A> },
     ]
 }
-
-impl ToTokens for ViewDef {
-    fn to_tokens (&self, out: &mut TokenStream2) {
-        let Self(ViewMeta { output }, ViewImpl { block, exposed }) = self;
-        let view = &block.self_ty;
-        let mut available = vec![];
-        let exposed: Vec<_> = exposed.iter()
-            .map(|(k,v)|{ available.push(k.clone()); 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()
-        );
-        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].
-            ///
-            /// Gives [#view] the ability to construct the [Render]able
-            /// which might corresponds to a given [TokenStream],
-            /// while taking [#view]'s state into consideration.
-            impl<'context> ::tengri::dsl::FromDsl<#view> for RenderBox<'context, #output> {
-                fn take_from <'state, 'source: 'state> (
-                    state: &'state #view, words: &mut ::tengri::dsl::TokenIter<'source>
-                ) -> Perhaps<Self> {
-                    Ok(match words.peek() {
-                        Some(::tengri::dsl::Token { value: ::tengri::dsl::Value::Exp(exp), .. }) => {
-                            if let Some(value) = FromDsl::take_from(state, words)? {
-                                return Ok(Some(value.boxed()))
-                            }
-                            //#builtins
-                            None
-                        },
-                        #(#exposed)*
-                        _ => None
-                    })
-                }
-            }
-        } {
-            out.append(token)
-        }
-    }
-}
-
-impl ToTokens for ViewArm {
-    fn to_tokens (&self, out: &mut TokenStream2) {
-        let Self(key, value) = self;
-        out.append(Ident::new("Some", Span::call_site()));
-        out.append(Group::new(Delimiter::Parenthesis, {
-            let mut out = TokenStream2::new();
-            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("Token", Span::call_site()));
-            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,7 +72,8 @@ pub trait TuiRun<R: Render<TuiOut> + Handle<TuiIn> + 'static> {
     fn run (&self, state: &Arc<RwLock<R>>) -> Usually<()>;
 }
 
-impl<T: Render<TuiOut> + Handle<TuiIn> + 'static> TuiRun<T> for Arc<RwLock<Tui>> {
+impl<T: Render<TuiOut> + Handle<TuiIn> + Send + Sync + 'static>
+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> + 'static> (
+    pub fn run_input <T: Handle<TuiIn> + Send + Sync + 'static> (
         engine: &Arc<RwLock<Tui>>,
         state:  &Arc<RwLock<T>>,
         timer:  Duration