Improve docs

examples/event.rs

+use console_log;
+use log::{error, info, Level};
+use wasm_bindgen::JsValue;
+use wasm_sockets;
 use console_error_panic_hook;
-use log::{debug, error, info, trace, warn, Level};
-use std::cell::RefCell;
 use std::panic;
-use std::rc::Rc;
-use wasm_bindgen::prelude::*;
-use wasm_sockets;
 
 fn main() -> Result<(), JsValue> {
     panic::set_hook(Box::new(console_error_panic_hook::hook));
+    // console_log and log macros are used instead of println!
+    // so that messages can be seen in the browser console
     console_log::init_with_level(Level::Trace).expect("Failed to enable logging");
     info!("Creating connection");
 
     let mut client = wasm_sockets::EventClient::new("wss://echo.websocket.org")?;
-    client.set_on_error(Some(Box::new(|e| {
-        error!("{:#?}", e);
+    client.set_on_error(Some(Box::new(|error| {
+        error!("{:#?}", error);
     })));
-    client.set_on_connection(Some(Box::new(|c: &wasm_sockets::EventClient, e| {
-        info!("Connected: {:#?}", e);
-        info!("{:#?}", c.status);
+    client.set_on_connection(Some(Box::new(|client: &wasm_sockets::EventClient, e| {
+        info!("{:#?}", client.status);
         info!("Sending message...");
-        c.send_string("test...").unwrap();
-        c.send_binary(vec![20]).unwrap();
+        client.send_string("Hello, World!").unwrap();
+        client.send_binary(vec![20]).unwrap();
     })));
     client.set_on_close(Some(Box::new(|| {
-        info!("Closed");
+        info!("Connection closed");
     })));
     client.set_on_message(Some(Box::new(
-        |c: &wasm_sockets::EventClient, e: wasm_sockets::Message| {
-            info!("New Message: {:#?}", e);
+        |client: &wasm_sockets::EventClient, message: wasm_sockets::Message| {
+            info!("New Message: {:#?}", message);
         },
     )));
 

examples/polling.rs

 use console_error_panic_hook;
-use log::{debug, error, info, trace, warn, Level};
+use log::{info, Level};
 use std::cell::RefCell;
 use std::panic;
 use std::rc::Rc;
 use wasm_bindgen::prelude::*;
-use wasm_bindgen_futures;
-use wasm_sockets::{self, ConnectionStatus};
+use wasm_sockets::{self};
 
 fn main() -> Result<(), JsValue> {
     panic::set_hook(Box::new(console_error_panic_hook::hook));

src/lib.rs

+//! This crate offers 2 (wasm-only) websocket clients.
+//! The first client offered is the [`EventClient`]. This client is event based and gives you the most control.
+//! ```
+//! use log::{error, info, Level};
+//! use wasm_bindgen::JsValue;
+//! use wasm_sockets;
+//! use console_log;
+//!
+//! fn main() -> Result<(), JsValue> {
+//!     // console_log and log macros are used instead of println!
+//!     // so that messages can be seen in the browser console
+//!     console_log::init_with_level(Level::Trace).expect("Failed to enable logging");
+//!     info!("Creating connection");
+//!
+//!     let mut client = wasm_sockets::EventClient::new("wss://echo.websocket.org")?;
+//!     client.set_on_error(Some(Box::new(|error| {
+//!         error!("{:#?}", error);
+//!     })));
+//!     client.set_on_connection(Some(Box::new(|client: &wasm_sockets::EventClient, e| {
+//!         info!("{:#?}", client.status);
+//!         info!("Sending message...");
+//!         client.send_string("Hello, World!").unwrap();
+//!         client.send_binary(vec![20]).unwrap();
+//!     })));
+//!     client.set_on_close(Some(Box::new(|| {
+//!         info!("Connection closed");
+//!     })));
+//!     client.set_on_message(Some(Box::new(
+//!         |client: &wasm_sockets::EventClient, message: wasm_sockets::Message| {
+//!             info!("New Message: {:#?}", message);
+//!         },
+//!     )));
+//!
+//!     info!("Connection successfully created");
+//!     Ok(())
+//! }
+//! ```
+//! The second client offered is the [`PollingClient`]. This client is ideal for games, because it is designed to be used with a loop.
+//! This client is also much simpler than the [`EventClient`]. However, you can access the main [`EventClient`] that it is using
+//! if you want access to lower level control.
+//! ```
+//! use log::{info, Level};
+//! use std::cell::RefCell;
+//! use std::panic;
+//! use std::rc::Rc;
+//! use wasm_bindgen::prelude::*;
+//! use wasm_sockets::{self};
+//!
+//! fn main() -> Result<(), JsValue> {
+//!     // console_log and log macros are used instead of println!
+//!     // so that messages can be seen in the browser console
+//!     console_log::init_with_level(Level::Trace).expect("Failed to enable logging");
+//!     info!("Creating connection");
+//!
+//!     // Client is wrapped in an Rc<RefCell<>> so it can be used within setInterval
+//!     // This isn't required when being used within a game engine
+//!     let client = Rc::new(RefCell::new(wasm_sockets::PollingClient::new(
+//!         "wss://echo.websocket.org",
+//!     )?));
+//!
+//!     let f = Closure::wrap(Box::new(move || {
+//!         // receive() gives you all new websocket messages since receive() was last called
+//!         info!("New messages: {:#?}", client.borrow_mut().receive());
+//!     }) as Box<dyn FnMut()>);
+//!
+//!     // Start non-blocking game loop
+//!     setInterval(&f, 100);
+//!     f.forget();
+//!
+//!     Ok(())
+//! }
+//! // Bind setInterval to make a basic game loop
+//! #[wasm_bindgen]
+//! extern "C" {
+//!     fn setInterval(closure: &Closure<dyn FnMut()>, time: u32) -> i32;
+//! }
+//! ```
+
 use log::{debug, error, info, trace, warn, Level};
 use std::cell::RefCell;
 use std::rc::Rc;