reduce number of space modules

src/space/cond.rs

@@ -1,65 +1,43 @@
 use crate::*;
 
-pub enum Cond<E: Engine, A: Render<E>, B: Render<E>> {
-    _Unused(E),
-    When(bool, A),
-    Either(bool, A, B)
-}
+/// Conditional rendering, in unary and binary forms.
+pub struct Cond;
 
-impl<E: Engine, R: Render<E>> LayoutCond<E> for R {}
-
-pub trait LayoutCond<E: Engine>: Render<E> + Sized {
-    fn when (self, cond: bool) -> If<E, Self> {
-        If(Default::default(), cond, self)
+impl Cond {
+    /// Render `item` when `cond` is true.
+    pub fn when <E: Engine, A: Render<E>> (cond: bool, item: A) -> When<E, A> {
+        When(cond, item, Default::default())
     }
-    fn or <B: Render<E>> (self, cond: bool, other: B) -> Either<E, Self, B> {
-        Either(Default::default(), cond, self, other)
+    /// Render `item` if `cond` is true, otherwise render `other`.
+    pub fn either <E: Engine, A: Render<E>, B: Render<E>> (cond: bool, item: A, other: B) -> Either<E, A, B> {
+        Either(cond, item, other, Default::default())
     }
 }
 
-impl<E: Engine> LayoutCondStatic<E> for E {}
+/// Renders `self.1` when `self.0` is true.
+pub struct When<E: Engine, A: Render<E>>(bool, A, PhantomData<E>);
 
-pub trait LayoutCondStatic<E: Engine> {
-    fn either <A: Render<E>, B: Render<E>> (
-        condition: bool,
-        a: A,
-        b: B,
-    ) -> Either<E, A, B> {
-        Either(Default::default(), condition, a, b)
-    }
-}
+/// Renders `self.1` when `self.0` is true, otherwise renders `self.2`
+pub struct Either<E: Engine, A: Render<E>, B: Render<E>>(bool, A, B, PhantomData<E>);
 
-/// Render widget if predicate is true
-pub struct If<E: Engine, A: Render<E>>(PhantomData<E>, bool, A);
-
-impl<E: Engine, A: Render<E>> Render<E> for If<E, A> {
+impl<E: Engine, A: Render<E>> Render<E> for When<E, A> {
     fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
-        if self.1 {
-            return self.2.min_size(to)
-        }
-        Ok(None)
+        let Self(cond, item, ..) = self;
+        if *cond { item.min_size(to) } else { Ok(Some([0.into(), 0.into()].into())) }
     }
     fn render (&self, to: &mut E::Output) -> Usually<()> {
-        if self.1 {
-            return self.2.render(to)
-        }
-        Ok(())
+        let Self(cond, item, ..) = self;
+        if *cond { item.render(to) } else { Ok(()) }
     }
 }
 
-/// Render widget A if predicate is true, otherwise widget B
-pub struct Either<E: Engine, A: Render<E>, B: Render<E>>(
-    PhantomData<E>,
-    bool,
-    A,
-    B,
-);
-
 impl<E: Engine, A: Render<E>, B: Render<E>> Render<E> for Either<E, A, B> {
     fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
-        if self.1 { self.2.min_size(to) } else { self.3.min_size(to) }
+        let Self(cond, item, other, ..) = self;
+        if *cond { item.min_size(to) } else { other.min_size(to) }
     }
     fn render (&self, to: &mut E::Output) -> Usually<()> {
-        if self.1 { self.2.render(to) } else { self.3.render(to) }
+        let Self(cond, item, other, ..) = self;
+        if *cond { item.render(to) } else { other.render(to) }
     }
 }