wip: 21 errors!

crates/tek_core/src/engine/handle.rs

@@ -0,0 +1,46 @@
+use crate::*;
+
+/// Handle input
+pub trait Handle<E: Engine>: Send + Sync {
+    fn handle (&mut self, context: &E::HandleInput) -> Perhaps<E::Handled>;
+}
+
+impl<H, E: Engine> Handle<E> for &mut H where H: Handle<E> {
+    fn handle (&mut self, context: &E::HandleInput) -> Perhaps<E::Handled> {
+        (*self).handle(context)
+    }
+}
+
+impl<H, E: Engine> Handle<E> for Option<H> where H: Handle<E> {
+    fn handle (&mut self, context: &E::HandleInput) -> Perhaps<E::Handled> {
+        if let Some(ref mut handle) = self {
+            handle.handle(context)
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+impl<H, E: Engine> Handle<E> for Mutex<H> where H: Handle<E> {
+    fn handle (&mut self, context: &E::HandleInput) -> Perhaps<E::Handled> {
+        self.lock().unwrap().handle(context)
+    }
+}
+
+impl<H, E: Engine> Handle<E> for Arc<Mutex<H>> where H: Handle<E> {
+    fn handle (&mut self, context: &E::HandleInput) -> Perhaps<E::Handled> {
+        self.lock().unwrap().handle(context)
+    }
+}
+
+impl<H, E: Engine> Handle<E> for RwLock<H> where H: Handle<E> {
+    fn handle (&mut self, context: &E::HandleInput) -> Perhaps<E::Handled> {
+        self.write().unwrap().handle(context)
+    }
+}
+
+impl<H, E: Engine> Handle<E> for Arc<RwLock<H>> where H: Handle<E> {
+    fn handle (&mut self, context: &E::HandleInput) -> Perhaps<E::Handled> {
+        self.write().unwrap().handle(context)
+    }
+}

crates/tek_core/src/engine/render.rs

@@ -0,0 +1,69 @@
+use crate::*;
+
+/// Render to output.
+pub trait Render<E: Engine>: Send + Sync {
+    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered>;
+}
+
+/// Options can be rendered optionally.
+impl<R, E: Engine> Render<E> for Option<R> where R: Render<E> {
+    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+        match self {
+            Some(component) => component.render(to),
+            None => Ok(None)
+        }
+    }
+}
+
+/// Boxed references can be rendered.
+impl<'a, E: Engine> Render<E> for Box<dyn Render<E> + 'a> {
+    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+        (**self).render(to)
+    }
+}
+
+/// Immutable references can be rendered.
+impl<R, E: Engine> Render<E> for &R where R: Render<E> {
+    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+        (*self).render(to)
+    }
+}
+
+/// Mutable references can be rendered.
+impl<R, E: Engine> Render<E> for &mut R where R: Render<E> {
+    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+        (**self).render(to)
+    }
+}
+
+/// Counted references can be rendered.
+impl<R, E: Engine> Render<E> for Arc<R> where R: Render<E> {
+    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+        self.as_ref().render(to)
+    }
+}
+
+/// References behind a [Mutex] can be rendered.
+impl<R, E: Engine> Render<E> for Mutex<R> where R: Render<E> {
+    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+        self.lock().unwrap().render(to)
+    }
+}
+
+/// References behind a [RwLock] can be rendered.
+impl<R, E: Engine> Render<E> for RwLock<R> where R: Render<E> {
+    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+        self.read().unwrap().render(to)
+    }
+}
+
+/// Boxed closures can be rendered.
+///
+/// Rendering unboxed closures should also be possible;
+/// but in practice implementing the trait for an unboxed
+/// `Fn` closure causes an impl conflict.
+impl<'a, E: Engine> Render<E> for Box<dyn Fn(&mut E::RenderInput) -> Perhaps<E::Rendered> + Send + Sync + 'a> {
+    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+        (*self)(to)
+    }
+}