wip: refactor(output): pen and paper ftw

output/src/out_traits.rs

@@ -0,0 +1,148 @@
+use crate::*;
+
+/// Drawing target.
+///
+/// ```
+/// use crate::*;
+/// struct TestOut([u16;4]);
+/// impl Out for TestOut {
+///     type Unit = u16;
+///     type Size = [u16;2];
+///     type Area = [u16;4];
+///     fn area (&self) -> [u16;4] {
+///         self.0
+///     }
+///     fn area_mut (&mut self) -> &mut [u16;4] {
+///         &mut self.0
+///     }
+///     fn place_at <T: Draw<Self> + ?Sized> (&mut self, area: [u16;4], _: &T) {
+///         println!("place_at: {area:?}");
+///         ()
+///     }
+/// }
+/// impl Draw<TestOut> for String {
+///     fn draw (&self, to: &mut TestOut) {
+///         to.area_mut().set_w(self.len() as u16);
+///     }
+/// }
+/// ```
+pub trait Out: Send + Sync + Sized {
+    /// Unit of length
+    type Unit: Coord;
+    /// Rectangle without offset
+    type Size: Size<Self::Unit>;
+    /// Rectangle with offset
+    type Area: Area<Self::Unit>;
+    /// Current output area
+    fn area (&self) -> Self::Area;
+    /// Mutable pointer to area.
+    fn area_mut (&mut self) -> &mut Self::Area;
+    /// Render drawable in area specified by `area`
+    fn place_at <'t, T: Draw<Self> + ?Sized> (&mut self, area: Self::Area, content: &'t T);
+    /// Render drawable in area specified by `T::layout(self.area())`
+    #[inline] fn place <'t, T: Content<Self> + ?Sized> (
+        &mut self, content: &'t T
+    ) {
+        self.place_at(content.layout(self.area()), content)
+    }
+}
+
+/// Drawable with dynamic dispatch.
+pub trait Draw<O: Out> {
+    fn draw (&self, to: &mut O);
+}
+
+/// FIXME: This is a general implementation: should be called `Eval` and be part of [dizzle].
+/// Matches [Language] expressions to renderings for a given [Output] target.
+pub trait View<O, U> {
+    fn view_expr <'a> (&'a self, _output: &mut O, expr: &'a impl Expression) -> Usually<U> {
+        Err(format!("View::view_expr: no exprs defined: {expr:?}").into())
+    }
+    fn view_word <'a> (&'a self, _output: &mut O, word: &'a impl Symbol) -> Usually<U> {
+        Err(format!("View::view_word: no words defined: {word:?}").into())
+    }
+    fn view <'a> (&'a self, output: &mut O, dsl: &'a impl Language) -> Usually<U> {
+        let is_expr = dsl.expr();
+        let is_word = dsl.word();
+        match (dsl.expr(), dsl.word()) {
+            (Ok(Some(e)), _          ) => self.view_expr(output, &e),
+            (_,           Ok(Some(w))) => self.view_word(output, &w),
+            (Err(e),      _          ) => Err(format!("invalid view expr:\n{dsl:?}\n{e}").into()),
+            (_,           Err(w)     ) => Err(format!("invalid view word:\n{dsl:?}\n{w}").into()),
+            (Ok(None),    Ok(None)   ) => Err(format!("empty view:\n{dsl:?}").into()),
+        }
+    }
+}
+
+/// Outputs combinator.
+pub trait Lay<O: Out>: Sized {}
+
+/// Drawable area of display.
+pub trait Layout<O: Out> {
+    fn x      (&self, to: O::Area) -> O::Unit { to.x() }
+    fn y      (&self, to: O::Area) -> O::Unit { to.y() }
+    fn w_min  (&self, _t: O::Area) -> O::Unit { 0.into() }
+    fn w_max  (&self, to: O::Area) -> O::Unit { to.w() }
+    fn w      (&self, to: O::Area) -> O::Unit { to.w().max(self.w_min(to)).min(self.w_max(to)) }
+    fn h_min  (&self, _t: O::Area) -> O::Unit { 0.into() }
+    fn h_max  (&self, to: O::Area) -> O::Unit { to.h() }
+    fn h      (&self, to: O::Area) -> O::Unit { to.h().max(self.h_min(to)).min(self.h_max(to)) }
+    fn layout (&self, to: O::Area) -> O::Area { [self.x(to), self.y(to), self.w(to), self.h(to)].into() }
+}
+
+// TODO DOCUMENTME
+pub trait Content<O: Out>: Draw<O> + Layout<O> {}
+
+/// A numeric type that can be used as coordinate.
+///
+/// FIXME: Replace this ad-hoc trait with `num` crate.
+pub trait Coord: Send + Sync + Copy
+    + Add<Self, Output=Self>
+    + Sub<Self, Output=Self>
+    + Mul<Self, Output=Self>
+    + Div<Self, Output=Self>
+    + Ord + PartialEq + Eq
+    + Debug + Display + Default
+    + From<u16> + Into<u16>
+    + Into<usize>
+    + Into<f64>
+{
+    fn zero () -> Self { 0.into() }
+    fn plus (self, other: Self) -> Self;
+    fn minus (self, other: Self) -> Self { if self >= other { self - other } else { 0.into() } }
+}
+
+// Something that has an origin point (X, Y).
+pub trait HasXY<N: Coord> {
+    fn x  (&self) -> N;
+    fn y  (&self) -> N;
+    fn xy (&self) -> XY<N> { XY(self.x(), self.y()) }
+}
+
+// Something that has a size (W, H).
+pub trait HasWH<N: Coord> {
+    fn w  (&self) -> N;
+    fn h  (&self) -> N;
+    fn wh (&self) -> WH<N> { WH(self.w(), self.h()) }
+}
+
+// Something that has a 2D bounding box (X, Y, W, H).
+pub trait HasXYWH<N: Coord>: HasXY<N> + HasWH<N> {
+    fn x2 (&self) -> N { self.x().plus(self.w()) }
+    fn y2 (&self) -> N { self.y().plus(self.h()) }
+    fn xywh (&self) -> XYWH<N> { XYWH(self.x(), self.y(), self.w(), self.h()) }
+    fn expect_min (&self, w: N, h: N) -> Usually<&Self> {
+        if self.w() < w || self.h() < h {
+            Err(format!("min {w}x{h}").into())
+        } else {
+            Ok(self)
+        }
+    }
+}
+
+// TODO DOCUMENTME
+pub trait HasSize<O: Out> {
+    fn size   (&self) -> &Measure<O>;
+    fn width  (&self) -> usize { self.size().w() }
+    fn height (&self) -> usize { self.size().h() }
+}