separate render/content macros; add has_jack

output/src/content.rs

@@ -1,46 +0,0 @@
-use crate::*;
-/// Build a [Render]able out of other [Render]ables,
-/// then apply optional custom render/layout on top.
-pub trait Content<E: Output>: Send + Sync + Sized {
-    fn content (&self) -> impl Render<E> { () }
-    fn layout (&self, area: E::Area) -> E::Area { self.content().layout(area) }
-    fn render (&self, output: &mut E) { self.content().render(output) }
-}
-impl<E: Output, C: Content<E>> Content<E> for &C {
-    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) }
-}
-/// The platonic ideal unit of [Content]: total emptiness at dead center.
-impl<E: Output> Content<E> for () {
-    fn layout (&self, area: E::Area) -> E::Area { area.center().to_area_pos().into() }
-    fn render (&self, _: &mut E) {}
-}
-impl<E: Output, T: Content<E>> Content<E> for Option<T> {
-    fn content (&self) -> impl Render<E> {
-        self.as_ref()
-    }
-    fn layout (&self, area: E::Area) -> E::Area {
-        self.as_ref()
-            .map(|content|content.layout(area))
-            .unwrap_or([0.into(), 0.into(), 0.into(), 0.into(),].into())
-    }
-    fn render (&self, output: &mut E) {
-        self.as_ref()
-            .map(|content|content.render(output));
-    }
-}
-//impl<E: Output, T: Content<E>, E: Content<E>> Content<E> for Option<T> {
-    //fn content (&self) -> impl Render<E> {
-        //self.as_ref()
-    //}
-    //fn layout (&self, area: E::Area) -> E::Area {
-        //self.as_ref()
-            //.map(|content|content.layout(area))
-            //.unwrap_or([0.into(), 0.into(), 0.into(), 0.into(),].into())
-    //}
-    //fn render (&self, output: &mut E) {
-        //self.as_ref()
-            //.map(|content|content.render(output));
-    //}
-//}

output/src/direction.rs

@@ -94,7 +94,6 @@ impl<E: Output, A: Content<E>, B: Content<E>> BspAreas<E, A, B> for Bsp<E, A, B>
 impl<'a, E: Output + 'a, T: EdnViewData<'a, E>> TryFromEdn<'a, T> for Bsp<E, RenderBox<'a, E>, RenderBox<'a, E>> {
     fn try_from_edn (s: &'a T, head: &EdnItem<&str>, tail: &'a [EdnItem<&str>]) -> Option<Self> {
         use EdnItem::*;
-                panic!("({head} {} {})", tail[0], tail[1]);
         Some(match (head, tail) {
             (Key("bsp/n"), [a, b]) => Self::n(s.get_content(a).expect("no a"), s.get(b).expect("no b")),
             (Key("bsp/s"), [a, b]) => Self::s(s.get_content(a).expect("no a"), s.get(b).expect("no b")),

output/src/lib.rs

@@ -6,10 +6,8 @@ mod coordinate; pub use self::coordinate::*;
 mod size; pub use self::size::*;
 mod area; pub use self::area::*;
 
-mod output;  pub use self::output::*;
-mod content; pub use self::content::*;
-mod render;  pub use self::render::*;
-mod thunk;   pub use self::thunk::*;
+mod output; pub use self::output::*;
+mod thunk;  pub use self::thunk::*;
 
 mod when;   pub use self::when::*;
 mod either; pub use self::either::*;

output/src/output.rs

@@ -1,6 +1,6 @@
 use crate::*;
-
-/// Render target
+use std::ops::Deref;
+/// Render target.
 pub trait Output: Send + Sync + Sized {
     /// Unit of length
     type Unit: Coordinate;
@@ -20,3 +20,113 @@ pub trait Output: Send + Sync + Sized {
     #[inline] fn h (&self) -> Self::Unit { self.area().h() }
     #[inline] fn wh (&self) -> Self::Size { self.area().wh().into() }
 }
+/// Renderable with dynamic dispatch.
+pub trait Render<E: Output>: Send + Sync {
+    /// Compute layout.
+    fn layout (&self, area: E::Area) -> E::Area;
+    /// 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: Sized + 'a {
+        Box::new(self) as RenderBox<'a, E>
+    }
+}
+/// Most importantly, every [Content] is also a [Render].
+///
+/// However, the converse does not hold true.
+/// Instead, the [Content::content] method returns an
+/// opaque [Render] pointer.
+impl<E: Output, C: Content<E>> Render<E> for C {
+    fn layout (&self, area: E::Area) -> E::Area { Content::layout(self, area) }
+    fn render (&self, output: &mut E) { Content::render(self, output) }
+}
+/// 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>>;
+/// You can render from a box.
+impl<'a, E: Output> Content<E> for RenderBox<'a, 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> + 'a;
+/// 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> { self.deref() }
+    fn layout (&self, area: E::Area) -> E::Area { Render::layout(self.deref(), area) }
+    fn render (&self, output: &mut E) { Render::render(self.deref(), output) }
+}
+/// Composable renderable with static dispatch.
+pub trait Content<E: Output>: Send + Sync + Sized {
+    /// Return a [Render]able of a specific type.
+    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].
+    fn render (&self, output: &mut E) { self.content().render(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 layout (&self, area: E::Area) -> E::Area { (*self).layout(area) }
+    fn render (&self, output: &mut E) { (*self).render(output) }
+}
+/// The platonic ideal unit of [Content]: total emptiness at dead center (e=1vg^sqrt(-1))
+impl<E: Output> Content<E> for () {
+    fn layout (&self, area: E::Area) -> E::Area { area.center().to_area_pos().into() }
+    fn render (&self, _: &mut E) {}
+}
+impl<E: Output, T: Content<E>> Content<E> for Option<T> {
+    fn content (&self) -> impl Render<E> {
+        self.as_ref()
+    }
+    fn layout (&self, area: E::Area) -> E::Area {
+        self.as_ref()
+            .map(|content|content.layout(area))
+            .unwrap_or([0.into(), 0.into(), 0.into(), 0.into(),].into())
+    }
+    fn render (&self, output: &mut E) {
+        self.as_ref()
+            .map(|content|content.render(output));
+    }
+}
+/// Implement [Content] with composable content for a struct.
+#[macro_export] macro_rules! content {
+    // 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) }
+        }
+    };
+    // Implement for specific [Output].
+    ($Output:ty:|
+        $self:ident:
+        $Struct:ident$(<$($($L:lifetime)? $($T:ident)? $(:$Trait:path)?),+>)?
+    |$content:expr) => {
+        impl $(<$($($L)? $($T)? $(:$Trait)?),+>)? Content<$Output>
+        for $Struct $(<$($($L)? $($T)?),+>)? {
+            fn content (&$self) -> impl Render<$Output> { $content }
+        }
+    };
+}
+/// Implement [Content] with custom rendering for a struct.
+#[macro_export] macro_rules! render {
+    (|$self:ident:$Struct:ident $(<
+        $($L:lifetime),* $($T:ident $(:$Trait:path)?),*
+    >)?, $to:ident | $render:expr) => {
+        impl <$($($L),*)? E: Output, $($T$(:$Trait)?),*> Content<E>
+        for $Struct $(<$($L),* $($T),*>>)? {
+            fn render (&$self, $to: &mut E) { $render }
+        }
+    };
+    ($Output:ty:|
+        $self:ident:
+        $Struct:ident $(<$($($L:lifetime)? $($T:ident)? $(:$Trait:path)?),+>)?, $to:ident
+    |$render:expr) => {
+        impl $(<$($($L)? $($T)? $(:$Trait)?),+>)? Content<$Output>
+        for $Struct $(<$($($L)? $($T)?),+>)? {
+            fn render (&$self, $to: &mut $Output) { $render }
+        }
+    };
+}

output/src/render.rs

@@ -1,66 +0,0 @@
-use crate::*;
-use std::ops::Deref;
-
-/// Custom layout and rendering.
-pub trait Render<E: Output>: Send + Sync {
-    fn layout (&self, area: E::Area) -> E::Area;
-    fn render (&self, output: &mut E);
-    fn boxed <'a> (self) -> RenderBox<'a, E> where Self: Sized + 'a {
-        Box::new(self) as RenderBox<'a, E>
-    }
-}
-
-pub type RenderDyn<'a, Output> = dyn Render<Output> + 'a;
-impl<'a, E: Output> Content<E> for &RenderDyn<'a, E> where Self: Sized {
-    fn content (&self) -> impl Render<E> { self.deref() }
-    fn layout (&self, area: E::Area) -> E::Area { Render::layout(self.deref(), area) }
-    fn render (&self, output: &mut E) { Render::render(self.deref(), output) }
-}
-
-pub type RenderBox<'a, E: Output> = Box<RenderDyn<'a, E>>;
-impl<'a, E: Output> Content<E> for RenderBox<'a, E> {
-    fn content (&self) -> impl Render<E> { self.deref() }
-    //fn boxed <'b> (self) -> RenderBox<'b, E> where Self: Sized + 'b { self }
-}
-
-impl<E: Output, C: Content<E>> Render<E> for C {
-    fn layout (&self, area: E::Area) -> E::Area { Content::layout(self, area) }
-    fn render (&self, output: &mut E) { Content::render(self, output) }
-}
-
-#[macro_export] macro_rules! render {
-    (($self:ident:$Struct:ty) => $content:expr) => {
-        impl <E: Output> Content<E> for $Struct {
-            fn content (&$self) -> impl Render<E> { Some($content) }
-        }
-    };
-    (|$self:ident:$Struct:ident $(<
-        $($L:lifetime),* $($T:ident $(:$Trait:path)?),*
-    >)?, $to:ident | $render:expr) => {
-        impl <$($($L),*)? E: Output, $($T$(:$Trait)?),*> Content<E>
-        for $Struct $(<$($L),* $($T),*>>)? {
-            fn render (&$self, $to: &mut E) { $render }
-        }
-    };
-    ($Output:ty:
-        ($self:ident:$Struct:ident $(<$(
-            $($L:lifetime)? $($T:ident)? $(:$Trait:path)?
-        ),+>)?) => $content:expr
-    ) => {
-        impl $(<$($($L)? $($T)? $(:$Trait)?),+>)? Content<$Output>
-        for $Struct $(<$($($L)? $($T)?),+>)? {
-            fn content (&$self) -> impl Render<$Output> { $content }
-        }
-    };
-
-    ($Output:ty:
-        |$self:ident : $Struct:ident $(<$(
-            $($L:lifetime)? $($T:ident)? $(:$Trait:path)?
-        ),+>)?, $to:ident| $render:expr
-    ) => {
-        impl $(<$($($L)? $($T)? $(:$Trait)?),+>)? Content<$Output>
-        for $Struct $(<$($($L)? $($T)?),+>)? {
-            fn render (&$self, $to: &mut $Output) { $render }
-        }
-    };
-}