re-add tui_main, fixing examples

Cargo.toml

@@ -37,7 +37,7 @@ winit         = { optional = true, version = "0.30.4", features = [ "x11" ]}
 [dev-dependencies]
 proptest        = { version = "^1" }
 proptest-derive = { version = "^0.5.1" }
-tengri          = { path = ".", features = [ "dsl" ] }
+tengri          = { path = "." }
 #tengri_proc     = { path = "./proc" }
 
 [profile.coverage]

examples/tui_00.rs

@@ -1,31 +1,57 @@
-use ::{std::{io::stdout, sync::{Arc, RwLock}}, ratatui::style::Color, tengri::*};
+use ::{
- tui_main!(State { cursor: 10, ..Default::default() });
+    std::{io::stdout, sync::{Arc, RwLock}},
-namespace!(State: bool  {});
+    tengri::{*, term::*, lang::*, keys::*, draw::*, space::*},
-namespace!(State: u16   {});
+    ratatui::style::Color,
-namespace!(State: Color {});
+};
-   handle!(TuiIn: |self: State, input|Action::from(input).eval(self).map(|_|None));
+
-     view!(State: TuiOut: [ evaluate_output_expression, evaluate_output_expression_tui ]);
+tui_main!(State { cursor: 10, ..Default::default() });
-     draw!(State: TuiOut: [ draw_example ]);
+
-#[derive(Debug, Default)] struct State {
+//namespace!(State: bool  {});
-    /** Rendered window size        */ size:    Measure<TuiOut>,
+//namespace!(State: u16   {});
-    /** Command history (undo/redo) */ history: Vec<Action>,
+//namespace!(State: Color {});
-    /** User-controllable value     */ cursor:  usize,
+   //handle!(TuiIn: |self: State, input|Action::from(input).eval(self).map(|_|None));
+     //view!(State: Tui: [ evaluate_output_expression, evaluate_output_expression_tui ]);
+     //draw!(State: Tui: [ draw_example ]);
+
+impl Apply<TuiEvent, Usually<Self>> for State {
+    fn apply (&mut self, input: &TuiEvent) -> Usually<Self> {
+        todo!()
+    }
 }
-impl_from!(Action: |input: &TuiIn| todo!());
+
-#[derive(Debug)] enum Action {
+impl View<Tui> for State {
-    /** Increment cursor */ Next,
+    fn view (&self) -> impl Draw<Tui> {
-    /** Decrement cursor */ Prev
+        let index   = self.cursor + 1;
-}
+        let wh      = (self.size.w(), self.size.h());
-fn draw_example (state: &State, to: &mut TuiOut) {
+        let src     = VIEWS.get(self.cursor).unwrap_or(&"");
-    let index   = state.cursor + 1;
-    let wh      = state.size.wh();
-    let src     = VIEWS.get(state.cursor).unwrap_or(&"");
         let heading = format!("State {}/{} in {:?}", index, VIEWS.len(), &wh);
-    let title   = Tui::bg(Color::Rgb(60, 10, 10), Push::Y(1, Align::n(heading)));
+        let title   = bg(Color::Rgb(60, 10, 10), push_y(1, align_n(heading)));
-    let code    = Tui::bg(Color::Rgb(10, 60, 10), Push::Y(2, Align::n(format!("{}", src))));
+        let code    = bg(Color::Rgb(10, 60, 10), push_y(2, align_n(format!("{}", src))));
-    //let content = ;//();//Tui::bg(Color::Rgb(10, 10, 60), View(state, CstIter::new(src)));
+        //let content = ;//();//bg(Color::Rgb(10, 10, 60), View(self, CstIter::new(src)));
-    state.size.of(Bsp::s(title, Bsp::n(code, state.understand(to, &src).unwrap()))).draw(to)
+        self.size.of(bsp_s(title, bsp_n(code, self.understand(to, &src).unwrap())))
+    }
 }
+
+#[derive(Debug, Default)] struct State {
+    /** Command history (undo/redo). */
+    history: Vec<Action>,
+    /** User-controllable value. */
+    cursor: usize,
+    /** Rendered window size. */
+    size: crate::space::Size,
+}
+
+//impl_from!(Action: |input: &TuiIn| todo!());
+#[derive(Debug)] enum Action {
+    /** Increment cursor */
+    Next,
+    /** Decrement cursor */
+    Prev
+}
+
+fn draw_example (state: &State, to: &mut Tui) {
+}
+
 impl Action {
     const BINDS: &'static str = stringify! { (@left prev) (@right next) };
     fn eval (&self, state: &mut State) -> Perhaps<Self> {
@@ -41,6 +67,7 @@ impl Action {
         Ok(Some(Self::Next))
     }
 }
+
 const VIEWS: &'static [&'static str] = &[
 
     stringify! { :hello-world },

src/draw.rs

@@ -1,17 +1,5 @@
 use crate::{*, lang::*, color::*, space::*};
 
-/// Emit a [Draw]able.
-///
-/// Speculative. How to avoid conflicts with [Draw] proper?
-pub trait View<T: Screen> {
-    fn view (&self) -> impl Draw<T>;
-}
-impl<T: Screen, V: View<T>> Draw<T> for &V {
-    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
-        self.view().draw(to)
-    }
-}
-
 /// Drawable that supports dynamic dispatch.
 ///
 /// Drawables are composable, e.g. the [when] and [either] conditionals
@@ -42,18 +30,24 @@ impl<T: Screen, V: View<T>> Draw<T> for &V {
 pub trait Draw<T: Screen> {
     fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>>;
 }
-/// Empty draw
+impl<T: Screen, D: Draw<T>> Draw<T> for &D {
-impl<T: Screen> Draw<T> for () {
+    fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
-    fn draw (self, __: &mut T) -> Usually<XYWH<T::Unit>> {
+        todo!()
-        Ok(Default::default())
     }
 }
 impl<T: Screen, D: Draw<T>> Draw<T> for Option<D> {
     fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
-        Ok(self.map(|draw|draw.draw(to)).transpose()?.unwrap_or_default())
+        todo!()
     }
 }
 
+/// Emit a [Draw]able.
+///
+/// Speculative. How to avoid conflicts with [Draw] proper?
+pub trait View<T: Screen> {
+    fn view (&self) -> impl Draw<T>;
+}
+
 pub const fn thunk <T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> (draw: F) -> Thunk<T, F> {
     Thunk(draw, std::marker::PhantomData)
 }
@@ -63,7 +57,6 @@ pub struct Thunk<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>>(
     pub F,
     std::marker::PhantomData<T>
 );
-
 impl<T: Screen, F: FnOnce(&mut T)->Usually<XYWH<T::Unit>>> Draw<T> for Thunk<T, F> {
     fn draw (self, to: &mut T) -> Usually<XYWH<T::Unit>> {
         (self.0)(to)

src/exit.rs

@@ -8,3 +8,10 @@ impl Exit {
         run(Self(Arc::new(AtomicBool::new(false))))
     }
 }
+
+impl AsRef<Arc<AtomicBool>> for Exit {
+    fn as_ref (&self) -> &Arc<AtomicBool> {
+        &self.0
+    }
+}
+

src/keys.rs

@@ -2,13 +2,13 @@ use crate::task::Task;
 
 use ::std::sync::{Arc, RwLock, atomic::{AtomicBool, Ordering::*}};
 use ::std::time::Duration;
-use ::dizzle::{Usually, Do, impl_from};
+use ::dizzle::{Usually, Apply, impl_from};
 use ::crossterm::event::{
     read, Event, KeyEvent, KeyCode, KeyModifiers, KeyEventKind, KeyEventState
 };
 
 /// Spawn the TUI input thread which reads keys from the terminal.
-pub fn tui_input <T: Do<TuiEvent, Usually<T>> + Send + Sync + 'static> (
+pub fn tui_input <T: Apply<TuiEvent, Usually<T>> + Send + Sync + 'static> (
     exited: &Arc<AtomicBool>, state: &Arc<RwLock<T>>, poll: Duration
 ) -> Result<Task, std::io::Error> {
     let exited = exited.clone();

src/space.rs

@@ -1,4 +1,5 @@
 use crate::{*, draw::*};
+#[cfg(test)] use proptest_derive::Arbitrary;
 
 /// Point with size.
 ///

src/term.rs

@@ -21,6 +21,23 @@ use ::{
         event::{poll, read, Event, KeyEvent, KeyCode, KeyModifiers, KeyEventKind, KeyEventState},
     }
 };
+#[macro_export] macro_rules! tui_main {
+    ($state:expr) => {
+        pub fn main () -> Usually<()> {
+            tengri::exit::Exit::run(|exit|{
+                let state = Arc::new(RwLock::new($state));
+                Ok((
+                    ::tengri::keys::tui_input(
+                        exit.as_ref(), &state, std::time::Duration::from_millis(100)
+                    )?,
+                    ::tengri::term::tui_output(
+                        stdout(), exit.as_ref(), &state, std::time::Duration::from_millis(10)
+                    )?
+                ))
+            })
+        }
+    }
+}
 pub struct Tui(pub Buffer, pub XYWH<u16>);
 impl Screen    for Tui { type Unit = u16; }
 impl Deref     for Tui { type Target = Buffer; fn deref (&self) -> &Buffer { &self.0 } }