Write documentation for new iced_native API

native/src/debug/basic.rs

@@ -1,5 +1,7 @@
+#![allow(missing_docs)]
 use std::{collections::VecDeque, time};
 
+/// A bunch of time measurements for debugging purposes.
 #[derive(Debug)]
 pub struct Debug {
     is_enabled: bool,
@@ -30,6 +32,9 @@ pub struct Debug {
 }
 
 impl Debug {
+    /// Creates a new [`Debug`].
+    ///
+    /// [`Debug`]: struct.Debug.html
     pub fn new() -> Self {
         let now = time::Instant::now();
 

native/src/lib.rs

@@ -34,7 +34,7 @@
 //! [`window::Backend`]: window/trait.Backend.html
 //! [`UserInterface`]: struct.UserInterface.html
 //! [renderer]: renderer/index.html
-//#![deny(missing_docs)]
+#![deny(missing_docs)]
 #![deny(missing_debug_implementations)]
 #![deny(unused_results)]
 #![forbid(unsafe_code)]

native/src/program.rs

@@ -14,7 +14,7 @@ pub trait Program: Sized {
 
     /// The type of __messages__ your [`Program`] will produce.
     ///
-    /// [`Application`]: trait.Program.html
+    /// [`Program`]: trait.Program.html
     type Message: std::fmt::Debug + Send;
 
     /// Handles a __message__ and updates the state of the [`Program`].
@@ -34,6 +34,6 @@ pub trait Program: Sized {
     ///
     /// These widgets can produce __messages__ based on user interaction.
     ///
-    /// [`Program`]: trait.Application.html
+    /// [`Program`]: trait.Program.html
     fn view(&mut self) -> Element<'_, Self::Message, Self::Renderer>;
 }

native/src/program/state.rs

@@ -3,6 +3,10 @@ use crate::{
     UserInterface,
 };
 
+/// The execution state of a [`Program`]. It leverages caching, event
+/// processing, and rendering primitive storage.
+///
+/// [`Program`]: trait.Program.html
 #[allow(missing_debug_implementations)]
 pub struct State<P>
 where
@@ -19,6 +23,11 @@ impl<P> State<P>
 where
     P: Program + 'static,
 {
+    /// Creates a new [`State`] with the provided [`Program`], initializing its
+    /// primitive with the given logical bounds and renderer.
+    ///
+    /// [`State`]: struct.State.html
+    /// [`Program`]: trait.Program.html
     pub fn new(
         mut program: P,
         bounds: Size,
@@ -48,22 +57,44 @@ where
         }
     }
 
+    /// Returns a reference to the [`Program`] of the [`State`].
+    ///
+    /// [`Program`]: trait.Program.html
+    /// [`State`]: struct.State.html
     pub fn program(&self) -> &P {
         &self.program
     }
 
+    /// Returns a reference to the current rendering primitive of the [`State`].
+    ///
+    /// [`State`]: struct.State.html
     pub fn primitive(&self) -> &<P::Renderer as Renderer>::Output {
         &self.primitive
     }
 
+    /// Queues an event in the [`State`] for processing during an [`update`].
+    ///
+    /// [`State`]: struct.State.html
+    /// [`update`]: #method.update
     pub fn queue_event(&mut self, event: Event) {
         self.queued_events.push(event);
     }
 
+    /// Queues a message in the [`State`] for processing during an [`update`].
+    ///
+    /// [`State`]: struct.State.html
+    /// [`update`]: #method.update
     pub fn queue_message(&mut self, message: P::Message) {
         self.queued_messages.push(message);
     }
 
+    /// Processes all the queued events and messages, rebuilding and redrawing
+    /// the widgets of the linked [`Program`] if necessary.
+    ///
+    /// Returns the [`Command`] obtained from [`Program`] after updating it,
+    /// only if an update was necessary.
+    ///
+    /// [`Program`]: trait.Program.html
     pub fn update(
         &mut self,
         clipboard: Option<&dyn Clipboard>,