Switch to parking_lot::{Mutex, RwLock}

Switch to the `parking_lot` crate's implementations of
`std::sync::Mutex` and `std::sync::RwLock`, which are more efficient.

A writeup on why `parking_lot` is more efficient can be read here:
<https://github.com/Amanieu/parking_lot>

Upgrade path:

Modify `mutex.lock().unwrap()` usage to `mutex.lock()` (not needing to
unwrap or handle a result), and
`rwlock.read().unwrap()`/`rwlock.write().unwrap()` usage to
`rwlock.read()` and `rwlock.write()`.

For example, modify:

```rust
use serenity::CACHE;

println!("{}", CACHE.read().unwrap().user.id);
```

to:

```rust
use serenity::CACHE;

println!("{}", CACHE.read().user.id);
```

7 files changed, 33 insertions, 40 deletions

diff --git a/src/client/bridge/gateway/shard_manager.rs b/src/client/bridge/gateway/shard_manager.rs
index 2068bef..4a50b56 100644
--- a/src/client/bridge/gateway/shard_manager.rs
+++ b/src/client/bridge/gateway/shard_manager.rs
@@ -1,8 +1,8 @@
 use internal::prelude::*;
-use parking_lot::Mutex as ParkingLotMutex;
+use parking_lot::Mutex;
 use std::collections::HashMap;
 use std::sync::mpsc::{self, Receiver, Sender};
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use std::thread;
 use super::super::super::EventHandler;
 use super::{
@@ -19,7 +19,7 @@ use typemap::ShareMap;
 use framework::Framework;
 
 pub struct ShardManager {
-    pub runners: Arc<ParkingLotMutex<HashMap<ShardId, ShardRunnerInfo>>>,
+    pub runners: Arc<Mutex<HashMap<ShardId, ShardRunnerInfo>>>,
     /// The index of the first shard to initialize, 0-indexed.
     shard_index: u64,
     /// The number of shards to initialize.
@@ -38,7 +38,7 @@ impl ShardManager {
         shard_total: u64,
         ws_url: Arc<Mutex<String>>,
         token: Arc<Mutex<String>>,
-        data: Arc<ParkingLotMutex<ShareMap>>,
+        data: Arc<Mutex<ShareMap>>,
         event_handler: Arc<H>,
         framework: Arc<Mutex<Option<Box<Framework + Send>>>>,
         threadpool: ThreadPool,
@@ -46,7 +46,7 @@ impl ShardManager {
         let (thread_tx, thread_rx) = mpsc::channel();
         let (shard_queue_tx, shard_queue_rx) = mpsc::channel();
 
-        let runners = Arc::new(ParkingLotMutex::new(HashMap::new()));
+        let runners = Arc::new(Mutex::new(HashMap::new()));
 
         let mut shard_queuer = ShardQueuer {
             data: data.clone(),
@@ -82,14 +82,14 @@ impl ShardManager {
         shard_total: u64,
         ws_url: Arc<Mutex<String>>,
         token: Arc<Mutex<String>>,
-        data: Arc<ParkingLotMutex<ShareMap>>,
+        data: Arc<Mutex<ShareMap>>,
         event_handler: Arc<H>,
         threadpool: ThreadPool,
     ) -> Self where H: EventHandler + Send + Sync + 'static {
         let (thread_tx, thread_rx) = mpsc::channel();
         let (shard_queue_tx, shard_queue_rx) = mpsc::channel();
 
-        let runners = Arc::new(ParkingLotMutex::new(HashMap::new()));
+        let runners = Arc::new(Mutex::new(HashMap::new()));
 
         let mut shard_queuer = ShardQueuer {
             data: data.clone(),
diff --git a/src/client/bridge/gateway/shard_queuer.rs b/src/client/bridge/gateway/shard_queuer.rs
index ea49de4..f75e35d 100644
--- a/src/client/bridge/gateway/shard_queuer.rs
+++ b/src/client/bridge/gateway/shard_queuer.rs
@@ -1,9 +1,9 @@
 use gateway::Shard;
 use internal::prelude::*;
-use parking_lot::Mutex as ParkingLotMutex;
+use parking_lot::Mutex;
 use std::collections::HashMap;
 use std::sync::mpsc::{Receiver, Sender};
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use std::thread;
 use std::time::{Duration, Instant};
 use super::super::super::EventHandler;
@@ -27,13 +27,13 @@ use framework::Framework;
 /// blocking nature of the loop itself as well as a 5 second thread sleep
 /// between shard starts.
 pub struct ShardQueuer<H: EventHandler + Send + Sync + 'static> {
-    pub data: Arc<ParkingLotMutex<ShareMap>>,
+    pub data: Arc<Mutex<ShareMap>>,
     pub event_handler: Arc<H>,
     #[cfg(feature = "framework")]
     pub framework: Arc<Mutex<Option<Box<Framework + Send>>>>,
     pub last_start: Option<Instant>,
     pub manager_tx: Sender<ShardManagerMessage>,
-    pub runners: Arc<ParkingLotMutex<HashMap<ShardId, ShardRunnerInfo>>>,
+    pub runners: Arc<Mutex<HashMap<ShardId, ShardRunnerInfo>>>,
     pub rx: Receiver<ShardQueuerMessage>,
     pub threadpool: ThreadPool,
     pub token: Arc<Mutex<String>>,
@@ -81,7 +81,7 @@ impl<H: EventHandler + Send + Sync + 'static> ShardQueuer<H> {
     fn start(&mut self, shard_id: ShardId, shard_total: ShardId) -> Result<()> {
         let shard_info = [shard_id.0, shard_total.0];
         let shard = Shard::new(self.ws_url.clone(), self.token.clone(), shard_info)?;
-        let locked = Arc::new(ParkingLotMutex::new(shard));
+        let locked = Arc::new(Mutex::new(shard));
 
         let mut runner = feature_framework! {{
             ShardRunner::new(
diff --git a/src/client/bridge/gateway/shard_runner.rs b/src/client/bridge/gateway/shard_runner.rs
index 1b1de0e..53d4b80 100644
--- a/src/client/bridge/gateway/shard_runner.rs
+++ b/src/client/bridge/gateway/shard_runner.rs
@@ -1,7 +1,7 @@
 use internal::prelude::*;
 use internal::ws_impl::ReceiverExt;
 use model::event::{Event, GatewayEvent};
-use parking_lot::Mutex as ParkingLotMutex;
+use parking_lot::Mutex;
 use std::sync::mpsc::{self, Receiver, Sender};
 use std::sync::Arc;
 use super::super::super::{EventHandler, dispatch};
@@ -12,11 +12,9 @@ use websocket::WebSocketError;
 
 #[cfg(feature = "framework")]
 use framework::Framework;
-#[cfg(feature = "framework")]
-use std::sync::Mutex;
 
 pub struct ShardRunner<H: EventHandler + Send + Sync + 'static> {
-    data: Arc<ParkingLotMutex<ShareMap>>,
+    data: Arc<Mutex<ShareMap>>,
     event_handler: Arc<H>,
     #[cfg(feature = "framework")]
     framework: Arc<Mutex<Option<Box<Framework + Send>>>>,
@@ -34,7 +32,7 @@ impl<H: EventHandler + Send + Sync + 'static> ShardRunner<H> {
         shard: LockedShard,
         manager_tx: Sender<ShardManagerMessage>,
         framework: Arc<Mutex<Option<Box<Framework + Send>>>>,
-        data: Arc<ParkingLotMutex<ShareMap>>,
+        data: Arc<Mutex<ShareMap>>,
         event_handler: Arc<H>,
         threadpool: ThreadPool,
     ) -> Self {
@@ -58,7 +56,7 @@ impl<H: EventHandler + Send + Sync + 'static> ShardRunner<H> {
     pub fn new(
         shard: LockedShard,
         manager_tx: Sender<ShardManagerMessage>,
-        data: Arc<ParkingLotMutex<ShareMap>>,
+        data: Arc<Mutex<ShareMap>>,
         event_handler: Arc<H>,
         threadpool: ThreadPool,
     ) -> Self {
diff --git a/src/client/context.rs b/src/client/context.rs
index 2288f28..18500d6 100644
--- a/src/client/context.rs
+++ b/src/client/context.rs
@@ -83,7 +83,7 @@ impl Context {
 
         feature_cache! {
             {
-                let cache = CACHE.read().unwrap();
+                let cache = CACHE.read();
 
                 map.insert("username".to_string(), Value::String(cache.user.name.clone()));
 
diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index 709e34b..aec6283 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -15,8 +15,6 @@ use framework::Framework;
 use model::GuildId;
 #[cfg(feature = "cache")]
 use std::{thread, time};
-#[cfg(feature = "framework")]
-use std::sync;
 
 #[cfg(feature = "cache")]
 use super::CACHE;
@@ -26,7 +24,7 @@ macro_rules! update {
         {
             #[cfg(feature="cache")]
             {
-                CACHE.write().unwrap().update(&mut $event)
+                CACHE.write().update(&mut $event)
             }
         }
     };
@@ -44,7 +42,7 @@ fn context(conn: Arc<Mutex<Shard>>, data: Arc<Mutex<ShareMap>>) -> Context {
 #[cfg(feature = "framework")]
 pub fn dispatch<H: EventHandler + 'static>(event: Event,
                                            conn: Arc<Mutex<Shard>>,
-                                           framework: Arc<sync::Mutex<Option<Box<Framework + Send>>>>,
+                                           framework: Arc<Mutex<Option<Box<Framework + Send>>>>,
                                            data: Arc<Mutex<ShareMap>>,
                                            event_handler: Arc<H>) {
     match event {
@@ -56,7 +54,7 @@ pub fn dispatch<H: EventHandler + 'static>(event: Event,
                 event_handler,
             );
 
-            if let Some(ref mut framework) = *framework.lock().unwrap() {
+            if let Some(ref mut framework) = *framework.lock() {
                 framework.dispatch(context, event.message);
             }
         },
@@ -102,7 +100,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
     #[cfg(feature = "cache")]
     let wait_for_guilds = move || -> ::Result<()> {
-        let unavailable_guilds = CACHE.read().unwrap().unavailable_guilds.len();
+        let unavailable_guilds = CACHE.read().unavailable_guilds.len();
 
         while unavailable_guilds != 0 && (now!() < last_guild_create_time + 2000) {
             thread::sleep(time::Duration::from_millis(500));
@@ -173,7 +171,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
             let context = context(conn, data);
 
             feature_cache! {{
-                let before = CACHE.read().unwrap().channel(event.channel.id());
+                let before = CACHE.read().channel(event.channel.id());
                 event_handler.on_channel_update(context, before, event.channel);
             } else {
                 event_handler.on_channel_update(context, event.channel);
@@ -192,7 +190,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
         Event::GuildCreate(mut event) => {
             #[cfg(feature = "cache")]
             let _is_new = {
-                let cache = CACHE.read().unwrap();
+                let cache = CACHE.read();
 
                 !cache.unavailable_guilds.contains(&event.guild.id)
             };
@@ -203,7 +201,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
             {
                 last_guild_create_time = now!();
 
-                let cache = CACHE.read().unwrap();
+                let cache = CACHE.read();
 
                 if cache.unavailable_guilds.is_empty() {
                     let context = context(conn.clone(), data.clone());
@@ -274,7 +272,6 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
                 // the member if it did not exist. So, there is be _no_ way
                 // that this could fail under any circumstance.
                 let after = CACHE.read()
-                    .unwrap()
                     .member(event.guild_id, event.user.id)
                     .unwrap()
                     .clone();
@@ -332,7 +329,6 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             feature_cache! {{
                 let before = CACHE.read()
-                    .unwrap()
                     .guilds
                     .get(&event.guild.id)
                     .cloned();
diff --git a/src/client/event_handler.rs b/src/client/event_handler.rs
index 6e3c78e..0c618c2 100644
--- a/src/client/event_handler.rs
+++ b/src/client/event_handler.rs
@@ -1,3 +1,4 @@
+use parking_lot::RwLock;
 use serde_json::Value;
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -5,8 +6,6 @@ use super::context::Context;
 use model::event::*;
 use model::*;
 
-use std::sync::RwLock;
-
 pub trait EventHandler {
     #[cfg(feature = "cache")]
     fn on_cached(&self, _: Context, _: Vec<GuildId>) {}
diff --git a/src/client/mod.rs b/src/client/mod.rs
index f2fb297..c17e284 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -39,7 +39,7 @@ pub use CACHE;
 
 use self::bridge::gateway::{ShardId, ShardManager, ShardRunnerInfo};
 use self::dispatch::dispatch;
-use std::sync::{self, Arc};
+use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering, ATOMIC_BOOL_INIT};
 use parking_lot::Mutex;
 use std::collections::HashMap;
@@ -192,7 +192,7 @@ pub struct Client<H: EventHandler + Send + Sync + 'static> {
     /// [`Event::Ready`]: ../model/event/enum.Event.html#variant.Ready
     /// [`on_ready`]: #method.on_ready
     event_handler: Arc<H>,
-    #[cfg(feature = "framework")] framework: Arc<sync::Mutex<Option<Box<Framework + Send>>>>,
+    #[cfg(feature = "framework")] framework: Arc<Mutex<Option<Box<Framework + Send>>>>,
     /// A HashMap of all shards instantiated by the Client.
     ///
     /// The key is the shard ID and the value is the shard itself.
@@ -250,7 +250,7 @@ pub struct Client<H: EventHandler + Send + Sync + 'static> {
     /// Defaults to 5 threads, which should suffice small bots. Consider
     /// increasing this number as your bot grows.
     pub threadpool: ThreadPool,
-    token: Arc<sync::Mutex<String>>,
+    token: Arc<Mutex<String>>,
 }
 
 impl<H: EventHandler + Send + Sync + 'static> Client<H> {
@@ -291,7 +291,7 @@ impl<H: EventHandler + Send + Sync + 'static> Client<H> {
         };
 
         http::set_token(&token);
-        let locked = Arc::new(sync::Mutex::new(token));
+        let locked = Arc::new(Mutex::new(token));
 
         let name = "serenity client".to_owned();
         let threadpool = ThreadPool::with_name(name, 5);
@@ -300,7 +300,7 @@ impl<H: EventHandler + Send + Sync + 'static> Client<H> {
             Client {
                 data: Arc::new(Mutex::new(ShareMap::custom())),
                 event_handler: Arc::new(handler),
-                framework: Arc::new(sync::Mutex::new(None)),
+                framework: Arc::new(Mutex::new(None)),
                 shard_runners: Arc::new(Mutex::new(HashMap::new())),
                 threadpool,
                 token: locked,
@@ -417,7 +417,7 @@ impl<H: EventHandler + Send + Sync + 'static> Client<H> {
     /// [framework docs]: ../framework/index.html
     #[cfg(feature = "framework")]
     pub fn with_framework<F: Framework + Send + 'static>(&mut self, f: F) {
-        self.framework = Arc::new(sync::Mutex::new(Some(Box::new(f))));
+        self.framework = Arc::new(Mutex::new(Some(Box::new(f))));
     }
 
     /// Establish the connection and start listening for events.
@@ -755,12 +755,12 @@ impl<H: EventHandler + Send + Sync + 'static> Client<H> {
         {
             let user = http::get_current_user()?;
 
-            if let Some(ref mut framework) = *self.framework.lock().unwrap() {
+            if let Some(ref mut framework) = *self.framework.lock() {
                 framework.update_current_user(user.id, user.bot);
             }
         }
 
-        let gateway_url = Arc::new(sync::Mutex::new(url));
+        let gateway_url = Arc::new(Mutex::new(url));
 
         let mut manager = ShardManager::new(
             shard_data[0],