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);
```

16 files changed, 152 insertions, 159 deletions

diff --git a/src/model/channel/channel_id.rs b/src/model/channel/channel_id.rs
index f728191..4034fb9 100644
--- a/src/model/channel/channel_id.rs
+++ b/src/model/channel/channel_id.rs
@@ -224,14 +224,14 @@ impl ChannelId {
 
     /// Search the cache for the channel with the Id.
     #[cfg(feature = "cache")]
-    pub fn find(&self) -> Option<Channel> { CACHE.read().unwrap().channel(*self) }
+    pub fn find(&self) -> Option<Channel> { CACHE.read().channel(*self) }
 
     /// Search the cache for the channel. If it can't be found, the channel is
     /// requested over REST.
     pub fn get(&self) -> Result<Channel> {
         #[cfg(feature = "cache")]
         {
-            if let Some(channel) = CACHE.read().unwrap().channel(*self) {
+            if let Some(channel) = CACHE.read().channel(*self) {
                 return Ok(channel);
             }
         }
@@ -311,13 +311,13 @@ impl ChannelId {
         };
 
         Some(match channel {
-            Guild(channel) => channel.read().unwrap().name().to_string(),
-            Group(channel) => match channel.read().unwrap().name() {
+            Guild(channel) => channel.read().name().to_string(),
+            Group(channel) => match channel.read().name() {
                 Cow::Borrowed(name) => name.to_string(),
                 Cow::Owned(name) => name,
             },
-            Category(category) => category.read().unwrap().name().to_string(),
-            Private(channel) => channel.read().unwrap().name(),
+            Category(category) => category.read().name().to_string(),
+            Private(channel) => channel.read().name(),
         })
     }
 
diff --git a/src/model/channel/guild_channel.rs b/src/model/channel/guild_channel.rs
index e2e5f09..cc74b9d 100644
--- a/src/model/channel/guild_channel.rs
+++ b/src/model/channel/guild_channel.rs
@@ -157,12 +157,12 @@ impl GuildChannel {
     ///     kind: PermissionOverwriteType::Member(user_id),
     /// };
     ///
-    /// let cache = CACHE.read().unwrap();
+    /// let cache = CACHE.read();
     /// let channel = cache
     ///     .guild_channel(channel_id)
     ///     .ok_or(ModelError::ItemMissing)?;
     ///
-    /// channel.read().unwrap().create_permission(&overwrite)?;
+    /// channel.read().create_permission(&overwrite)?;
     /// #     Ok(())
     /// # }
     /// #
@@ -199,12 +199,12 @@ impl GuildChannel {
     ///     kind: PermissionOverwriteType::Member(user_id),
     /// };
     ///
-    /// let cache = CACHE.read().unwrap();
+    /// let cache = CACHE.read();
     /// let channel = cache
     ///     .guild_channel(channel_id)
     ///     .ok_or(ModelError::ItemMissing)?;
     ///
-    /// channel.read().unwrap().create_permission(&overwrite)?;
+    /// channel.read().create_permission(&overwrite)?;
     /// #     Ok(())
     /// # }
     /// #
@@ -365,7 +365,7 @@ impl GuildChannel {
     /// **Note**: Right now this performs a clone of the guild. This will be
     /// optimized in the future.
     #[cfg(feature = "cache")]
-    pub fn guild(&self) -> Option<Arc<RwLock<Guild>>> { CACHE.read().unwrap().guild(self.guild_id) }
+    pub fn guild(&self) -> Option<Arc<RwLock<Guild>>> { CACHE.read().guild(self.guild_id) }
 
     /// Gets all of the channel's invites.
     ///
@@ -436,12 +436,12 @@ impl GuildChannel {
     ///
     /// impl EventHandler for Handler {
     ///     fn on_message(&self, _: Context, msg: Message) {
-    ///         let channel = match CACHE.read().unwrap().guild_channel(msg.channel_id) {
+    ///         let channel = match CACHE.read().guild_channel(msg.channel_id) {
     ///             Some(channel) => channel,
     ///             None => return,
     ///         };
     ///
-    ///         let permissions = channel.read().unwrap().permissions_for(&msg.author).unwrap();
+    ///         let permissions = channel.read().permissions_for(&msg.author).unwrap();
     ///
     ///         println!("The user's permissions: {:?}", permissions);
     ///     }
@@ -464,14 +464,14 @@ impl GuildChannel {
     ///
     /// impl EventHandler for Handler {
     ///     fn on_message(&self, _: Context, msg: Message) {
-    ///         let channel = match CACHE.read().unwrap().guild_channel(msg.channel_id) {
+    ///         let channel = match CACHE.read().guild_channel(msg.channel_id) {
     ///             Some(channel) => channel,
     ///             None => return,
     ///         };
     ///
-    ///         let current_user_id = CACHE.read().unwrap().user.id;
+    ///         let current_user_id = CACHE.read().user.id;
     /// let permissions =
-    /// channel.read().unwrap().permissions_for(current_user_id).unwrap();
+    /// channel.read().permissions_for(current_user_id).unwrap();
     ///
     /// if !permissions.contains(Permissions::ATTACH_FILES |
     /// Permissions::SEND_MESSAGES) {
@@ -512,7 +512,7 @@ impl GuildChannel {
     pub fn permissions_for<U: Into<UserId>>(&self, user_id: U) -> Result<Permissions> {
         self.guild()
             .ok_or_else(|| Error::Model(ModelError::GuildNotFound))
-            .map(|g| g.read().unwrap().permissions_for(self.id, user_id))
+            .map(|g| g.read().permissions_for(self.id, user_id))
     }
 
     /// Pins a [`Message`] to the channel.
diff --git a/src/model/channel/message.rs b/src/model/channel/message.rs
index 55f61ba..f6efd74 100644
--- a/src/model/channel/message.rs
+++ b/src/model/channel/message.rs
@@ -97,12 +97,12 @@ impl Message {
     ///
     /// command!(channel_name(_ctx, msg) {
     ///     let _ = match msg.channel() {
-    ///         Some(Channel::Category(c)) => msg.reply(&c.read().unwrap().name),
-    ///         Some(Channel::Group(c)) => msg.reply(&c.read().unwrap().name()),
-    ///         Some(Channel::Guild(c)) => msg.reply(&c.read().unwrap().name),
+    ///         Some(Channel::Category(c)) => msg.reply(&c.read().name),
+    ///         Some(Channel::Group(c)) => msg.reply(&c.read().name()),
+    ///         Some(Channel::Guild(c)) => msg.reply(&c.read().name),
     ///         Some(Channel::Private(c)) => {
-    ///             let channel = c.read().unwrap();
-    ///             let user = channel.recipient.read().unwrap();
+    ///             let channel = c.read();
+    ///             let user = channel.recipient.read();
     ///
     ///             msg.reply(&format!("DM with {}", user.name.clone()))
     ///         },
@@ -113,12 +113,12 @@ impl Message {
     /// ```
     #[cfg(feature = "cache")]
     #[inline]
-    pub fn channel(&self) -> Option<Channel> { CACHE.read().unwrap().channel(self.channel_id) }
+    pub fn channel(&self) -> Option<Channel> { CACHE.read().channel(self.channel_id) }
 
     /// A util function for determining whether this message was sent by someone else, or the
     /// bot.
     #[cfg(all(feature = "cache", feature = "utils"))]
-    pub fn is_own(&self) -> bool { self.author.id == CACHE.read().unwrap().user.id }
+    pub fn is_own(&self) -> bool { self.author.id == CACHE.read().user.id }
 
     /// Deletes the message.
     ///
@@ -138,7 +138,7 @@ impl Message {
         #[cfg(feature = "cache")]
         {
             let req = Permissions::MANAGE_MESSAGES;
-            let is_author = self.author.id == CACHE.read().unwrap().user.id;
+            let is_author = self.author.id == CACHE.read().user.id;
             let has_perms = utils::user_has_perms(self.channel_id, req)?;
 
             if !is_author && !has_perms {
@@ -211,7 +211,7 @@ impl Message {
         where F: FnOnce(CreateMessage) -> CreateMessage {
         #[cfg(feature = "cache")]
         {
-            if self.author.id != CACHE.read().unwrap().user.id {
+            if self.author.id != CACHE.read().user.id {
                 return Err(Error::Model(ModelError::InvalidUser));
             }
         }
@@ -335,7 +335,7 @@ impl Message {
     #[cfg(feature = "cache")]
     pub fn guild(&self) -> Option<Arc<RwLock<Guild>>> {
         self.guild_id()
-            .and_then(|guild_id| CACHE.read().unwrap().guild(guild_id))
+            .and_then(|guild_id| CACHE.read().guild(guild_id))
     }
 
     /// Retrieves the Id of the guild that the message was sent in, if sent in
@@ -345,8 +345,8 @@ impl Message {
     /// cache.
     #[cfg(feature = "cache")]
     pub fn guild_id(&self) -> Option<GuildId> {
-        match CACHE.read().unwrap().channel(self.channel_id) {
-            Some(Channel::Guild(ch)) => Some(ch.read().unwrap().guild_id),
+        match CACHE.read().channel(self.channel_id) {
+            Some(Channel::Guild(ch)) => Some(ch.read().guild_id),
             _ => None,
         }
     }
@@ -354,7 +354,7 @@ impl Message {
     /// True if message was sent using direct messages.
     #[cfg(feature = "cache")]
     pub fn is_private(&self) -> bool {
-        match CACHE.read().unwrap().channel(self.channel_id) {
+        match CACHE.read().channel(self.channel_id) {
             Some(Channel::Group(_)) | Some(Channel::Private(_)) => true,
             _ => false,
         }
diff --git a/src/model/channel/mod.rs b/src/model/channel/mod.rs
index 4ba0322..f7ecc0f 100644
--- a/src/model/channel/mod.rs
+++ b/src/model/channel/mod.rs
@@ -83,16 +83,16 @@ impl Channel {
     pub fn delete(&self) -> Result<()> {
         match *self {
             Channel::Group(ref group) => {
-                let _ = group.read().unwrap().leave()?;
+                let _ = group.read().leave()?;
             },
             Channel::Guild(ref public_channel) => {
-                let _ = public_channel.read().unwrap().delete()?;
+                let _ = public_channel.read().delete()?;
             },
             Channel::Private(ref private_channel) => {
-                let _ = private_channel.read().unwrap().delete()?;
+                let _ = private_channel.read().delete()?;
             },
             Channel::Category(ref category) => {
-                category.read().unwrap().delete()?;
+                category.read().delete()?;
             },
         }
 
@@ -375,15 +375,15 @@ impl Display for Channel {
     /// [`PrivateChannel`]: struct.PrivateChannel.html
     fn fmt(&self, f: &mut Formatter) -> FmtResult {
         match *self {
-            Channel::Group(ref group) => Display::fmt(&group.read().unwrap().name(), f),
-            Channel::Guild(ref ch) => Display::fmt(&ch.read().unwrap().id.mention(), f),
+            Channel::Group(ref group) => Display::fmt(&group.read().name(), f),
+            Channel::Guild(ref ch) => Display::fmt(&ch.read().id.mention(), f),
             Channel::Private(ref ch) => {
-                let channel = ch.read().unwrap();
-                let recipient = channel.recipient.read().unwrap();
+                let channel = ch.read();
+                let recipient = channel.recipient.read();
 
                 Display::fmt(&recipient.name, f)
             },
-            Channel::Category(ref category) => Display::fmt(&category.read().unwrap().name, f),
+            Channel::Category(ref category) => Display::fmt(&category.read().name, f),
         }
     }
 }
diff --git a/src/model/channel/private_channel.rs b/src/model/channel/private_channel.rs
index d6ba781..01b387a 100644
--- a/src/model/channel/private_channel.rs
+++ b/src/model/channel/private_channel.rs
@@ -279,6 +279,6 @@ impl PrivateChannel {
 impl Display for PrivateChannel {
     /// Formats the private channel, displaying the recipient's username.
     fn fmt(&self, f: &mut Formatter) -> FmtResult {
-        f.write_str(&self.recipient.read().unwrap().name)
+        f.write_str(&self.recipient.read().name)
     }
 }
diff --git a/src/model/channel/reaction.rs b/src/model/channel/reaction.rs
index 8edc2e9..1a40ecb 100644
--- a/src/model/channel/reaction.rs
+++ b/src/model/channel/reaction.rs
@@ -48,7 +48,7 @@ impl Reaction {
     pub fn delete(&self) -> Result<()> {
         let user_id = feature_cache! {
             {
-                let user = if self.user_id == CACHE.read().unwrap().user.id {
+                let user = if self.user_id == CACHE.read().user.id {
                     None
                 } else {
                     Some(self.user_id.0)
diff --git a/src/model/event.rs b/src/model/event.rs
index fe65269..8d949c7 100644
--- a/src/model/event.rs
+++ b/src/model/event.rs
@@ -61,7 +61,7 @@ impl CacheUpdate for ChannelCreateEvent {
 
                 let channel_id = group.with_mut(|writer| {
                     for (recipient_id, recipient) in &mut writer.recipients {
-                        cache.update_user_entry(&recipient.read().unwrap());
+                        cache.update_user_entry(&recipient.read());
 
                         *recipient = cache.users[recipient_id].clone();
                     }
@@ -110,7 +110,7 @@ impl CacheUpdate for ChannelCreateEvent {
             },
             Channel::Category(ref category) => cache
                 .categories
-                .insert(category.read().unwrap().id, category.clone())
+                .insert(category.read().id, category.clone())
                 .map(Channel::Category),
         }
     }
@@ -214,7 +214,7 @@ impl CacheUpdate for ChannelRecipientAddEvent {
         let user = cache.users[&self.user.id].clone();
 
         cache.groups.get_mut(&self.channel_id).map(|group| {
-            group.write().unwrap().recipients.insert(self.user.id, user);
+            group.write().recipients.insert(self.user.id, user);
         });
 
         None
@@ -263,16 +263,16 @@ impl CacheUpdate for ChannelUpdateEvent {
                         e.insert(group.clone());
                     },
                     Entry::Occupied(mut e) => {
-                        let mut dest = e.get_mut().write().unwrap();
+                        let mut dest = e.get_mut().write();
 
                         if no_recipients {
                             let recipients = mem::replace(&mut dest.recipients, HashMap::new());
 
-                            dest.clone_from(&group.read().unwrap());
+                            dest.clone_from(&group.read());
 
                             dest.recipients = recipients;
                         } else {
-                            dest.clone_from(&group.read().unwrap());
+                            dest.clone_from(&group.read());
                         }
                     },
                 }
@@ -289,13 +289,13 @@ impl CacheUpdate for ChannelUpdateEvent {
             Channel::Private(ref channel) => {
                 cache
                     .private_channels
-                    .get_mut(&channel.read().unwrap().id)
+                    .get_mut(&channel.read().id)
                     .map(|private| private.clone_from(channel));
             },
             Channel::Category(ref category) => {
                 cache
                     .categories
-                    .get_mut(&category.read().unwrap().id)
+                    .get_mut(&category.read().id)
                     .map(|c| c.clone_from(category));
             },
         }
@@ -340,7 +340,7 @@ impl CacheUpdate for GuildCreateEvent {
         let mut guild = self.guild.clone();
 
         for (user_id, member) in &mut guild.members {
-            cache.update_user_entry(&member.user.read().unwrap());
+            cache.update_user_entry(&member.user.read());
             let user = cache.users[user_id].clone();
 
             member.user = user.clone();
@@ -375,7 +375,7 @@ impl CacheUpdate for GuildDeleteEvent {
     fn update(&mut self, cache: &mut Cache) -> Option<Self::Output> {
         // Remove channel entries for the guild if the guild is found.
         cache.guilds.remove(&self.guild.id).map(|guild| {
-            for channel_id in guild.write().unwrap().channels.keys() {
+            for channel_id in guild.write().channels.keys() {
                 cache.channels.remove(channel_id);
             }
 
@@ -428,7 +428,7 @@ impl CacheUpdate for GuildMemberAddEvent {
 
     fn update(&mut self, cache: &mut Cache) -> Option<()> {
         let user_id = self.member.user.with(|u| u.id);
-        cache.update_user_entry(&self.member.user.read().unwrap());
+        cache.update_user_entry(&self.member.user.read());
 
         // Always safe due to being inserted above.
         self.member.user = cache.users[&user_id].clone();
@@ -498,7 +498,7 @@ impl CacheUpdate for GuildMemberUpdateEvent {
         cache.update_user_entry(&self.user);
 
         if let Some(guild) = cache.guilds.get_mut(&self.guild_id) {
-            let mut guild = guild.write().unwrap();
+            let mut guild = guild.write();
 
             let mut found = false;
 
@@ -507,7 +507,7 @@ impl CacheUpdate for GuildMemberUpdateEvent {
 
                 member.nick.clone_from(&self.nick);
                 member.roles.clone_from(&self.roles);
-                member.user.write().unwrap().clone_from(&self.user);
+                member.user.write().clone_from(&self.user);
 
                 found = true;
 
@@ -550,7 +550,7 @@ impl CacheUpdate for GuildMembersChunkEvent {
 
     fn update(&mut self, cache: &mut Cache) -> Option<()> {
         for member in self.members.values() {
-            cache.update_user_entry(&member.user.read().unwrap());
+            cache.update_user_entry(&member.user.read());
         }
 
         cache.guilds.get_mut(&self.guild_id).map(|guild| {
@@ -607,7 +607,6 @@ impl CacheUpdate for GuildRoleCreateEvent {
         cache.guilds.get_mut(&self.guild_id).map(|guild| {
             guild
                 .write()
-                .unwrap()
                 .roles
                 .insert(self.role.id, self.role.clone())
         });
@@ -683,7 +682,7 @@ impl CacheUpdate for GuildUpdateEvent {
 
     fn update(&mut self, cache: &mut Cache) -> Option<()> {
         cache.guilds.get_mut(&self.guild.id).map(|guild| {
-            let mut guild = guild.write().unwrap();
+            let mut guild = guild.write();
 
             guild.afk_timeout = self.guild.afk_timeout;
             guild.afk_channel_id.clone_from(&self.guild.afk_channel_id);
@@ -766,13 +765,13 @@ impl CacheUpdate for PresenceUpdateEvent {
         let user_id = self.presence.user_id;
 
         if let Some(user) = self.presence.user.as_mut() {
-            cache.update_user_entry(&user.read().unwrap());
+            cache.update_user_entry(&user.read());
             *user = cache.users[&user_id].clone();
         }
 
         if let Some(guild_id) = self.guild_id {
             if let Some(guild) = cache.guilds.get_mut(&guild_id) {
-                let mut guild = guild.write().unwrap();
+                let mut guild = guild.write();
 
                 // If the member went offline, remove them from the presence list.
                 if self.presence.status == OnlineStatus::Offline {
@@ -918,7 +917,7 @@ impl CacheUpdate for ReadyEvent {
 
         for (user_id, presence) in &mut ready.presences {
             if let Some(ref user) = presence.user {
-                cache.update_user_entry(&user.read().unwrap());
+                cache.update_user_entry(&user.read());
             }
 
             presence.user = cache.users.get(user_id).cloned();
@@ -1002,7 +1001,7 @@ impl CacheUpdate for VoiceStateUpdateEvent {
     fn update(&mut self, cache: &mut Cache) -> Option<()> {
         if let Some(guild_id) = self.guild_id {
             if let Some(guild) = cache.guilds.get_mut(&guild_id) {
-                let mut guild = guild.write().unwrap();
+                let mut guild = guild.write();
 
                 if self.voice_state.channel_id.is_some() {
                     // Update or add to the voice state list
diff --git a/src/model/gateway.rs b/src/model/gateway.rs
index 4edc20e..ca846e8 100644
--- a/src/model/gateway.rs
+++ b/src/model/gateway.rs
@@ -1,6 +1,7 @@
+use parking_lot::RwLock;
 use serde::de::Error as DeError;
 use serde_json;
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
 use super::utils::*;
 use super::*;
 
diff --git a/src/model/guild/emoji.rs b/src/model/guild/emoji.rs
index 4a2190f..7f332ae 100644
--- a/src/model/guild/emoji.rs
+++ b/src/model/guild/emoji.rs
@@ -151,8 +151,8 @@ impl Emoji {
     /// ```
     #[cfg(feature = "cache")]
     pub fn find_guild_id(&self) -> Option<GuildId> {
-        for guild in CACHE.read().unwrap().guilds.values() {
-            let guild = guild.read().unwrap();
+        for guild in CACHE.read().guilds.values() {
+            let guild = guild.read();
 
             if guild.emojis.contains_key(&self.id) {
                 return Some(guild.id);
diff --git a/src/model/guild/guild_id.rs b/src/model/guild/guild_id.rs
index 4b9a713..efda6a8 100644
--- a/src/model/guild/guild_id.rs
+++ b/src/model/guild/guild_id.rs
@@ -305,7 +305,7 @@ impl GuildId {
 
     /// Search the cache for the guild.
     #[cfg(feature = "cache")]
-    pub fn find(&self) -> Option<Arc<RwLock<Guild>>> { CACHE.read().unwrap().guild(*self) }
+    pub fn find(&self) -> Option<Arc<RwLock<Guild>>> { CACHE.read().guild(*self) }
 
     /// Requests the guild over REST.
     ///
@@ -408,7 +408,7 @@ impl GuildId {
     /// [`utils::shard_id`]: ../utils/fn.shard_id.html
     #[cfg(all(feature = "cache", feature = "utils"))]
     #[inline]
-    pub fn shard_id(&self) -> u64 { ::utils::shard_id(self.0, CACHE.read().unwrap().shard_count) }
+    pub fn shard_id(&self) -> u64 { ::utils::shard_id(self.0, CACHE.read().shard_count) }
 
     /// Returns the Id of the shard associated with the guild.
     ///
diff --git a/src/model/guild/member.rs b/src/model/guild/member.rs
index 694de20..bca3ecb 100644
--- a/src/model/guild/member.rs
+++ b/src/model/guild/member.rs
@@ -88,7 +88,7 @@ impl Member {
             return Ok(());
         }
 
-        match http::add_member_role(self.guild_id.0, self.user.read().unwrap().id.0, role_id.0) {
+        match http::add_member_role(self.guild_id.0, self.user.read().id.0, role_id.0) {
             Ok(()) => {
                 self.roles.push(role_id);
 
@@ -111,7 +111,7 @@ impl Member {
 
         let map = EditMember::default().roles(&self.roles).0;
 
-        match http::edit_member(self.guild_id.0, self.user.read().unwrap().id.0, &map) {
+        match http::edit_member(self.guild_id.0, self.user.read().id.0, &map) {
             Ok(()) => Ok(()),
             Err(why) => {
                 self.roles.retain(|r| !role_ids.contains(r));
@@ -149,7 +149,7 @@ impl Member {
 
         http::ban_user(
             self.guild_id.0,
-            self.user.read().unwrap().id.0,
+            self.user.read().id.0,
             dmd,
             &*reason,
         )
@@ -158,9 +158,9 @@ impl Member {
     /// Determines the member's colour.
     #[cfg(all(feature = "cache", feature = "utils"))]
     pub fn colour(&self) -> Option<Colour> {
-        let cache = CACHE.read().unwrap();
+        let cache = CACHE.read();
         let guild = match cache.guilds.get(&self.guild_id) {
-            Some(guild) => guild.read().unwrap(),
+            Some(guild) => guild.read(),
             None => return None,
         };
 
@@ -187,10 +187,10 @@ impl Member {
             None => return None,
         };
 
-        let reader = guild.read().unwrap();
+        let reader = guild.read();
 
         for (cid, channel) in &reader.channels {
-            if reader.permissions_for(*cid, self.user.read().unwrap().id).read_messages() {
+            if reader.permissions_for(*cid, self.user.read().id).read_messages() {
                 return Some(channel.clone());
             }
         }
@@ -206,7 +206,7 @@ impl Member {
         self.nick
             .as_ref()
             .map(Cow::Borrowed)
-            .unwrap_or_else(|| Cow::Owned(self.user.read().unwrap().name.clone()))
+            .unwrap_or_else(|| Cow::Owned(self.user.read().name.clone()))
     }
 
     /// Returns the DiscordTag of a Member, taking possible nickname into account.
@@ -215,7 +215,7 @@ impl Member {
         format!(
             "{}#{}",
             self.display_name(),
-            self.user.read().unwrap().discriminator
+            self.user.read().discriminator
         )
     }
 
@@ -231,7 +231,7 @@ impl Member {
     pub fn edit<F: FnOnce(EditMember) -> EditMember>(&self, f: F) -> Result<()> {
         let map = f(EditMember::default()).0;
 
-        http::edit_member(self.guild_id.0, self.user.read().unwrap().id.0, &map)
+        http::edit_member(self.guild_id.0, self.user.read().id.0, &map)
     }
 
     /// Kick the member from the guild.
@@ -274,17 +274,16 @@ impl Member {
 
             let has_perms = CACHE
                 .read()
-                .unwrap()
                 .guilds
                 .get(&self.guild_id)
-                .map(|guild| guild.read().unwrap().has_perms(req));
+                .map(|guild| guild.read().has_perms(req));
 
             if let Some(Ok(false)) = has_perms {
                 return Err(Error::Model(ModelError::InvalidPermissions(req)));
             }
         }
 
-        self.guild_id.kick(self.user.read().unwrap().id)
+        self.guild_id.kick(self.user.read().id)
     }
 
     /// Returns the permissions for the member.
@@ -314,18 +313,18 @@ impl Member {
             None => return Err(From::from(ModelError::GuildNotFound)),
         };
 
-        let guild = guild.read().unwrap();
+        let guild = guild.read();
 
-        let default_channel = match guild.default_channel(self.user.read().unwrap().id) {
+        let default_channel = match guild.default_channel(self.user.read().id) {
             Some(dc) => dc,
             None => return Err(From::from(ModelError::ItemMissing)),
         };
 
-        let default_channel_reader = default_channel.read().unwrap();
+        let default_channel_reader = default_channel.read();
 
         Ok(
             guild
-                .permissions_for(default_channel_reader.id, self.user.read().unwrap().id),
+                .permissions_for(default_channel_reader.id, self.user.read().id),
         )
     }
 
@@ -344,7 +343,7 @@ impl Member {
             return Ok(());
         }
 
-        match http::remove_member_role(self.guild_id.0, self.user.read().unwrap().id.0, role_id.0) {
+        match http::remove_member_role(self.guild_id.0, self.user.read().id.0, role_id.0) {
             Ok(()) => {
                 self.roles.retain(|r| r.0 != role_id.0);
 
@@ -366,7 +365,7 @@ impl Member {
 
         let map = EditMember::default().roles(&self.roles).0;
 
-        match http::edit_member(self.guild_id.0, self.user.read().unwrap().id.0, &map) {
+        match http::edit_member(self.guild_id.0, self.user.read().id.0, &map) {
             Ok(()) => Ok(()),
             Err(why) => {
                 self.roles.extend_from_slice(role_ids);
@@ -385,19 +384,17 @@ impl Member {
     pub fn roles(&self) -> Option<Vec<Role>> {
         CACHE
             .read()
-            .unwrap()
             .guilds
             .values()
             .find(|guild| {
-                guild.read().unwrap().members.values().any(|m| {
-                    m.user.read().unwrap().id == self.user.read().unwrap().id &&
+                guild.read().members.values().any(|m| {
+                    m.user.read().id == self.user.read().id &&
                     m.joined_at == self.joined_at
                 })
             })
             .map(|guild| {
                 guild
                     .read()
-                    .unwrap()
                     .roles
                     .values()
                     .filter(|role| self.roles.contains(&role.id))
@@ -420,7 +417,7 @@ impl Member {
     /// [Ban Members]: permissions/constant.BAN_MEMBERS.html
     #[cfg(feature = "cache")]
     pub fn unban(&self) -> Result<()> {
-        http::remove_ban(self.guild_id.0, self.user.read().unwrap().id.0)
+        http::remove_ban(self.guild_id.0, self.user.read().id.0)
     }
 }
 
@@ -436,6 +433,6 @@ impl Display for Member {
     ///
     // This is in the format of `<@USER_ID>`.
     fn fmt(&self, f: &mut Formatter) -> FmtResult {
-        Display::fmt(&self.user.read().unwrap().mention(), f)
+        Display::fmt(&self.user.read().mention(), f)
     }
 }
diff --git a/src/model/guild/mod.rs b/src/model/guild/mod.rs
index 73dfa73..ea6cb17 100644
--- a/src/model/guild/mod.rs
+++ b/src/model/guild/mod.rs
@@ -155,17 +155,17 @@ impl Guild {
 
     #[cfg(feature = "cache")]
     fn has_perms(&self, mut permissions: Permissions) -> Result<bool> {
-        let member = match self.members.get(&CACHE.read().unwrap().user.id) {
+        let member = match self.members.get(&CACHE.read().user.id) {
             Some(member) => member,
             None => return Err(Error::Model(ModelError::ItemMissing)),
         };
 
-        let default_channel = match self.default_channel(member.user.read().unwrap().id) {
+        let default_channel = match self.default_channel(member.user.read().id) {
             Some(dc) => dc,
             None => return Err(Error::Model(ModelError::ItemMissing)),
         };
 
-        let perms = self.permissions_for(default_channel.read().unwrap().id, member.user.read().unwrap().id);
+        let perms = self.permissions_for(default_channel.read().id, member.user.read().id);
         permissions.remove(perms);
 
         Ok(permissions.is_empty())
@@ -406,7 +406,7 @@ impl Guild {
     pub fn delete(&self) -> Result<PartialGuild> {
         #[cfg(feature = "cache")]
         {
-            if self.owner_id != CACHE.read().unwrap().user.id {
+            if self.owner_id != CACHE.read().user.id {
                 let req = Permissions::MANAGE_GUILD;
 
                 return Err(Error::Model(ModelError::InvalidPermissions(req)));
@@ -723,9 +723,9 @@ impl Guild {
         self.members
             .values()
             .find(|member| {
-                let name_matches = member.user.read().unwrap().name == name;
+                let name_matches = member.user.read().name == name;
                 let discrim_matches = match discrim {
-                    Some(discrim) => member.user.read().unwrap().discriminator == discrim,
+                    Some(discrim) => member.user.read().discriminator == discrim,
                     None => true,
                 };
 
@@ -744,7 +744,7 @@ impl Guild {
     /// - "zey", "zeyla", "zey mei"
     /// If 'case_sensitive' is false, the following are not found:
     /// - "Zey", "ZEYla", "zeY mei"
-    /// 
+    ///
     /// [`Member`]: struct.Member.html
     pub fn members_starting_with(&self, prefix: &str, case_sensitive: bool) -> Vec<&Member> {
         self.members
@@ -752,11 +752,11 @@ impl Guild {
             .filter(|member|
 
                 if case_sensitive {
-                    member.user.read().unwrap().name.starts_with(prefix)
+                    member.user.read().name.starts_with(prefix)
                 } else {
-                    starts_with_case_insensitive(&member.user.read().unwrap().name, &prefix)
+                    starts_with_case_insensitive(&member.user.read().name, &prefix)
                 }
-                
+
                 || member.nick.as_ref()
                     .map_or(false, |nick|
 
@@ -773,7 +773,7 @@ impl Guild {
     /// - "zeyla", "meiyla", "yladenisyla"
     /// If 'case_sensitive' is false, the following are not found:
     /// - "zeYLa", "meiyLa", "LYAdenislyA"
-    /// 
+    ///
     /// [`Member`]: struct.Member.html
     pub fn members_containing(&self, substring: &str, case_sensitive: bool) -> Vec<&Member> {
         self.members
@@ -781,11 +781,11 @@ impl Guild {
             .filter(|member|
 
                 if case_sensitive {
-                    member.user.read().unwrap().name.contains(substring)
+                    member.user.read().name.contains(substring)
                 } else {
-                    contains_case_insensitive(&member.user.read().unwrap().name, &substring)
+                    contains_case_insensitive(&member.user.read().name, &substring)
                 }
-                
+
                 || member.nick.as_ref()
                     .map_or(false, |nick|
 
@@ -849,7 +849,7 @@ impl Guild {
             } else {
                 warn!(
                     "(╯°□°）╯︵ ┻━┻ {} on {} has non-existent role {:?}",
-                    member.user.read().unwrap().id,
+                    member.user.read().id,
                     self.id,
                     role
                 );
@@ -862,7 +862,7 @@ impl Guild {
         }
 
         if let Some(channel) = self.channels.get(&channel_id) {
-            let channel = channel.read().unwrap();
+            let channel = channel.read();
 
             // If this is a text channel, then throw out voice permissions.
             if channel.kind == ChannelType::Text {
@@ -1102,7 +1102,7 @@ impl Guild {
     /// impl EventHandler for Handler {
     ///     fn on_message(&self, _: Context, msg: Message) {
     ///         if let Some(arc) = msg.guild_id().unwrap().find() {
-    ///             if let Some(role) = arc.read().unwrap().role_by_name("role_name") {
+    ///             if let Some(role) = arc.read().role_by_name("role_name") {
     ///                 println!("{:?}", role);
     ///             }
     ///         }
diff --git a/src/model/guild/role.rs b/src/model/guild/role.rs
index 7ac7019..3ed718e 100644
--- a/src/model/guild/role.rs
+++ b/src/model/guild/role.rs
@@ -106,8 +106,8 @@ impl Role {
     /// [`ModelError::GuildNotFound`]: enum.ModelError.html#variant.GuildNotFound
     #[cfg(feature = "cache")]
     pub fn find_guild(&self) -> Result<GuildId> {
-        for guild in CACHE.read().unwrap().guilds.values() {
-            let guild = guild.read().unwrap();
+        for guild in CACHE.read().guilds.values() {
+            let guild = guild.read();
 
             if guild.roles.contains_key(&RoleId(self.id.0)) {
                 return Ok(guild.id);
@@ -168,10 +168,10 @@ impl RoleId {
     /// Search the cache for the role.
     #[cfg(feature = "cache")]
     pub fn find(&self) -> Option<Role> {
-        let cache = CACHE.read().unwrap();
+        let cache = CACHE.read();
 
         for guild in cache.guilds.values() {
-            let guild = guild.read().unwrap();
+            let guild = guild.read();
 
             if !guild.roles.contains_key(self) {
                 continue;
diff --git a/src/model/mod.rs b/src/model/mod.rs
index 0817094..64987e1 100644
--- a/src/model/mod.rs
+++ b/src/model/mod.rs
@@ -32,11 +32,12 @@ pub use self::voice::*;
 pub use self::webhook::*;
 
 use chrono::NaiveDateTime;
+use parking_lot::RwLock;
 use self::utils::*;
 use serde::de::Visitor;
 use std::collections::HashMap;
 use std::fmt::{Display, Formatter, Result as FmtResult};
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
 use internal::prelude::*;
 
 #[cfg(feature = "utils")]
@@ -67,7 +68,7 @@ macro_rules! id_u64 {
                     self
                 }
             }
-            
+
             impl From<u64> for $name {
                 fn from(id_as_u64: u64) -> $name {
                     $name(id_as_u64)
diff --git a/src/model/user.rs b/src/model/user.rs
index 39efa10..bf5ee36 100644
--- a/src/model/user.rs
+++ b/src/model/user.rs
@@ -7,12 +7,14 @@ use model::misc::Mentionable;
 
 #[cfg(feature = "model")]
 use chrono::NaiveDateTime;
+#[cfg(all(feature = "cache", feature = "model"))]
+use parking_lot::RwLock;
 #[cfg(feature = "model")]
 use std::fmt::Write;
 #[cfg(feature = "model")]
 use std::mem;
 #[cfg(all(feature = "cache", feature = "model"))]
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
 #[cfg(feature = "model")]
 use builder::{CreateMessage, EditProfile};
 #[cfg(all(feature = "cache", feature = "model"))]
@@ -46,7 +48,7 @@ impl CurrentUser {
     /// ```rust,no_run
     /// # use serenity::client::CACHE;
     /// #
-    /// # let cache = CACHE.read().unwrap();
+    /// # let cache = CACHE.read();
     /// #
     /// // assuming the cache has been unlocked
     /// let user = &cache.user;
@@ -80,7 +82,7 @@ impl CurrentUser {
     ///
     /// let avatar = serenity::utils::read_image("./avatar.png").unwrap();
     ///
-    /// CACHE.write().unwrap().user.edit(|p| p.avatar(Some(&avatar)));
+    /// CACHE.write().user.edit(|p| p.avatar(Some(&avatar)));
     /// ```
     pub fn edit<F>(&mut self, f: F) -> Result<()>
         where F: FnOnce(EditProfile) -> EditProfile {
@@ -123,7 +125,7 @@ impl CurrentUser {
     /// ```rust,no_run
     /// # use serenity::client::CACHE;
     /// #
-    /// # let cache = CACHE.read().unwrap();
+    /// # let cache = CACHE.read();
     /// #
     /// // assuming the cache has been unlocked
     /// let user = &cache.user;
@@ -151,7 +153,7 @@ impl CurrentUser {
     /// ```rust,no_run
     /// # use serenity::client::CACHE;
     /// #
-    /// # let mut cache = CACHE.write().unwrap();
+    /// # let mut cache = CACHE.write();
     ///
     /// use serenity::model::permissions::Permissions;
     ///
@@ -174,7 +176,7 @@ impl CurrentUser {
     /// ```rust,no_run
     /// # use serenity::client::CACHE;
     /// #
-    /// # let mut cache = CACHE.write().unwrap();
+    /// # let mut cache = CACHE.write();
     ///
     /// use serenity::model::Permissions;
     ///
@@ -230,7 +232,7 @@ impl CurrentUser {
     /// ```rust,no_run
     /// # use serenity::client::CACHE;
     /// #
-    /// # let cache = CACHE.read().unwrap();
+    /// # let cache = CACHE.read();
     /// #
     /// // assuming the cache has been unlocked
     /// let user = &cache.user;
@@ -254,7 +256,7 @@ impl CurrentUser {
     /// ```rust,no_run
     /// # use serenity::client::CACHE;
     /// #
-    /// # let cache = CACHE.read().unwrap();
+    /// # let cache = CACHE.read();
     /// #
     /// // assuming the cache has been unlocked
     /// println!("The current user's distinct identifier is {}", cache.user.tag());
@@ -410,25 +412,21 @@ impl User {
     /// impl EventHandler for Handler {
     ///     fn on_message(&self, _: Context, msg: Message) {
     ///         if msg.content == "~help" {
-    ///             let url = match CACHE.read() {
-    ///                 Ok(v) => {
-    ///                     match v.user.invite_url(Permissions::empty()) {
-    ///                         Ok(v) => v,
-    ///                         Err(why) => {
-    ///                             println!("Error creating invite url: {:?}", why);
-    ///
-    ///                             return;
-    ///                         },
-    ///                     }
-    ///                 },
+    ///             let cache = CACHE.read();
+    ///
+    ///             let url = match cache.user.invite_url(Permissions::empty()) {
+    ///                 Ok(v) => v,
     ///                 Err(why) => {
-    ///                     println!("Error reading from CACHE: {:?}", why);
+    ///                     println!("Error creating invite url: {:?}", why);
     ///
     ///                     return;
-    ///                 }
+    ///                 },
     ///             };
-    /// let help = format!("Helpful info here. Invite me with this link: <{}>",
-    /// url);
+    ///
+    ///             let help = format!(
+    ///                 "Helpful info here. Invite me with this link: <{}>",
+    ///                 url,
+    ///             );
     ///
     ///             match msg.author.direct_message(|m| m.content(&help)) {
     ///                 Ok(_) => {
@@ -480,12 +478,12 @@ impl User {
         let private_channel_id = feature_cache! {
             {
                 let finding = {
-                    let cache = CACHE.read().unwrap();
+                    let cache = CACHE.read();
 
                     let finding = cache.private_channels
                         .values()
-                        .map(|ch| ch.read().unwrap())
-                        .find(|ch| ch.recipient.read().unwrap().id == self.id)
+                        .map(|ch| ch.read())
+                        .find(|ch| ch.recipient.read().id == self.id)
                         .map(|ch| ch.id);
 
                     finding
@@ -580,10 +578,9 @@ impl User {
             GuildContainer::Id(_guild_id) => {
                 feature_cache! {{
                     CACHE.read()
-                        .unwrap()
                         .guilds
                         .get(&_guild_id)
-                        .map(|g| g.read().unwrap().roles.contains_key(&role_id))
+                        .map(|g| g.read().roles.contains_key(&role_id))
                         .unwrap_or(false)
                 } else {
                     true
@@ -631,11 +628,11 @@ impl User {
     ///     loop {
     ///         thread::sleep(duration);
     ///
-    ///         let cache = CACHE.read().unwrap();
+    ///         let cache = CACHE.read();
     ///
     ///         for id in &special_users {
     ///             if let Some(user) = cache.user(*id) {
-    ///                 if let Err(why) = user.write().unwrap().refresh() {
+    ///                 if let Err(why) = user.write().refresh() {
     ///                     println!("Error refreshing {}: {:?}", id, why);
     ///                 }
     ///             }
@@ -721,7 +718,7 @@ impl UserId {
 
     /// Search the cache for the user with the Id.
     #[cfg(feature = "cache")]
-    pub fn find(&self) -> Option<Arc<RwLock<User>>> { CACHE.read().unwrap().user(*self) }
+    pub fn find(&self) -> Option<Arc<RwLock<User>>> { CACHE.read().user(*self) }
 
     /// Gets a user by its Id over the REST API.
     ///
@@ -730,8 +727,8 @@ impl UserId {
     pub fn get(&self) -> Result<User> {
         #[cfg(feature = "cache")]
         {
-            if let Some(user) = CACHE.read().unwrap().user(*self) {
-                return Ok(user.read().unwrap().clone());
+            if let Some(user) = CACHE.read().user(*self) {
+                return Ok(user.read().clone());
             }
         }
 
@@ -751,12 +748,12 @@ impl<'a> From<&'a CurrentUser> for UserId {
 
 impl From<Member> for UserId {
     /// Gets the Id of a `Member`.
-    fn from(member: Member) -> UserId { member.user.read().unwrap().id }
+    fn from(member: Member) -> UserId { member.user.read().id }
 }
 
 impl<'a> From<&'a Member> for UserId {
     /// Gets the Id of a `Member`.
-    fn from(member: &Member) -> UserId { member.user.read().unwrap().id }
+    fn from(member: &Member) -> UserId { member.user.read().id }
 }
 
 impl From<User> for UserId {
diff --git a/src/model/utils.rs b/src/model/utils.rs
index 719a472..62ecc4e 100644
--- a/src/model/utils.rs
+++ b/src/model/utils.rs
@@ -1,6 +1,7 @@
+use parking_lot::RwLock;
 use serde::de::Error as DeError;
 use std::collections::HashMap;
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
 use super::*;
 
 #[cfg(feature = "cache")]
@@ -44,7 +45,7 @@ pub fn deserialize_members<'de, D: Deserializer<'de>>(
     let mut members = HashMap::new();
 
     for member in vec {
-        let user_id = member.user.read().unwrap().id;
+        let user_id = member.user.read().id;
 
         members.insert(user_id, member);
     }
@@ -73,8 +74,8 @@ pub fn deserialize_private_channels<'de, D: Deserializer<'de>>(
 
     for private_channel in vec {
         let id = match private_channel {
-            Channel::Group(ref group) => group.read().unwrap().channel_id,
-            Channel::Private(ref channel) => channel.read().unwrap().id,
+            Channel::Group(ref group) => group.read().channel_id,
+            Channel::Private(ref channel) => channel.read().id,
             Channel::Guild(_) => unreachable!("Guild private channel decode"),
             Channel::Category(_) => unreachable!("Channel category private channel decode"),
         };
@@ -147,7 +148,7 @@ pub fn deserialize_voice_states<'de, D: Deserializer<'de>>(
 
 #[cfg(all(feature = "cache", feature = "model"))]
 pub fn user_has_perms(channel_id: ChannelId, mut permissions: Permissions) -> Result<bool> {
-    let cache = CACHE.read().unwrap();
+    let cache = CACHE.read();
     let current_user = &cache.user;
 
     let channel = match cache.channel(channel_id) {
@@ -156,7 +157,7 @@ pub fn user_has_perms(channel_id: ChannelId, mut permissions: Permissions) -> Re
     };
 
     let guild_id = match channel {
-        Channel::Guild(channel) => channel.read().unwrap().guild_id,
+        Channel::Guild(channel) => channel.read().guild_id,
         Channel::Group(_) | Channel::Private(_) | Channel::Category(_) => {
             // Both users in DMs, and all users in groups and maybe all channels in categories will
             // have the same
@@ -177,10 +178,7 @@ pub fn user_has_perms(channel_id: ChannelId, mut permissions: Permissions) -> Re
         None => return Err(Error::Model(ModelError::ItemMissing)),
     };
 
-    let perms = guild
-        .read()
-        .unwrap()
-        .permissions_for(channel_id, current_user.id);
+    let perms = guild.read().permissions_for(channel_id, current_user.id);
 
     permissions.remove(perms);