Revamp `RwLock` usage in the lib

Also not quite sure if they goofed rustfmt or something, but its changes it did were a bit bizarre.

58 files changed, 821 insertions, 1182 deletions

diff --git a/src/builder/create_embed.rs b/src/builder/create_embed.rs
index 6d61653..1e0bc8d 100644
--- a/src/builder/create_embed.rs
+++ b/src/builder/create_embed.rs
@@ -87,10 +87,8 @@ impl CreateEmbed {
     /// Set the colour of the left-hand side of the embed.
     #[cfg(not(feature = "utils"))]
     pub fn colour(mut self, colour: u32) -> Self {
-        self.0.insert(
-            "color".to_owned(),
-            Value::Number(Number::from(colour)),
-        );
+        self.0
+            .insert("color".to_owned(), Value::Number(Number::from(colour)));
 
         CreateEmbed(self.0)
     }
@@ -284,30 +282,24 @@ impl CreateEmbed {
     /// let mut client = Client::new("token", Handler); client.start().unwrap();
     /// ```
     pub fn timestamp<T: Into<Timestamp>>(mut self, timestamp: T) -> Self {
-        self.0.insert(
-            "timestamp".to_owned(),
-            Value::String(timestamp.into().ts),
-        );
+        self.0
+            .insert("timestamp".to_owned(), Value::String(timestamp.into().ts));
 
         CreateEmbed(self.0)
     }
 
     /// Set the title of the embed.
     pub fn title<D: Display>(mut self, title: D) -> Self {
-        self.0.insert(
-            "title".to_owned(),
-            Value::String(format!("{}", title)),
-        );
+        self.0
+            .insert("title".to_owned(), Value::String(format!("{}", title)));
 
         CreateEmbed(self.0)
     }
 
     /// Set the URL to direct to when clicking on the title.
     pub fn url(mut self, url: &str) -> Self {
-        self.0.insert(
-            "url".to_owned(),
-            Value::String(url.to_owned()),
-        );
+        self.0
+            .insert("url".to_owned(), Value::String(url.to_owned()));
 
         CreateEmbed(self.0)
     }
@@ -327,10 +319,7 @@ impl Default for CreateEmbed {
     /// Creates a builder with default values, setting the `type` to `rich`.
     fn default() -> CreateEmbed {
         let mut map = Map::new();
-        map.insert(
-            "type".to_owned(),
-            Value::String("rich".to_owned()),
-        );
+        map.insert("type".to_owned(), Value::String("rich".to_owned()));
 
         CreateEmbed(map)
     }
@@ -407,30 +396,24 @@ pub struct CreateEmbedAuthor(pub Map<String, Value>);
 impl CreateEmbedAuthor {
     /// Set the URL of the author's icon.
     pub fn icon_url(mut self, icon_url: &str) -> Self {
-        self.0.insert(
-            "icon_url".to_owned(),
-            Value::String(icon_url.to_owned()),
-        );
+        self.0
+            .insert("icon_url".to_owned(), Value::String(icon_url.to_owned()));
 
         self
     }
 
     /// Set the author's name.
     pub fn name(mut self, name: &str) -> Self {
-        self.0.insert(
-            "name".to_owned(),
-            Value::String(name.to_owned()),
-        );
+        self.0
+            .insert("name".to_owned(), Value::String(name.to_owned()));
 
         self
     }
 
     /// Set the author's URL.
     pub fn url(mut self, url: &str) -> Self {
-        self.0.insert(
-            "url".to_owned(),
-            Value::String(url.to_owned()),
-        );
+        self.0
+            .insert("url".to_owned(), Value::String(url.to_owned()));
 
         self
     }
@@ -457,20 +440,16 @@ impl CreateEmbedField {
 
     /// Set the field's name. It can't be longer than 256 characters.
     pub fn name<D: Display>(mut self, name: D) -> Self {
-        self.0.insert(
-            "name".to_owned(),
-            Value::String(format!("{}", name)),
-        );
+        self.0
+            .insert("name".to_owned(), Value::String(format!("{}", name)));
 
         self
     }
 
     /// Set the field's value. It can't be longer than 1024 characters.
     pub fn value<D: Display>(mut self, value: D) -> Self {
-        self.0.insert(
-            "value".to_owned(),
-            Value::String(format!("{}", value)),
-        );
+        self.0
+            .insert("value".to_owned(), Value::String(format!("{}", value)));
 
         self
     }
@@ -500,20 +479,16 @@ pub struct CreateEmbedFooter(pub Map<String, Value>);
 impl CreateEmbedFooter {
     /// Set the icon URL's value. This only supports HTTP(S).
     pub fn icon_url(mut self, icon_url: &str) -> Self {
-        self.0.insert(
-            "icon_url".to_owned(),
-            Value::String(icon_url.to_owned()),
-        );
+        self.0
+            .insert("icon_url".to_owned(), Value::String(icon_url.to_owned()));
 
         self
     }
 
     /// Set the footer's text.
     pub fn text<D: Display>(mut self, text: D) -> Self {
-        self.0.insert(
-            "text".to_owned(),
-            Value::String(format!("{}", text)),
-        );
+        self.0
+            .insert("text".to_owned(), Value::String(format!("{}", text)));
 
         self
     }
diff --git a/src/builder/create_invite.rs b/src/builder/create_invite.rs
index d17f273..58893fc 100644
--- a/src/builder/create_invite.rs
+++ b/src/builder/create_invite.rs
@@ -89,10 +89,8 @@ impl CreateInvite {
     /// # }
     /// ```
     pub fn max_age(mut self, max_age: u64) -> Self {
-        self.0.insert(
-            "max_age".to_owned(),
-            Value::Number(Number::from(max_age)),
-        );
+        self.0
+            .insert("max_age".to_owned(), Value::Number(Number::from(max_age)));
 
         self
     }
@@ -125,10 +123,8 @@ impl CreateInvite {
     /// # }
     /// ```
     pub fn max_uses(mut self, max_uses: u64) -> Self {
-        self.0.insert(
-            "max_uses".to_owned(),
-            Value::Number(Number::from(max_uses)),
-        );
+        self.0
+            .insert("max_uses".to_owned(), Value::Number(Number::from(max_uses)));
 
         self
     }
@@ -159,10 +155,8 @@ impl CreateInvite {
     /// # }
     /// ```
     pub fn temporary(mut self, temporary: bool) -> Self {
-        self.0.insert(
-            "temporary".to_owned(),
-            Value::Bool(temporary),
-        );
+        self.0
+            .insert("temporary".to_owned(), Value::Bool(temporary));
 
         self
     }
diff --git a/src/builder/create_message.rs b/src/builder/create_message.rs
index 1ac5211..32cd781 100644
--- a/src/builder/create_message.rs
+++ b/src/builder/create_message.rs
@@ -46,10 +46,8 @@ impl CreateMessage {
     ///
     /// **Note**: Message contents must be under 2000 unicode code points.
     pub fn content<D: Display>(mut self, content: D) -> Self {
-        self.0.insert(
-            "content".to_owned(),
-            Value::String(format!("{}", content)),
-        );
+        self.0
+            .insert("content".to_owned(), Value::String(format!("{}", content)));
 
         CreateMessage(self.0, self.1)
     }
@@ -76,7 +74,7 @@ impl CreateMessage {
     }
 
     /// Adds a list of reactions to create after the message's sent.
-    pub fn reactions<R: Into<ReactionType>>(mut self, reactions: Vec<R>) -> Self {
+pub fn reactions<R: Into<ReactionType>>(mut self, reactions: Vec<R>) -> Self{
         self.1 = Some(reactions.into_iter().map(|r| r.into()).collect());
 
         CreateMessage(self.0, self.1)
diff --git a/src/builder/edit_channel.rs b/src/builder/edit_channel.rs
index a5d799f..e3bf78e 100644
--- a/src/builder/edit_channel.rs
+++ b/src/builder/edit_channel.rs
@@ -27,10 +27,8 @@ impl EditChannel {
     ///
     /// [voice]: ../model/enum.ChannelType.html#variant.Voice
     pub fn bitrate(mut self, bitrate: u64) -> Self {
-        self.0.insert(
-            "bitrate".to_owned(),
-            Value::Number(Number::from(bitrate)),
-        );
+        self.0
+            .insert("bitrate".to_owned(), Value::Number(Number::from(bitrate)));
 
         self
     }
@@ -39,20 +37,16 @@ impl EditChannel {
     ///
     /// Must be between 2 and 100 characters long.
     pub fn name(mut self, name: &str) -> Self {
-        self.0.insert(
-            "name".to_owned(),
-            Value::String(name.to_owned()),
-        );
+        self.0
+            .insert("name".to_owned(), Value::String(name.to_owned()));
 
         self
     }
 
     /// The position of the channel in the channel list.
     pub fn position(mut self, position: u64) -> Self {
-        self.0.insert(
-            "position".to_owned(),
-            Value::Number(Number::from(position)),
-        );
+        self.0
+            .insert("position".to_owned(), Value::Number(Number::from(position)));
 
         self
     }
@@ -65,10 +59,8 @@ impl EditChannel {
     ///
     /// [text]: ../model/enum.ChannelType.html#variant.Text
     pub fn topic(mut self, topic: &str) -> Self {
-        self.0.insert(
-            "topic".to_owned(),
-            Value::String(topic.to_owned()),
-        );
+        self.0
+            .insert("topic".to_owned(), Value::String(topic.to_owned()));
 
         self
     }
diff --git a/src/builder/edit_guild.rs b/src/builder/edit_guild.rs
index 6cfd13a..0fca747 100644
--- a/src/builder/edit_guild.rs
+++ b/src/builder/edit_guild.rs
@@ -22,7 +22,7 @@ impl EditGuild {
     /// valid.
     ///
     /// [`afk_timeout`]: #method.afk_timeout
-    pub fn afk_channel<C: Into<ChannelId>>(mut self, channel: Option<C>) -> Self {
+pub fn afk_channel<C: Into<ChannelId>>(mut self, channel: Option<C>) -> Self{
         self.0.insert(
             "afk_channel_id".to_owned(),
             match channel {
@@ -79,10 +79,7 @@ impl EditGuild {
     pub fn icon(mut self, icon: Option<&str>) -> Self {
         self.0.insert(
             "icon".to_owned(),
-            icon.map_or_else(
-                || Value::Null,
-                |x| Value::String(x.to_owned()),
-            ),
+            icon.map_or_else(|| Value::Null, |x| Value::String(x.to_owned())),
         );
 
         self
@@ -92,10 +89,8 @@ impl EditGuild {
     ///
     /// **Note**: Must be between (and including) 2-100 chracters.
     pub fn name(mut self, name: &str) -> Self {
-        self.0.insert(
-            "name".to_owned(),
-            Value::String(name.to_owned()),
-        );
+        self.0
+            .insert("name".to_owned(), Value::String(name.to_owned()));
 
         self
     }
@@ -139,10 +134,8 @@ impl EditGuild {
     ///
     /// [`Region::UsWest`]: ../model/enum.Region.html#variant.UsWest
     pub fn region(mut self, region: Region) -> Self {
-        self.0.insert(
-            "region".to_owned(),
-            Value::String(region.name().to_owned()),
-        );
+        self.0
+            .insert("region".to_owned(), Value::String(region.name().to_owned()));
 
         self
     }
diff --git a/src/builder/edit_member.rs b/src/builder/edit_member.rs
index 80ec983..9143640 100644
--- a/src/builder/edit_member.rs
+++ b/src/builder/edit_member.rs
@@ -39,10 +39,8 @@ impl EditMember {
     ///
     /// [Manage Nicknames]: ../model/permissions/constant.MANAGE_NICKNAMES.html
     pub fn nickname(mut self, nickname: &str) -> Self {
-        self.0.insert(
-            "nick".to_owned(),
-            Value::String(nickname.to_owned()),
-        );
+        self.0
+            .insert("nick".to_owned(), Value::String(nickname.to_owned()));
 
         self
     }
@@ -68,7 +66,7 @@ impl EditMember {
     /// Requires the [Move Members] permission.
     ///
     /// [Move Members]: ../model/permissions/constant.MOVE_MEMBERS.html
-    pub fn voice_channel<C: Into<ChannelId>>(mut self, channel_id: C) -> Self {
+pub fn voice_channel<C: Into<ChannelId>>(mut self, channel_id: C) -> Self{
         self.0.insert(
             "channel_id".to_owned(),
             Value::Number(Number::from(channel_id.into().0)),
diff --git a/src/builder/edit_profile.rs b/src/builder/edit_profile.rs
index 3bc121c..6aa4e78 100644
--- a/src/builder/edit_profile.rs
+++ b/src/builder/edit_profile.rs
@@ -61,10 +61,8 @@ impl EditProfile {
     ///
     /// [provided]: #method.password
     pub fn email(mut self, email: &str) -> Self {
-        self.0.insert(
-            "email".to_owned(),
-            Value::String(email.to_owned()),
-        );
+        self.0
+            .insert("email".to_owned(), Value::String(email.to_owned()));
 
         self
     }
@@ -90,10 +88,8 @@ impl EditProfile {
     /// [modifying the password]: #method.new_password
     /// [modifying the associated email address]: #method.email
     pub fn password(mut self, password: &str) -> Self {
-        self.0.insert(
-            "password".to_owned(),
-            Value::String(password.to_owned()),
-        );
+        self.0
+            .insert("password".to_owned(), Value::String(password.to_owned()));
 
         self
     }
@@ -105,10 +101,8 @@ impl EditProfile {
     /// If there are no available discriminators with the requested username,
     /// an error will occur.
     pub fn username(mut self, username: &str) -> Self {
-        self.0.insert(
-            "username".to_owned(),
-            Value::String(username.to_owned()),
-        );
+        self.0
+            .insert("username".to_owned(), Value::String(username.to_owned()));
 
         self
     }
diff --git a/src/builder/edit_role.rs b/src/builder/edit_role.rs
index d034149..8be3404 100644
--- a/src/builder/edit_role.rs
+++ b/src/builder/edit_role.rs
@@ -1,6 +1,6 @@
 use std::default::Default;
 use internal::prelude::*;
-use model::{Permissions, Role, permissions};
+use model::{permissions, Permissions, Role};
 
 /// A builer to create or edit a [`Role`] for use via a number of model methods.
 ///
@@ -58,22 +58,13 @@ impl EditRole {
 
         #[cfg(not(feature = "utils"))]
         {
-            map.insert(
-                "color".to_owned(),
-                Value::Number(Number::from(role.colour)),
-            );
+            map.insert("color".to_owned(), Value::Number(Number::from(role.colour)));
         }
 
         map.insert("hoist".to_owned(), Value::Bool(role.hoist));
         map.insert("managed".to_owned(), Value::Bool(role.managed));
-        map.insert(
-            "mentionable".to_owned(),
-            Value::Bool(role.mentionable),
-        );
-        map.insert(
-            "name".to_owned(),
-            Value::String(role.name.clone()),
-        );
+        map.insert("mentionable".to_owned(), Value::Bool(role.mentionable));
+        map.insert("name".to_owned(), Value::String(role.name.clone()));
         map.insert(
             "permissions".to_owned(),
             Value::Number(Number::from(role.permissions.bits())),
@@ -88,10 +79,8 @@ impl EditRole {
 
     /// Sets the colour of the role.
     pub fn colour(mut self, colour: u64) -> Self {
-        self.0.insert(
-            "color".to_owned(),
-            Value::Number(Number::from(colour)),
-        );
+        self.0
+            .insert("color".to_owned(), Value::Number(Number::from(colour)));
 
         self
     }
@@ -106,20 +95,16 @@ impl EditRole {
 
     /// Whether or not to make the role mentionable, notifying its users.
     pub fn mentionable(mut self, mentionable: bool) -> Self {
-        self.0.insert(
-            "mentionable".to_owned(),
-            Value::Bool(mentionable),
-        );
+        self.0
+            .insert("mentionable".to_owned(), Value::Bool(mentionable));
 
         self
     }
 
     /// The name of the role to set.
     pub fn name(mut self, name: &str) -> Self {
-        self.0.insert(
-            "name".to_owned(),
-            Value::String(name.to_owned()),
-        );
+        self.0
+            .insert("name".to_owned(), Value::String(name.to_owned()));
 
         self
     }
@@ -137,10 +122,8 @@ impl EditRole {
     /// The position to assign the role in the role list. This correlates to the
     /// role's position in the user list.
     pub fn position(mut self, position: u8) -> Self {
-        self.0.insert(
-            "position".to_owned(),
-            Value::Number(Number::from(position)),
-        );
+        self.0
+            .insert("position".to_owned(), Value::Number(Number::from(position)));
 
         self
     }
@@ -163,24 +146,12 @@ impl Default for EditRole {
         let mut map = Map::new();
         let permissions = Number::from(permissions::PRESET_GENERAL.bits());
 
-        map.insert(
-            "color".to_owned(),
-            Value::Number(Number::from(10_070_709)),
-        );
+        map.insert("color".to_owned(), Value::Number(Number::from(10_070_709)));
         map.insert("hoist".to_owned(), Value::Bool(false));
         map.insert("mentionable".to_owned(), Value::Bool(false));
-        map.insert(
-            "name".to_owned(),
-            Value::String("new role".to_owned()),
-        );
-        map.insert(
-            "permissions".to_owned(),
-            Value::Number(permissions),
-        );
-        map.insert(
-            "position".to_owned(),
-            Value::Number(Number::from(1)),
-        );
+        map.insert("name".to_owned(), Value::String("new role".to_owned()));
+        map.insert("permissions".to_owned(), Value::Number(permissions));
+        map.insert("position".to_owned(), Value::Number(Number::from(1)));
 
         EditRole(map)
     }
diff --git a/src/builder/execute_webhook.rs b/src/builder/execute_webhook.rs
index 05f0d00..0cb276c 100644
--- a/src/builder/execute_webhook.rs
+++ b/src/builder/execute_webhook.rs
@@ -103,10 +103,8 @@ impl ExecuteWebhook {
     ///
     /// [`embeds`]: #method.embeds
     pub fn content(mut self, content: &str) -> Self {
-        self.0.insert(
-            "content".to_owned(),
-            Value::String(content.to_owned()),
-        );
+        self.0
+            .insert("content".to_owned(), Value::String(content.to_owned()));
 
         self
     }
@@ -167,10 +165,8 @@ impl ExecuteWebhook {
     /// }
     /// ```
     pub fn username(mut self, username: &str) -> Self {
-        self.0.insert(
-            "username".to_owned(),
-            Value::String(username.to_owned()),
-        );
+        self.0
+            .insert("username".to_owned(), Value::String(username.to_owned()));
 
         self
     }
diff --git a/src/builder/get_messages.rs b/src/builder/get_messages.rs
index 8ac5dfe..bca2f0e 100644
--- a/src/builder/get_messages.rs
+++ b/src/builder/get_messages.rs
@@ -85,10 +85,8 @@ impl GetMessages {
     /// limitation. If an amount larger than 100 is supplied, it will be
     /// reduced.
     pub fn limit(mut self, limit: u64) -> Self {
-        self.0.insert(
-            "limit".to_owned(),
-            if limit > 100 { 100 } else { limit },
-        );
+        self.0
+            .insert("limit".to_owned(), if limit > 100 { 100 } else { limit });
 
         self
     }
diff --git a/src/cache/cache_events_impl.rs b/src/cache/cache_events_impl.rs
index cbf0e77..0b511b2 100644
--- a/src/cache/cache_events_impl.rs
+++ b/src/cache/cache_events_impl.rs
@@ -5,6 +5,7 @@ use std::sync::{Arc, RwLock};
 use std::mem;
 use model::*;
 use model::event::*;
+use internal::RwLockExt;
 
 pub(crate) trait CacheEventsImpl {
     fn update_with_channel_create(&mut self, event: &ChannelCreateEvent) -> Option<Channel>;
@@ -62,64 +63,52 @@ impl CacheEventsImpl for super::Cache {
             Channel::Group(ref group) => {
                 let group = group.clone();
 
-                let channel_id = {
-                    let writer = group.write().unwrap();
-
-                    for (recipient_id, recipient) in &mut group.write().unwrap().recipients {
+                let channel_id = group.with_mut(|writer| {
+                    for (recipient_id, recipient) in &mut writer.recipients {
                         self.update_user_entry(&recipient.read().unwrap());
 
                         *recipient = self.users[recipient_id].clone();
                     }
 
                     writer.channel_id
-                };
+                });
 
                 let ch = self.groups.insert(channel_id, group);
 
                 ch.map(Channel::Group)
             },
             Channel::Guild(ref channel) => {
-                let (guild_id, channel_id) = {
-                    let channel = channel.read().unwrap();
-
-                    (channel.guild_id, channel.id)
-                };
+                let (guild_id, channel_id) = channel.with(|channel| (channel.guild_id, channel.id));
 
                 self.channels.insert(channel_id, channel.clone());
 
                 self.guilds
                     .get_mut(&guild_id)
                     .and_then(|guild| {
-                        guild.write().unwrap().channels.insert(
-                            channel_id,
-                            channel.clone(),
-                        )
+                        guild
+                            .with_mut(|guild| guild.channels.insert(channel_id, channel.clone()))
                     })
                     .map(Channel::Guild)
             },
             Channel::Private(ref channel) => {
-                if let Some(channel) = self.private_channels.get(&channel.read().unwrap().id) {
+                if let Some(channel) = self.private_channels.get(&channel.with(|c| c.id)) {
                     return Some(Channel::Private((*channel).clone()));
                 }
 
                 let channel = channel.clone();
 
-                let mut channel_writer = channel.write().unwrap();
-
-                let user_id = {
-                    let user_reader = channel_writer.recipient.read().unwrap();
-
-                    self.update_user_entry(&user_reader);
+                let id = channel.with_mut(|writer| {
+                    let user_id = writer.recipient.with_mut(|user| {
+                        self.update_user_entry(&user);
 
-                    user_reader.id
-                };
+                        user.id
+                    });
 
-                channel_writer.recipient = self.users[&user_id].clone();
+                    writer.recipient = self.users[&user_id].clone();
+                    writer.id
+                });
 
-                let ch = self.private_channels.insert(
-                    channel_writer.id,
-                    channel.clone(),
-                );
+                let ch = self.private_channels.insert(id, channel.clone());
                 ch.map(Channel::Private)
             },
         }
@@ -131,70 +120,66 @@ impl CacheEventsImpl for super::Cache {
             // We ignore these two due to the fact that the delete event for dms/groups
             // will _not_ fire
             // anymore.
-            Channel::Private(_) |
-            Channel::Group(_) => unreachable!(),
+            Channel::Private(_) | Channel::Group(_) => unreachable!(),
         };
 
-        let (channel_id, guild_id) = {
-            let channel = channel.read().unwrap();
-
-            (channel.id, channel.guild_id)
-        };
+        let (guild_id, channel_id) = channel.with(|channel| (channel.guild_id, channel.id));
 
         self.channels.remove(&channel_id);
 
-        self.guilds.get_mut(&guild_id).and_then(|guild| {
-            guild.write().unwrap().channels.remove(&channel_id)
-        });
+        self.guilds
+            .get_mut(&guild_id)
+            .and_then(|guild| guild.with_mut(|g| g.channels.remove(&channel_id)));
     }
 
     #[allow(dead_code)]
-    fn update_with_channel_pins_update(&mut self, event: &ChannelPinsUpdateEvent) {
+fn update_with_channel_pins_update(&mut self, event: &ChannelPinsUpdateEvent){
         if let Some(channel) = self.channels.get(&event.channel_id) {
-            channel.write().unwrap().last_pin_timestamp = event.last_pin_timestamp;
+            channel
+                .with_mut(|c| { c.last_pin_timestamp = event.last_pin_timestamp; });
 
             return;
         }
 
         if let Some(channel) = self.private_channels.get_mut(&event.channel_id) {
-            channel.write().unwrap().last_pin_timestamp = event.last_pin_timestamp;
+            channel
+                .with_mut(|c| { c.last_pin_timestamp = event.last_pin_timestamp; });
 
             return;
         }
 
         if let Some(group) = self.groups.get_mut(&event.channel_id) {
-            group.write().unwrap().last_pin_timestamp = event.last_pin_timestamp;
+            group
+                .with_mut(|c| { c.last_pin_timestamp = event.last_pin_timestamp; });
 
             return;
         }
     }
 
-    fn update_with_channel_recipient_add(&mut self, event: &mut ChannelRecipientAddEvent) {
+fn update_with_channel_recipient_add(&mut self, event: &mut ChannelRecipientAddEvent){
         self.update_user_entry(&event.user);
         let user = self.users[&event.user.id].clone();
 
         self.groups.get_mut(&event.channel_id).map(|group| {
-            group.write().unwrap().recipients.insert(
-                event.user.id,
-                user,
-            );
+            group
+                .write()
+                .unwrap()
+                .recipients
+                .insert(event.user.id, user);
         });
     }
 
-    fn update_with_channel_recipient_remove(&mut self, event: &ChannelRecipientRemoveEvent) {
+fn update_with_channel_recipient_remove(&mut self, event: &ChannelRecipientRemoveEvent){
         self.groups.get_mut(&event.channel_id).map(|group| {
-            group.write().unwrap().recipients.remove(&event.user.id)
+            group.with_mut(|g| g.recipients.remove(&event.user.id))
         });
     }
 
     fn update_with_channel_update(&mut self, event: &ChannelUpdateEvent) {
         match event.channel {
             Channel::Group(ref group) => {
-                let (ch_id, no_recipients) = {
-                    let group = group.read().unwrap();
-
-                    (group.channel_id, group.recipients.is_empty())
-                };
+                let (ch_id, no_recipients) =
+                    group.with(|g| (g.channel_id, g.recipients.is_empty()));
 
                 match self.groups.entry(ch_id) {
                     Entry::Vacant(e) => {
@@ -216,18 +201,12 @@ impl CacheEventsImpl for super::Cache {
                 }
             },
             Channel::Guild(ref channel) => {
-                let (channel_id, guild_id) = {
-                    let channel = channel.read().unwrap();
-
-                    (channel.id, channel.guild_id)
-                };
+                let (guild_id, channel_id) = channel.with(|channel| (channel.guild_id, channel.id));
 
                 self.channels.insert(channel_id, channel.clone());
                 self.guilds.get_mut(&guild_id).map(|guild| {
-                    guild.write().unwrap().channels.insert(
-                        channel_id,
-                        channel.clone(),
-                    )
+                    guild
+                        .with_mut(|g| g.channels.insert(channel_id, channel.clone()))
                 });
             },
             Channel::Private(ref channel) => {
@@ -251,16 +230,14 @@ impl CacheEventsImpl for super::Cache {
         }
 
         self.channels.extend(guild.channels.clone());
-        self.guilds.insert(
-            event.guild.id,
-            Arc::new(RwLock::new(guild)),
-        );
+        self.guilds
+            .insert(event.guild.id, Arc::new(RwLock::new(guild)));
     }
 
     fn update_with_guild_delete(&mut self, event: &GuildDeleteEvent) -> Option<Arc<RwLock<Guild>>> {
         // Remove channel entries for the guild if the guild is found.
         self.guilds.remove(&event.guild.id).map(|guild| {
-            for channel_id in guild.read().unwrap().channels.keys() {
+            for channel_id in guild.write().unwrap().channels.keys() {
                 self.channels.remove(channel_id);
             }
 
@@ -268,41 +245,41 @@ impl CacheEventsImpl for super::Cache {
         })
     }
 
-    fn update_with_guild_emojis_update(&mut self, event: &GuildEmojisUpdateEvent) {
+fn update_with_guild_emojis_update(&mut self, event: &GuildEmojisUpdateEvent){
         self.guilds.get_mut(&event.guild_id).map(|guild| {
-            guild.write().unwrap().emojis.extend(event.emojis.clone())
+            guild.with_mut(|g| g.emojis.extend(event.emojis.clone()))
         });
     }
 
-    fn update_with_guild_member_add(&mut self, event: &mut GuildMemberAddEvent) {
-        let user_id = event.member.user.read().unwrap().id;
+fn update_with_guild_member_add(&mut self, event: &mut GuildMemberAddEvent){
+        let user_id = event.member.user.with(|u| u.id);
         self.update_user_entry(&event.member.user.read().unwrap());
 
         // Always safe due to being inserted above.
         event.member.user = self.users[&user_id].clone();
 
         self.guilds.get_mut(&event.guild_id).map(|guild| {
-            let mut guild = guild.write().unwrap();
-
-            guild.member_count += 1;
-            guild.members.insert(user_id, event.member.clone());
+            guild.with_mut(|guild| {
+                guild.member_count += 1;
+                guild.members.insert(user_id, event.member.clone());
+            })
         });
     }
 
     fn update_with_guild_member_remove(&mut self,
                                        event: &GuildMemberRemoveEvent)
-                                       -> Option<Member> {
+-> Option<Member>{
         self.guilds.get_mut(&event.guild_id).and_then(|guild| {
-            let mut guild = guild.write().unwrap();
-
-            guild.member_count -= 1;
-            guild.members.remove(&event.user.id)
+            guild.with_mut(|guild| {
+                guild.member_count -= 1;
+                guild.members.remove(&event.user.id)
+            })
         })
     }
 
     fn update_with_guild_member_update(&mut self,
                                        event: &GuildMemberUpdateEvent)
-                                       -> Option<Member> {
+-> Option<Member>{
         self.update_user_entry(&event.user);
 
         if let Some(guild) = self.guilds.get_mut(&event.guild_id) {
@@ -345,40 +322,43 @@ impl CacheEventsImpl for super::Cache {
         }
     }
 
-    fn update_with_guild_members_chunk(&mut self, event: &GuildMembersChunkEvent) {
+fn update_with_guild_members_chunk(&mut self, event: &GuildMembersChunkEvent){
         for member in event.members.values() {
             self.update_user_entry(&member.user.read().unwrap());
         }
 
         self.guilds.get_mut(&event.guild_id).map(|guild| {
-            guild.write().unwrap().members.extend(event.members.clone())
+            guild.with_mut(|g| g.members.extend(event.members.clone()))
         });
     }
 
-    fn update_with_guild_role_create(&mut self, event: &GuildRoleCreateEvent) {
+fn update_with_guild_role_create(&mut self, event: &GuildRoleCreateEvent){
         self.guilds.get_mut(&event.guild_id).map(|guild| {
-            guild.write().unwrap().roles.insert(
-                event.role.id,
-                event.role.clone(),
-            )
+            guild
+                .write()
+                .unwrap()
+                .roles
+                .insert(event.role.id, event.role.clone())
         });
     }
 
-    fn update_with_guild_role_delete(&mut self, event: &GuildRoleDeleteEvent) -> Option<Role> {
-        self.guilds.get_mut(&event.guild_id).and_then(|guild| {
-            guild.write().unwrap().roles.remove(&event.role_id)
-        })
+fn update_with_guild_role_delete(&mut self, event: &GuildRoleDeleteEvent) -> Option<Role>{
+        self.guilds
+            .get_mut(&event.guild_id)
+            .and_then(|guild| guild.with_mut(|g| g.roles.remove(&event.role_id)))
     }
 
-    fn update_with_guild_role_update(&mut self, event: &GuildRoleUpdateEvent) -> Option<Role> {
+fn update_with_guild_role_update(&mut self, event: &GuildRoleUpdateEvent) -> Option<Role>{
         self.guilds.get_mut(&event.guild_id).and_then(|guild| {
-            guild.write().unwrap().roles.get_mut(&event.role.id).map(
-                |role| mem::replace(role, event.role.clone()),
-            )
+            guild.with_mut(|g| {
+                g.roles
+                    .get_mut(&event.role.id)
+                    .map(|role| mem::replace(role, event.role.clone()))
+            })
         })
     }
 
-    fn update_with_guild_unavailable(&mut self, event: &GuildUnavailableEvent) {
+fn update_with_guild_unavailable(&mut self, event: &GuildUnavailableEvent){
         self.unavailable_guilds.insert(event.guild_id);
         self.guilds.remove(&event.guild_id);
     }
@@ -398,7 +378,7 @@ impl CacheEventsImpl for super::Cache {
         });
     }
 
-    fn update_with_presences_replace(&mut self, event: &PresencesReplaceEvent) {
+fn update_with_presences_replace(&mut self, event: &PresencesReplaceEvent){
         self.presences.extend({
             let mut p: HashMap<UserId, Presence> = HashMap::default();
 
@@ -426,19 +406,16 @@ impl CacheEventsImpl for super::Cache {
                 if event.presence.status == OnlineStatus::Offline {
                     guild.presences.remove(&event.presence.user_id);
                 } else {
-                    guild.presences.insert(
-                        event.presence.user_id,
-                        event.presence.clone(),
-                    );
+                    guild
+                        .presences
+                        .insert(event.presence.user_id, event.presence.clone());
                 }
             }
         } else if event.presence.status == OnlineStatus::Offline {
             self.presences.remove(&event.presence.user_id);
         } else {
-            self.presences.insert(
-                event.presence.user_id,
-                event.presence.clone(),
-            );
+            self.presences
+                .insert(event.presence.user_id, event.presence.clone());
         }
     }
 
@@ -479,7 +456,7 @@ impl CacheEventsImpl for super::Cache {
         mem::replace(&mut self.user, event.current_user.clone())
     }
 
-    fn update_with_voice_state_update(&mut self, event: &VoiceStateUpdateEvent) {
+fn update_with_voice_state_update(&mut self, event: &VoiceStateUpdateEvent){
         if let Some(guild_id) = event.guild_id {
             if let Some(guild) = self.guilds.get_mut(&guild_id) {
                 let mut guild = guild.write().unwrap();
@@ -496,10 +473,9 @@ impl CacheEventsImpl for super::Cache {
                         }
                     }
 
-                    guild.voice_states.insert(
-                        event.voice_state.user_id,
-                        event.voice_state.clone(),
-                    );
+                    guild
+                        .voice_states
+                        .insert(event.voice_state.user_id, event.voice_state.clone());
                 } else {
                     // Remove the user from the voice state list
                     guild.voice_states.remove(&event.voice_state.user_id);
diff --git a/src/cache/mod.rs b/src/cache/mod.rs
index 68a78a7..4aa587f 100644
--- a/src/cache/mod.rs
+++ b/src/cache/mod.rs
@@ -482,7 +482,7 @@ impl Cache {
     pub fn member<G, U>(&self, guild_id: G, user_id: U) -> Option<Member>
         where G: Into<GuildId>, U: Into<UserId> {
         self.guilds.get(&guild_id.into()).and_then(|guild| {
-            guild.write().unwrap().members.get(&user_id.into()).cloned()
+            guild.read().unwrap().members.get(&user_id.into()).cloned()
         })
     }
 
@@ -517,7 +517,7 @@ impl Cache {
     #[inline]
     pub fn private_channel<C: Into<ChannelId>>(&self,
                                                channel_id: C)
-                                               -> Option<Arc<RwLock<PrivateChannel>>> {
+-> Option<Arc<RwLock<PrivateChannel>>>{
         self.private_channels.get(&channel_id.into()).cloned()
     }
 
@@ -553,9 +553,9 @@ impl Cache {
     /// ```
     pub fn role<G, R>(&self, guild_id: G, role_id: R) -> Option<Role>
         where G: Into<GuildId>, R: Into<RoleId> {
-        self.guilds.get(&guild_id.into()).and_then(|g| {
-            g.read().unwrap().roles.get(&role_id.into()).cloned()
-        })
+        self.guilds
+            .get(&guild_id.into())
+            .and_then(|g| g.read().unwrap().roles.get(&role_id.into()).cloned())
     }
 
     /// Retrieves a `User` from the cache's [`users`] map, if it exists.
diff --git a/src/client/context.rs b/src/client/context.rs
index a20a316..e8595cd 100644
--- a/src/client/context.rs
+++ b/src/client/context.rs
@@ -75,26 +75,26 @@ impl Context {
     /// let mut client = Client::new("token", Handler); client.start().unwrap();
     /// ```
     #[cfg(feature = "builder")]
-    pub fn edit_profile<F: FnOnce(EditProfile) -> EditProfile>(&self, f: F) -> Result<CurrentUser> {
+pub fn edit_profile<F: FnOnce(EditProfile) -> EditProfile>(&self, f: F) -> Result<CurrentUser>{
         let mut map = Map::new();
 
         feature_cache! {{
-            let cache = CACHE.read().unwrap();
-
-            map.insert("username".to_owned(), Value::String(cache.user.name.clone()));
-
-            if let Some(email) = cache.user.email.as_ref() {
-                map.insert("email".to_owned(), Value::String(email.clone()));
-            }
-        } else {
-            let user = http::get_current_user()?;
-
-            map.insert("username".to_owned(), Value::String(user.name.clone()));
-
-            if let Some(email) = user.email.as_ref() {
-                map.insert("email".to_owned(), Value::String(email.clone()));
-            }
-        }}
+                            let cache = CACHE.read().unwrap();
+        
+                            map.insert("username".to_owned(), Value::String(cache.user.name.clone()));
+        
+                            if let Some(email) = cache.user.email.as_ref() {
+                                map.insert("email".to_owned(), Value::String(email.clone()));
+                            }
+                        } else {
+                            let user = http::get_current_user()?;
+        
+                            map.insert("username".to_owned(), Value::String(user.name.clone()));
+        
+                            if let Some(email) = user.email.as_ref() {
+                                map.insert("email".to_owned(), Value::String(email.clone()));
+                            }
+                        }}
 
         let edited = f(EditProfile(map)).0;
 
diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index 0a2ad8d..cb45428 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -62,7 +62,7 @@ pub fn dispatch<H: EventHandler + 'static>(event: Event,
                                            framework: &Arc<sync::Mutex<Option<Box<Framework>>>>,
                                            data: &Arc<Mutex<ShareMap>>,
                                            event_handler: &Arc<H>,
-                                           tokio_handle: &Handle) {
+tokio_handle: &Handle){
     match event {
         Event::MessageCreate(event) => {
             let context = context(conn, data);
@@ -75,12 +75,12 @@ pub fn dispatch<H: EventHandler + 'static>(event: Event,
 
             if let Some(ref mut framework) = *framework.lock().unwrap() {
                 helper! {{
-					if framework.initialized() {
-						framework.dispatch(context, event.message, tokio_handle);
-					}
-				} else {
-					framework.dispatch(context, event.message, tokio_handle);
-				}}
+                if framework.initialized() {
+                framework.dispatch(context, event.message, tokio_handle);
+                }
+                } else {
+                framework.dispatch(context, event.message, tokio_handle);
+                }}
             }
         },
         other => handle_event(other, conn, data, event_handler, tokio_handle),
@@ -92,7 +92,7 @@ pub fn dispatch<H: EventHandler + 'static>(event: Event,
                                            conn: &Arc<Mutex<Shard>>,
                                            data: &Arc<Mutex<ShareMap>>,
                                            event_handler: &Arc<H>,
-                                           tokio_handle: &Handle) {
+tokio_handle: &Handle){
     match event {
         Event::MessageCreate(event) => {
             let context = context(conn, data);
@@ -106,7 +106,7 @@ pub fn dispatch<H: EventHandler + 'static>(event: Event,
 fn dispatch_message<H: EventHandler + 'static>(context: Context,
                                                mut message: Message,
                                                event_handler: &Arc<H>,
-                                               tokio_handle: &Handle) {
+tokio_handle: &Handle){
     let h = event_handler.clone();
     tokio_handle.spawn_fn(move || {
         #[cfg(feature = "model")]
@@ -125,7 +125,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
                                            conn: &Arc<Mutex<Shard>>,
                                            data: &Arc<Mutex<ShareMap>>,
                                            event_handler: &Arc<H>,
-                                           tokio_handle: &Handle) {
+tokio_handle: &Handle){
     #[cfg(feature="cache")]
     let mut last_guild_create_time = now!();
 
@@ -172,8 +172,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
             let context = context(conn, data);
 
             match event.channel {
-                Channel::Private(_) |
-                Channel::Group(_) => {},
+                Channel::Private(_) | Channel::Group(_) => {},
                 Channel::Guild(channel) => {
                     let h = event_handler.clone();
                     tokio_handle.spawn_fn(move || {
@@ -199,11 +198,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_channel_recipient_addition(
-                    context,
-                    event.channel_id,
-                    event.user,
-                );
+                h.on_channel_recipient_addition(context, event.channel_id, event.user);
                 Ok(())
             });
         },
@@ -214,11 +209,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_channel_recipient_removal(
-                    context,
-                    event.channel_id,
-                    event.user,
-                );
+                h.on_channel_recipient_removal(context, event.channel_id, event.user);
                 Ok(())
             });
         },
@@ -332,11 +323,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_guild_emojis_update(
-                    context,
-                    event.guild_id,
-                    event.emojis,
-                );
+                h.on_guild_emojis_update(context, event.guild_id, event.emojis);
                 Ok(())
             });
         },
@@ -356,11 +343,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_guild_member_addition(
-                    context,
-                    event.guild_id,
-                    event.member,
-                );
+                h.on_guild_member_addition(context, event.guild_id, event.member);
                 Ok(())
             });
         },
@@ -387,25 +370,25 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             feature_cache! {{
-                // This is safe to unwrap, as the update would have created
-                // 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();
-
-                tokio_handle.spawn_fn(move || {
-                    h.on_guild_member_update(context, _before, after);
-                    Ok(())
-                });
-            } else {
-                tokio_handle.spawn_fn(move || {
-                    h.on_guild_member_update(context, event);
-                    Ok(())
-                });
-            }}
+                                                                // This is safe to unwrap, as the update would have created
+                                                                // 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();
+            
+                                                                tokio_handle.spawn_fn(move || {
+                                                                    h.on_guild_member_update(context, _before, after);
+                                                                    Ok(())
+                                                                });
+                                                            } else {
+                                                                tokio_handle.spawn_fn(move || {
+                                                                    h.on_guild_member_update(context, event);
+                                                                    Ok(())
+                                                                });
+                                                            }}
         },
         Event::GuildMembersChunk(event) => {
             update!(update_with_guild_members_chunk, event);
@@ -414,11 +397,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_guild_members_chunk(
-                    context,
-                    event.guild_id,
-                    event.members,
-                );
+                h.on_guild_members_chunk(context, event.guild_id, event.members);
                 Ok(())
             });
         },
@@ -485,22 +464,22 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             feature_cache! {{
-                let before = CACHE.read()
-                    .unwrap()
-                    .guilds
-                    .get(&event.guild.id)
-                    .cloned();
-
-                tokio_handle.spawn_fn(move || {
-                    h.on_guild_update(context, before, event.guild);
-                    Ok(())
-                });
-            } else {
-                tokio_handle.spawn_fn(move || {
-                    h.on_guild_update(context, event.guild);
-                    Ok(())
-                });
-            }}
+                                                                let before = CACHE.read()
+                                                                    .unwrap()
+                                                                    .guilds
+                                                                    .get(&event.guild.id)
+                                                                    .cloned();
+            
+                                                                tokio_handle.spawn_fn(move || {
+                                                                    h.on_guild_update(context, before, event.guild);
+                                                                    Ok(())
+                                                                });
+                                                            } else {
+                                                                tokio_handle.spawn_fn(move || {
+                                                                    h.on_guild_update(context, event.guild);
+                                                                    Ok(())
+                                                                });
+                                                            }}
         },
         // Already handled by the framework check macro
         Event::MessageCreate(_) => {},
@@ -509,11 +488,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_message_delete_bulk(
-                    context,
-                    event.channel_id,
-                    event.ids,
-                );
+                h.on_message_delete_bulk(context, event.channel_id, event.ids);
                 Ok(())
             });
         },
@@ -522,11 +497,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_message_delete(
-                    context,
-                    event.channel_id,
-                    event.message_id,
-                );
+                h.on_message_delete(context, event.channel_id, event.message_id);
                 Ok(())
             });
         },
@@ -582,11 +553,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_reaction_remove_all(
-                    context,
-                    event.channel_id,
-                    event.message_id,
-                );
+                h.on_reaction_remove_all(context, event.channel_id, event.message_id);
                 Ok(())
             });
         },
@@ -594,27 +561,27 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
             update!(update_with_ready, event);
 
             feature_cache!{{
-                last_guild_create_time = now!();
-
-                let _ = wait_for_guilds()
-                .map(|_| {
-                    let context = context(conn, data);
-
-                    let h = event_handler.clone();
-                    tokio_handle.spawn_fn(move || {
-                        h.on_ready(context, event.ready);
-                        Ok(())
-                    });
-                });
-            } else {
-               let context = context(conn, data);
-
-                let h = event_handler.clone();
-                tokio_handle.spawn_fn(move || {
-                    h.on_ready(context, event.ready);
-                    Ok(())
-                });
-            }}
+                                                                last_guild_create_time = now!();
+            
+                                                                let _ = wait_for_guilds()
+                                                                .map(|_| {
+                                                                    let context = context(conn, data);
+            
+                                                                    let h = event_handler.clone();
+                                                                    tokio_handle.spawn_fn(move || {
+                                                                        h.on_ready(context, event.ready);
+                                                                        Ok(())
+                                                                    });
+                                                                });
+                                                            } else {
+                                                               let context = context(conn, data);
+            
+                                                                let h = event_handler.clone();
+                                                                tokio_handle.spawn_fn(move || {
+                                                                    h.on_ready(context, event.ready);
+                                                                    Ok(())
+                                                                });
+                                                            }}
         },
         Event::Resumed(event) => {
             let context = context(conn, data);
@@ -676,11 +643,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_voice_state_update(
-                    context,
-                    event.guild_id,
-                    event.voice_state,
-                );
+                h.on_voice_state_update(context, event.guild_id, event.voice_state);
                 Ok(())
             });
         },
@@ -689,11 +652,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_webhook_update(
-                    context,
-                    event.guild_id,
-                    event.channel_id,
-                );
+                h.on_webhook_update(context, event.guild_id, event.channel_id);
                 Ok(())
             });
         },
diff --git a/src/client/mod.rs b/src/client/mod.rs
index 5821597..47ff96c 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -37,7 +37,7 @@ pub use CACHE;
 
 use self::dispatch::dispatch;
 use std::sync::{self, Arc};
-use std::sync::atomic::{ATOMIC_BOOL_INIT, AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, Ordering, ATOMIC_BOOL_INIT};
 use parking_lot::Mutex;
 use tokio_core::reactor::Core;
 use futures;
@@ -194,8 +194,7 @@ pub struct Client<H: EventHandler + '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>>>>,
+    #[cfg(feature = "framework")] framework: Arc<sync::Mutex<Option<Box<Framework>>>>,
     token: Arc<sync::Mutex<String>>,
 }
 
@@ -355,7 +354,7 @@ impl<H: EventHandler + 'static> Client<H> {
     /// [`on_message`]: #method.on_message
     /// [framework docs]: ../framework/index.html
     #[cfg(feature = "framework")]
-    pub fn with_framework<F: Framework + 'static>(&mut self, f: F) {
+pub fn with_framework<F: Framework + 'static>(&mut self, f: F){
         self.framework = Arc::new(sync::Mutex::new(Some(Box::new(f))));
     }
 
@@ -540,10 +539,7 @@ impl<H: EventHandler + 'static> Client<H> {
     /// [`start_autosharded`]: #method.start_autosharded
     /// [gateway docs]: gateway/index.html#sharding
     pub fn start_shard(&mut self, shard: u64, shards: u64) -> Result<()> {
-        self.start_connection(
-            [shard, shard, shards],
-            http::get_gateway()?.url,
-        )
+        self.start_connection([shard, shard, shards], http::get_gateway()?.url)
     }
 
     /// Establish sharded connections and start listening for events.
@@ -668,10 +664,7 @@ impl<H: EventHandler + 'static> Client<H> {
     /// [`start_shards`]: #method.start_shards
     /// [Gateway docs]: gateway/index.html#sharding
     pub fn start_shard_range(&mut self, range: [u64; 2], total_shards: u64) -> Result<()> {
-        self.start_connection(
-            [range[0], range[1], total_shards],
-            http::get_gateway()?.url,
-        )
+        self.start_connection([range[0], range[1], total_shards], http::get_gateway()?.url)
     }
 
     /// Returns a thread-safe handle for closing shards.
@@ -729,8 +722,7 @@ impl<H: EventHandler + 'static> Client<H> {
                 Ok(shard) => {
                     let shard = Arc::new(Mutex::new(shard));
 
-                    let monitor_info =
-                        feature_framework! {{
+                    let monitor_info = feature_framework! {{
                         MonitorInfo {
                             data: self.data.clone(),
                             event_handler: self.event_handler.clone(),
@@ -846,7 +838,7 @@ fn boot_shard(info: &BootInfo) -> Result<Shard> {
     Err(Error::Client(ClientError::ShardBootFailure))
 }
 
-fn monitor_shard<H: EventHandler + 'static>(mut info: MonitorInfo<H>) {
+fn monitor_shard<H: EventHandler + 'static>(mut info: MonitorInfo<H>){
     handle_shard(&mut info);
 
     let mut handle_still = HANDLE_STILL.load(Ordering::Relaxed);
@@ -900,7 +892,7 @@ fn monitor_shard<H: EventHandler + 'static>(mut info: MonitorInfo<H>) {
     }
 }
 
-fn handle_shard<H: EventHandler + 'static>(info: &mut MonitorInfo<H>) {
+fn handle_shard<H: EventHandler + 'static>(info: &mut MonitorInfo<H>){
     let mut core = Core::new().unwrap();
     let handle = core.handle();
 
diff --git a/src/error.rs b/src/error.rs
index 3944a4c..508578b 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -171,8 +171,7 @@ impl Display for Error {
 impl StdError for Error {
     fn description(&self) -> &str {
         match *self {
-            Error::Decode(msg, _) |
-            Error::Other(msg) => msg,
+            Error::Decode(msg, _) | Error::Other(msg) => msg,
             Error::ExceededLimit(..) => "Input exceeded a limit",
             Error::Format(ref inner) => inner.description(),
             Error::Io(ref inner) => inner.description(),
diff --git a/src/framework/standard/buckets.rs b/src/framework/standard/buckets.rs
index f2c4486..4719b85 100644
--- a/src/framework/standard/buckets.rs
+++ b/src/framework/standard/buckets.rs
@@ -31,9 +31,9 @@ pub(crate) struct Bucket {
 impl Bucket {
     pub fn take(&mut self, user_id: u64) -> i64 {
         let time = Utc::now().timestamp();
-        let user = self.users.entry(user_id).or_insert_with(
-            MemberRatelimit::default,
-        );
+        let user = self.users
+            .entry(user_id)
+            .or_insert_with(MemberRatelimit::default);
 
         if let Some((timespan, limit)) = self.ratelimit.limit {
             if (user.tickets + 1) > limit {
diff --git a/src/framework/standard/command.rs b/src/framework/standard/command.rs
index 22a82ce..8c23ca0 100644
--- a/src/framework/standard/command.rs
+++ b/src/framework/standard/command.rs
@@ -6,10 +6,7 @@ use std::collections::HashMap;
 
 pub type Check = Fn(&mut Context, &Message, &mut Args, &Arc<Command>) -> bool + 'static;
 pub type Exec = Fn(&mut Context, &Message, Args) -> Result<(), String> + 'static;
-pub type Help = Fn(&mut Context,
-                   &Message,
-                   HashMap<String, Arc<CommandGroup>>,
-                   Args)
+pub type Help = Fn(&mut Context, &Message, HashMap<String, Arc<CommandGroup>>, Args)
                    -> Result<(), String>
                     + 'static;
 pub type BeforeHook = Fn(&mut Context, &Message, &str) -> bool + 'static;
diff --git a/src/framework/standard/configuration.rs b/src/framework/standard/configuration.rs
index 491bbc4..dd1c7e7 100644
--- a/src/framework/standard/configuration.rs
+++ b/src/framework/standard/configuration.rs
@@ -33,32 +33,19 @@ use model::{GuildId, Message, UserId};
 /// [`Client`]: ../../client/struct.Client.html
 /// [`Framework`]: struct.Framework.html
 pub struct Configuration {
-    #[doc(hidden)]
-    pub allow_dm: bool,
-    #[doc(hidden)]
-    pub allow_whitespace: bool,
-    #[doc(hidden)]
-    pub blocked_guilds: HashSet<GuildId>,
-    #[doc(hidden)]
-    pub blocked_users: HashSet<UserId>,
-    #[doc(hidden)]
-    pub depth: usize,
-    #[doc(hidden)]
-    pub disabled_commands: HashSet<String>,
-    #[doc(hidden)]
-    pub dynamic_prefix: Option<Box<PrefixCheck>>,
-    #[doc(hidden)]
-    pub ignore_bots: bool,
-    #[doc(hidden)]
-    pub ignore_webhooks: bool,
-    #[doc(hidden)]
-    pub on_mention: Option<Vec<String>>,
-    #[doc(hidden)]
-    pub owners: HashSet<UserId>,
-    #[doc(hidden)]
-    pub prefixes: Vec<String>,
-    #[doc(hidden)]
-    pub delimiters: Vec<String>,
+    #[doc(hidden)] pub allow_dm: bool,
+    #[doc(hidden)] pub allow_whitespace: bool,
+    #[doc(hidden)] pub blocked_guilds: HashSet<GuildId>,
+    #[doc(hidden)] pub blocked_users: HashSet<UserId>,
+    #[doc(hidden)] pub depth: usize,
+    #[doc(hidden)] pub disabled_commands: HashSet<String>,
+    #[doc(hidden)] pub dynamic_prefix: Option<Box<PrefixCheck>>,
+    #[doc(hidden)] pub ignore_bots: bool,
+    #[doc(hidden)] pub ignore_webhooks: bool,
+    #[doc(hidden)] pub on_mention: Option<Vec<String>>,
+    #[doc(hidden)] pub owners: HashSet<UserId>,
+    #[doc(hidden)] pub prefixes: Vec<String>,
+    #[doc(hidden)] pub delimiters: Vec<String>,
 }
 
 impl Configuration {
@@ -269,8 +256,8 @@ impl Configuration {
 
         if let Ok(current_user) = http::get_current_user() {
             self.on_mention = Some(vec![
-                format!("<@{}>", current_user.id), // Regular mention
-                format!("<@!{}>", current_user.id) /* Nickname mention */,
+                format!("<@{}>", current_user.id),  // Regular mention
+                format!("<@!{}>", current_user.id), // Nickname mention
             ]);
         }
 
@@ -415,9 +402,8 @@ impl Configuration {
     /// ```
     pub fn delimiters(mut self, delimiters: Vec<&str>) -> Self {
         self.delimiters.clear();
-        self.delimiters.extend(
-            delimiters.into_iter().map(|s| s.to_string()),
-        );
+        self.delimiters
+            .extend(delimiters.into_iter().map(|s| s.to_string()));
 
         self
     }
diff --git a/src/framework/standard/create_command.rs b/src/framework/standard/create_command.rs
index 0a467e1..97bf092 100644
--- a/src/framework/standard/create_command.rs
+++ b/src/framework/standard/create_command.rs
@@ -11,9 +11,9 @@ pub struct CreateCommand(pub Command);
 impl CreateCommand {
     /// Adds multiple aliases.
     pub fn batch_known_as(mut self, names: Vec<&str>) -> Self {
-        self.0.aliases.extend(
-            names.into_iter().map(|n| n.to_owned()),
-        );
+        self.0
+            .aliases
+            .extend(names.into_iter().map(|n| n.to_owned()));
 
         self
     }
@@ -115,10 +115,7 @@ impl CreateCommand {
     ///
     /// You can return `Err(string)` if there's an error.
     pub fn exec_help<F>(mut self, f: F) -> Self
-        where F: Fn(&mut Context,
-                    &Message,
-                    HashMap<String, Arc<CommandGroup>>,
-                    Args)
+        where F: Fn(&mut Context, &Message, HashMap<String, Arc<CommandGroup>>, Args)
                     -> Result<(), String>
                      + 'static {
         self.0.exec = CommandType::WithCommands(Box::new(f));
diff --git a/src/framework/standard/create_group.rs b/src/framework/standard/create_group.rs
index 013ba67..d533c6a 100644
--- a/src/framework/standard/create_group.rs
+++ b/src/framework/standard/create_group.rs
@@ -35,9 +35,7 @@ impl CreateGroup {
             if let Some(ref prefix) = self.0.prefix {
                 self.0.commands.insert(
                     format!("{} {}", prefix, n.to_owned()),
-                    CommandOrAlias::Alias(
-                        format!("{} {}", prefix, command_name.to_string()),
-                    ),
+                    CommandOrAlias::Alias(format!("{} {}", prefix, command_name.to_string())),
                 );
             } else {
                 self.0.commands.insert(
@@ -61,10 +59,9 @@ impl CreateGroup {
         where F: Fn(&mut Context, &Message, Args) -> Result<(), String> + Send + Sync + 'static {
         let cmd = Arc::new(Command::new(f));
 
-        self.0.commands.insert(
-            command_name.to_owned(),
-            CommandOrAlias::Command(cmd),
-        );
+        self.0
+            .commands
+            .insert(command_name.to_owned(), CommandOrAlias::Command(cmd));
 
         self
     }
diff --git a/src/framework/standard/help_commands.rs b/src/framework/standard/help_commands.rs
index f081e1a..75c5b0b 100644
--- a/src/framework/standard/help_commands.rs
+++ b/src/framework/standard/help_commands.rs
@@ -116,19 +116,15 @@ pub fn with_embeds(_: &mut Context,
 
                         if let Some(ref usage) = command.usage {
                             embed = embed.field(|f| {
-                                f.name("Usage").value(
-                                    &format!("`{} {}`", command_name, usage),
-                                )
+                                f.name("Usage")
+                                    .value(&format!("`{} {}`", command_name, usage))
                             });
                         }
 
                         if let Some(ref example) = command.example {
                             embed = embed.field(|f| {
-                                f.name("Sample usage").value(&format!(
-                                    "`{} {}`",
-                                    command_name,
-                                    example
-                                ))
+                                f.name("Sample usage")
+                                    .value(&format!("`{} {}`", command_name, example))
                             });
                         }
 
@@ -297,10 +293,8 @@ pub fn plain(_: &mut Context,
             }
         }
 
-        let _ = msg.channel_id.say(&format!(
-            "**Error**: Command `{}` not found.",
-            name
-        ));
+        let _ = msg.channel_id
+            .say(&format!("**Error**: Command `{}` not found.", name));
 
         return Ok(());
     }
diff --git a/src/framework/standard/mod.rs b/src/framework/standard/mod.rs
index 0a29b59..3aaee92 100644
--- a/src/framework/standard/mod.rs
+++ b/src/framework/standard/mod.rs
@@ -25,6 +25,7 @@ use super::Framework;
 use model::{ChannelId, GuildId, Message, UserId};
 use model::permissions::Permissions;
 use tokio_core::reactor::Handle;
+use internal::RwLockExt;
 
 #[cfg(feature = "cache")]
 use client::CACHE;
@@ -395,18 +396,15 @@ impl StandardFramework {
     #[cfg(feature = "cache")]
     fn is_blocked_guild(&self, message: &Message) -> bool {
         if let Some(Channel::Guild(channel)) = CACHE.read().unwrap().channel(message.channel_id) {
-            let guild_id = channel.read().unwrap().guild_id;
+            let guild_id = channel.with(|g| g.guild_id);
             if self.configuration.blocked_guilds.contains(&guild_id) {
                 return true;
             }
 
             if let Some(guild) = guild_id.find() {
-                return self.configuration.blocked_users.contains(
-                    &guild
-                        .read()
-                        .unwrap()
-                        .owner_id,
-                );
+                return self.configuration
+                    .blocked_users
+                    .contains(&guild.with(|g| g.owner_id));
             }
         }
 
@@ -417,10 +415,8 @@ impl StandardFramework {
     fn has_correct_permissions(&self, command: &Arc<Command>, message: &Message) -> bool {
         if !command.required_permissions.is_empty() {
             if let Some(guild) = message.guild() {
-                let perms = guild.read().unwrap().permissions_for(
-                    message.channel_id,
-                    message.author.id,
-                );
+                let perms = guild
+                    .with(|g| g.permissions_for(message.channel_id, message.author.id));
 
                 return perms.contains(command.required_permissions);
             }
@@ -450,8 +446,7 @@ impl StandardFramework {
                     let rate_limit = bucket.take(message.author.id.0);
                     match bucket.check {
                         Some(ref check) => {
-                            let apply =
-                                feature_cache! {{
+                            let apply = feature_cache! {{
                                 let guild_id = message.guild_id();
                                 (check)(context, guild_id, message.channel_id, message.author.id)
                             } else {
@@ -462,10 +457,8 @@ impl StandardFramework {
                                 return Some(DispatchError::RateLimited(rate_limit));
                             }
                         },
-                        None => {
-                            if rate_limit > 0i64 {
-                                return Some(DispatchError::RateLimited(rate_limit));
-                            }
+                        None => if rate_limit > 0i64 {
+                            return Some(DispatchError::RateLimited(rate_limit));
                         },
                     }
                 }
@@ -515,18 +508,19 @@ impl StandardFramework {
 
             if command.owners_only {
                 Some(DispatchError::OnlyForOwners)
-            } else if self.configuration.blocked_users.contains(
-                &message.author.id,
-            ) {
+            } else if self.configuration
+                   .blocked_users
+                   .contains(&message.author.id) {
                 Some(DispatchError::BlockedUser)
             } else if self.configuration.disabled_commands.contains(to_check) {
                 Some(DispatchError::CommandDisabled(to_check.to_owned()))
             } else if self.configuration.disabled_commands.contains(built) {
                 Some(DispatchError::CommandDisabled(built.to_owned()))
             } else {
-                let all_passed = command.checks.iter().all(|check| {
-                    check(&mut context, message, args, command)
-                });
+                let all_passed = command
+                    .checks
+                    .iter()
+                    .all(|check| check(&mut context, message, args, command));
 
                 if all_passed {
                     None
@@ -580,21 +574,16 @@ impl StandardFramework {
     pub fn on<F, S>(mut self, command_name: S, f: F) -> Self
         where F: Fn(&mut Context, &Message, Args) -> Result<(), String> + 'static, S: Into<String> {
         {
-            let ungrouped = self.groups.entry("Ungrouped".to_owned()).or_insert_with(
-                || {
-                    Arc::new(CommandGroup::default())
-                },
-            );
+            let ungrouped = self.groups
+                .entry("Ungrouped".to_owned())
+                .or_insert_with(|| Arc::new(CommandGroup::default()));
 
             if let Some(ref mut group) = Arc::get_mut(ungrouped) {
                 let name = command_name.into();
 
-                group.commands.insert(
-                    name,
-                    CommandOrAlias::Command(
-                        Arc::new(Command::new(f)),
-                    ),
-                );
+                group
+                    .commands
+                    .insert(name, CommandOrAlias::Command(Arc::new(Command::new(f))));
             }
         }
 
@@ -617,11 +606,9 @@ impl StandardFramework {
     pub fn command<F, S>(mut self, command_name: S, f: F) -> Self
         where F: FnOnce(CreateCommand) -> CreateCommand, S: Into<String> {
         {
-            let ungrouped = self.groups.entry("Ungrouped".to_owned()).or_insert_with(
-                || {
-                    Arc::new(CommandGroup::default())
-                },
-            );
+            let ungrouped = self.groups
+                .entry("Ungrouped".to_owned())
+                .or_insert_with(|| Arc::new(CommandGroup::default()));
 
             if let Some(ref mut group) = Arc::get_mut(ungrouped) {
                 let cmd = f(CreateCommand(Command::default())).0;
@@ -636,17 +623,15 @@ impl StandardFramework {
                     }
                 } else {
                     for v in &cmd.aliases {
-                        group.commands.insert(
-                            v.to_owned(),
-                            CommandOrAlias::Alias(name.clone()),
-                        );
+                        group
+                            .commands
+                            .insert(v.to_owned(), CommandOrAlias::Alias(name.clone()));
                     }
                 }
 
-                group.commands.insert(
-                    name,
-                    CommandOrAlias::Command(Arc::new(cmd)),
-                );
+                group
+                    .commands
+                    .insert(name, CommandOrAlias::Command(Arc::new(cmd)));
             }
         }
 
@@ -859,8 +844,7 @@ impl Framework for StandardFramework {
                 for group in groups.values() {
                     let command_length = built.len();
 
-                    if let Some(&CommandOrAlias::Alias(ref points_to)) =
-                        group.commands.get(&built) {
+                    if let Some(&CommandOrAlias::Alias(ref points_to)) = group.commands.get(&built) {
                         built = points_to.to_owned();
                     }
 
diff --git a/src/gateway/shard.rs b/src/gateway/shard.rs
index dc7ee83..7663cee 100644
--- a/src/gateway/shard.rs
+++ b/src/gateway/shard.rs
@@ -12,7 +12,7 @@ use websocket::stream::sync::AsTcpStream;
 use websocket::sync::client::{Client, ClientBuilder};
 use websocket::sync::stream::{TcpStream, TlsStream};
 use websocket::WebSocketError;
-use constants::{self, OpCode, close_codes};
+use constants::{self, close_codes, OpCode};
 use internal::prelude::*;
 use internal::ws_impl::SenderExt;
 use model::event::{Event, GatewayEvent};
@@ -95,8 +95,7 @@ pub struct Shard {
     /// update the voice connections' states.
     #[cfg(feature = "voice")]
     pub manager: VoiceManager,
-    #[cfg(feature = "voice")]
-    manager_rx: MpscReceiver<Value>,
+    #[cfg(feature = "voice")] manager_rx: MpscReceiver<Value>,
 }
 
 impl Shard {
@@ -137,42 +136,41 @@ impl Shard {
         let stage = ConnectionStage::Handshake;
         let session_id = None;
 
-        let mut shard =
-            feature_voice! {{
-            let (tx, rx) = mpsc::channel();
-
-            let user = http::get_current_user()?;
-
-            Shard {
-                client,
-                current_presence,
-                heartbeat_instants,
-                heartbeat_interval,
-                last_heartbeat_acknowledged,
-                seq,
-                stage,
-                token,
-                session_id,
-                shard_info,
-                ws_url,
-                manager: VoiceManager::new(tx, user.id),
-                manager_rx: rx,
-            }
-        } else {
-            Shard {
-                client,
-                current_presence,
-                heartbeat_instants,
-                heartbeat_interval,
-                last_heartbeat_acknowledged,
-                seq,
-                stage,
-                token,
-                session_id,
-                shard_info,
-                ws_url,
-            }
-        }};
+        let mut shard = feature_voice! {{
+                                            let (tx, rx) = mpsc::channel();
+        
+                                            let user = http::get_current_user()?;
+        
+                                            Shard {
+                                                client,
+                                                current_presence,
+                                                heartbeat_instants,
+                                                heartbeat_interval,
+                                                last_heartbeat_acknowledged,
+                                                seq,
+                                                stage,
+                                                token,
+                                                session_id,
+                                                shard_info,
+                                                ws_url,
+                                                manager: VoiceManager::new(tx, user.id),
+                                                manager_rx: rx,
+                                            }
+                                        } else {
+                                            Shard {
+                                                client,
+                                                current_presence,
+                                                heartbeat_instants,
+                                                heartbeat_interval,
+                                                last_heartbeat_acknowledged,
+                                                seq,
+                                                stage,
+                                                token,
+                                                session_id,
+                                                shard_info,
+                                                ws_url,
+                                            }
+                                        }};
 
         shard.identify()?;
 
@@ -416,7 +414,7 @@ impl Shard {
             },
             Ok(GatewayEvent::InvalidateSession) => {
                 info!("[Shard {:?}] Received session invalidation; re-identifying",
-                      self.shard_info);
+                self.shard_info);
 
                 self.seq = 0;
                 self.session_id = None;
@@ -435,10 +433,10 @@ impl Shard {
                     let kind = if clean { "Cleanly" } else { "Uncleanly" };
 
                     info!("[Shard {:?}] {} closing with {:?}: {:?}",
-                          self.shard_info,
-                          kind,
-                          num,
-                          reason);
+                    self.shard_info,
+                    kind,
+                    num,
+                    reason);
                 }
 
                 match num {
@@ -471,17 +469,16 @@ impl Shard {
 
                         return Err(Error::Gateway(GatewayError::OverloadedShard));
                     },
-                    Some(4006) |
-                    Some(close_codes::SESSION_TIMEOUT) => {
+                    Some(4006) | Some(close_codes::SESSION_TIMEOUT) => {
                         info!("[Shard {:?}] Invalid session", self.shard_info);
 
                         self.session_id = None;
                     },
                     Some(other) if !clean => {
                         warn!("[Shard {:?}] Unknown unclean close {}: {:?}",
-                              self.shard_info,
-                              other,
-                              reason);
+                        self.shard_info,
+                        other,
+                        reason);
                     },
                     _ => {},
                 }
@@ -742,10 +739,9 @@ impl Shard {
             },
             Err(why) => {
                 match why {
-                    Error::WebSocket(WebSocketError::IoError(err)) => {
-                        if err.raw_os_error() != Some(32) {
-                            debug!("[Shard {:?}] Err w/ heartbeating: {:?}", self.shard_info, err);
-                        }
+                    Error::WebSocket(WebSocketError::IoError(err)) => if err.raw_os_error() !=
+                                                                         Some(32) {
+                        debug!("[Shard {:?}] Err w/ heartbeating: {:?}", self.shard_info, err);
                     },
                     other => {
                         warn!("[Shard {:?}] Other err w/ keepalive: {:?}", self.shard_info, other);
@@ -780,8 +776,8 @@ impl Shard {
 
             return self.reconnect().map_err(|why| {
                 warn!("[Shard {:?}] Err auto-reconnecting from heartbeat check: {:?}",
-                      self.shard_info,
-                      why);
+                self.shard_info,
+                why);
 
                 why
             });
diff --git a/src/http/mod.rs b/src/http/mod.rs
index ab9bdb0..91a5e96 100644
--- a/src/http/mod.rs
+++ b/src/http/mod.rs
@@ -35,7 +35,7 @@ use hyper::header::ContentType;
 use hyper::method::Method;
 use hyper::mime::{Mime, SubLevel, TopLevel};
 use hyper::net::HttpsConnector;
-use hyper::{Error as HyperError, Result as HyperResult, Url, header};
+use hyper::{header, Error as HyperError, Result as HyperResult, Url};
 use hyper_native_tls::NativeTlsClient;
 use multipart::client::Multipart;
 use self::ratelimiting::Route;
@@ -549,9 +549,9 @@ pub fn delete_reaction(channel_id: u64,
                        user_id: Option<u64>,
                        reaction_type: &ReactionType)
                        -> Result<()> {
-    let user = user_id.map(|uid| uid.to_string()).unwrap_or_else(
-        || "@me".to_string(),
-    );
+    let user = user_id
+        .map(|uid| uid.to_string())
+        .unwrap_or_else(|| "@me".to_string());
 
     verify(
         204,
@@ -634,9 +634,8 @@ pub fn delete_webhook_with_token(webhook_id: u64, token: &str) -> Result<()> {
     verify(
         204,
         retry(|| {
-            client.delete(
-                &format!(api!("/webhooks/{}/{}"), webhook_id, token),
-            )
+            client
+                .delete(&format!(api!("/webhooks/{}/{}"), webhook_id, token))
         }).map_err(Error::Hyper)?,
     )
 }
@@ -739,9 +738,7 @@ pub fn edit_message(channel_id: u64, message_id: u64, map: &Value) -> Result<Mes
 ///
 /// [`Guild`]: ../model/struct.Guild.html
 pub fn edit_nickname(guild_id: u64, new_nickname: Option<&str>) -> Result<()> {
-    let map = json!({
-        "nick": new_nickname
-    });
+    let map = json!({ "nick": new_nickname });
     let body = map.to_string();
     let response = request!(
         Route::GuildsIdMembersMeNick(guild_id),
@@ -779,9 +776,8 @@ pub fn edit_profile(map: &JsonMap) -> Result<CurrentUser> {
         }
     }
 
-    serde_json::from_value::<CurrentUser>(value).map_err(
-        From::from,
-    )
+    serde_json::from_value::<CurrentUser>(value)
+        .map_err(From::from)
 }
 
 /// Changes a role in a guild.
@@ -991,11 +987,8 @@ pub fn get_active_maintenances() -> Result<Vec<Maintenance>> {
     let mut map: BTreeMap<String, Value> = serde_json::from_reader(response)?;
 
     match map.remove("scheduled_maintenances") {
-        Some(v) => {
-            serde_json::from_value::<Vec<Maintenance>>(v).map_err(
-                From::from,
-            )
-        },
+        Some(v) => serde_json::from_value::<Vec<Maintenance>>(v)
+            .map_err(From::from),
         None => Ok(vec![]),
     }
 }
@@ -1401,10 +1394,7 @@ pub fn get_member(guild_id: u64, user_id: u64) -> Result<Member> {
     let mut v = serde_json::from_reader::<HyperResponse, Value>(response)?;
 
     if let Some(map) = v.as_object_mut() {
-        map.insert(
-            "guild_id".to_owned(),
-            Value::Number(Number::from(guild_id)),
-        );
+        map.insert("guild_id".to_owned(), Value::Number(Number::from(guild_id)));
     }
 
     serde_json::from_value::<Member>(v).map_err(From::from)
@@ -1489,11 +1479,8 @@ pub fn get_unresolved_incidents() -> Result<Vec<Incident>> {
     let mut map: BTreeMap<String, Value> = serde_json::from_reader(response)?;
 
     match map.remove("incidents") {
-        Some(v) => {
-            serde_json::from_value::<Vec<Incident>>(v).map_err(
-                From::from,
-            )
-        },
+        Some(v) => serde_json::from_value::<Vec<Incident>>(v)
+            .map_err(From::from),
         None => Ok(vec![]),
     }
 }
@@ -1511,11 +1498,8 @@ pub fn get_upcoming_maintenances() -> Result<Vec<Maintenance>> {
     let mut map: BTreeMap<String, Value> = serde_json::from_reader(response)?;
 
     match map.remove("scheduled_maintenances") {
-        Some(v) => {
-            serde_json::from_value::<Vec<Maintenance>>(v).map_err(
-                From::from,
-            )
-        },
+        Some(v) => serde_json::from_value::<Vec<Maintenance>>(v)
+            .map_err(From::from),
         None => Ok(vec![]),
     }
 }
@@ -1589,9 +1573,8 @@ pub fn get_webhook_with_token(webhook_id: u64, token: &str) -> Result<Webhook> {
     let client = request_client!();
 
     let response = retry(|| {
-        client.get(
-            &format!(api!("/webhooks/{}/{}"), webhook_id, token),
-        )
+        client
+            .get(&format!(api!("/webhooks/{}/{}"), webhook_id, token))
     }).map_err(Error::Hyper)?;
 
     serde_json::from_reader::<HyperResponse, Webhook>(response)
@@ -1667,12 +1650,12 @@ pub fn send_files<'a, T>(channel_id: u64, files: Vec<T>, map: JsonMap) -> Result
     let tc = NativeTlsClient::new()?;
     let connector = HttpsConnector::new(tc);
     let mut request = Request::with_connector(Method::Post, url, &connector)?;
-    request.headers_mut().set(header::Authorization(
-        TOKEN.lock().unwrap().clone(),
-    ));
-    request.headers_mut().set(header::UserAgent(
-        constants::USER_AGENT.to_owned(),
-    ));
+    request
+        .headers_mut()
+        .set(header::Authorization(TOKEN.lock().unwrap().clone()));
+    request
+        .headers_mut()
+        .set(header::UserAgent(constants::USER_AGENT.to_owned()));
 
     let mut request = Multipart::from_request(request)?;
     let mut file_num = "0".to_owned();
@@ -1680,20 +1663,12 @@ pub fn send_files<'a, T>(channel_id: u64, files: Vec<T>, map: JsonMap) -> Result
     for file in files {
         match file.into() {
             AttachmentType::Bytes((mut bytes, filename)) => {
-                request.write_stream(
-                    &file_num,
-                    &mut bytes,
-                    Some(filename),
-                    None,
-                )?;
+                request
+                    .write_stream(&file_num, &mut bytes, Some(filename), None)?;
             },
             AttachmentType::File((mut f, filename)) => {
-                request.write_stream(
-                    &file_num,
-                    &mut f,
-                    Some(filename),
-                    None,
-                )?;
+                request
+                    .write_stream(&file_num, &mut f, Some(filename), None)?;
             },
             AttachmentType::Path(p) => {
                 request.write_file(&file_num, &p)?;
@@ -1836,8 +1811,7 @@ pub fn unpin_message(channel_id: u64, message_id: u64) -> Result<()> {
 fn request<'a, F>(route: Route, f: F) -> Result<HyperResponse>
     where F: Fn() -> RequestBuilder<'a> {
     let response = ratelimiting::perform(route, || {
-        f()
-            .header(header::Authorization(TOKEN.lock().unwrap().clone()))
+        f().header(header::Authorization(TOKEN.lock().unwrap().clone()))
             .header(header::ContentType::json())
     })?;
 
@@ -1851,8 +1825,7 @@ fn request<'a, F>(route: Route, f: F) -> Result<HyperResponse>
 pub(crate) fn retry<'a, F>(f: F) -> HyperResult<HyperResponse>
     where F: Fn() -> RequestBuilder<'a> {
     let req = || {
-        f()
-            .header(header::UserAgent(constants::USER_AGENT.to_owned()))
+        f().header(header::UserAgent(constants::USER_AGENT.to_owned()))
             .send()
     };
 
diff --git a/src/http/ratelimiting.rs b/src/http/ratelimiting.rs
index 039f15d..52762f5 100644
--- a/src/http/ratelimiting.rs
+++ b/src/http/ratelimiting.rs
@@ -47,7 +47,7 @@ use hyper::status::StatusCode;
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
-use std::{i64, str, thread};
+use std::{str, thread, i64};
 use super::{HttpError, LightMethod};
 use internal::prelude::*;
 
@@ -399,15 +399,16 @@ pub(crate) fn perform<'a, F>(route: Route, f: F) -> Result<Response>
             let redo = if response.headers.get_raw("x-ratelimit-global").is_some() {
                 let _ = GLOBAL.lock().expect("global route lock poisoned");
 
-                Ok(if let Some(retry_after) =
-                    parse_header(&response.headers, "retry-after")? {
-                    debug!("Ratelimited on route {:?} for {:?}ms", route, retry_after);
-                    thread::sleep(Duration::from_millis(retry_after as u64));
+                Ok(
+                    if let Some(retry_after) = parse_header(&response.headers, "retry-after")? {
+                        debug!("Ratelimited on route {:?} for {:?}ms", route, retry_after);
+                        thread::sleep(Duration::from_millis(retry_after as u64));
 
-                    true
-                } else {
-                    false
-                })
+                        true
+                    } else {
+                        false
+                    },
+                )
             } else {
                 lock.post_hook(&response, &route)
             };
@@ -505,16 +506,12 @@ impl RateLimit {
 
 fn parse_header(headers: &Headers, header: &str) -> Result<Option<i64>> {
     match headers.get_raw(header) {
-        Some(header) => {
-            match str::from_utf8(&header[0]) {
-                Ok(v) => {
-                    match v.parse::<i64>() {
-                        Ok(v) => Ok(Some(v)),
-                        Err(_) => Err(Error::Http(HttpError::RateLimitI64)),
-                    }
-                },
-                Err(_) => Err(Error::Http(HttpError::RateLimitUtf8)),
-            }
+        Some(header) => match str::from_utf8(&header[0]) {
+            Ok(v) => match v.parse::<i64>() {
+                Ok(v) => Ok(Some(v)),
+                Err(_) => Err(Error::Http(HttpError::RateLimitI64)),
+            },
+            Err(_) => Err(Error::Http(HttpError::RateLimitUtf8)),
         },
         None => Ok(None),
     }
diff --git a/src/internal/mod.rs b/src/internal/mod.rs
index 2ff8067..a0c8142 100644
--- a/src/internal/mod.rs
+++ b/src/internal/mod.rs
@@ -3,6 +3,10 @@ pub mod macros;
 
 pub mod prelude;
 
+mod rwlock_ext;
+
+pub use self::rwlock_ext::RwLockExt;
+
 #[cfg(feature = "gateway")]
 pub mod ws_impl;
 
diff --git a/src/internal/rwlock_ext.rs b/src/internal/rwlock_ext.rs
new file mode 100644
index 0000000..8266cdf
--- /dev/null
+++ b/src/internal/rwlock_ext.rs
@@ -0,0 +1,18 @@
+use std::sync::{Arc, RwLock};
+
+pub trait RwLockExt<T> {
+    fn with<Y, F: Fn(&T) -> Y>(&self, f: F) -> Y;
+    fn with_mut<Y, F: FnMut(&mut T) -> Y>(&self, f: F) -> Y;
+}
+
+impl<T> RwLockExt<T> for Arc<RwLock<T>> {
+    fn with<Y, F: Fn(&T) -> Y>(&self, f: F) -> Y {
+        let r = self.read().unwrap();
+        f(&r)
+    }
+
+    fn with_mut<Y, F: FnMut(&mut T) -> Y>(&self, mut f: F) -> Y {
+        let mut w = self.write().unwrap();
+        f(&mut w)
+    }
+}
diff --git a/src/internal/ws_impl.rs b/src/internal/ws_impl.rs
index cd9161a..70c4cb7 100644
--- a/src/internal/ws_impl.rs
+++ b/src/internal/ws_impl.rs
@@ -7,7 +7,8 @@ use gateway::GatewayError;
 use internal::prelude::*;
 
 pub trait ReceiverExt {
-    fn recv_json<F, T>(&mut self, decode: F) -> Result<T> where F: Fn(Value) -> Result<T>;
+    fn recv_json<F, T>(&mut self, decode: F) -> Result<T>
+        where F: Fn(Value) -> Result<T>;
 }
 
 pub trait SenderExt {
@@ -42,9 +43,8 @@ impl ReceiverExt for WsClient<TlsStream<TcpStream>> {
                 }))
             },
             OwnedMessage::Ping(x) => {
-                self.send_message(&OwnedMessage::Pong(x)).map_err(
-                    Error::from,
-                )?;
+                self.send_message(&OwnedMessage::Pong(x))
+                    .map_err(Error::from)?;
 
                 None
             },
diff --git a/src/lib.rs b/src/lib.rs
index 3893968..066d926 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -105,11 +105,9 @@ extern crate lazy_static;
 extern crate base64;
 extern crate chrono;
 extern crate flate2;
-extern crate serde;
 extern crate parking_lot;
+extern crate serde;
 
-#[cfg(feature = "framework")]
-extern crate vec_shift;
 #[cfg(feature = "voice")]
 extern crate byteorder;
 #[cfg(feature = "futures")]
@@ -130,6 +128,8 @@ extern crate sodiumoxide;
 extern crate tokio_core;
 #[cfg(feature = "client")]
 extern crate typemap;
+#[cfg(feature = "framework")]
+extern crate vec_shift;
 #[cfg(feature = "gateway")]
 extern crate websocket;
 
diff --git a/src/model/channel/channel_id.rs b/src/model/channel/channel_id.rs
index d8ccc71..cf9e41c 100644
--- a/src/model/channel/channel_id.rs
+++ b/src/model/channel/channel_id.rs
@@ -1,5 +1,6 @@
 use std::fmt::{Display, Formatter, Result as FmtResult};
 use model::*;
+use internal::RwLockExt;
 
 #[cfg(feature = "model")]
 use std::borrow::Cow;
@@ -99,7 +100,7 @@ impl ChannelId {
     /// [`Message::delete`]: struct.Message.html#method.delete
     /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
     #[inline]
-    pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()> {
+pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()>{
         http::delete_message(self.0, message_id.into().0)
     }
 
@@ -186,7 +187,7 @@ impl ChannelId {
     /// [`Channel`]: enum.Channel.html
     /// [Manage Channel]: permissions/constant.MANAGE_CHANNELS.html
     #[inline]
-    pub fn edit<F: FnOnce(EditChannel) -> EditChannel>(&self, f: F) -> Result<GuildChannel> {
+pub fn edit<F: FnOnce(EditChannel) -> EditChannel>(&self, f: F) -> Result<GuildChannel>{
         http::edit_channel(self.0, &f(EditChannel::default()).0)
     }
 
@@ -255,13 +256,12 @@ impl ChannelId {
     /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
     #[inline]
     pub fn message<M: Into<MessageId>>(&self, message_id: M) -> Result<Message> {
-        http::get_message(self.0, message_id.into().0).map(
-            |mut msg| {
+        http::get_message(self.0, message_id.into().0)
+            .map(|mut msg| {
                 msg.transform_content();
 
                 msg
-            },
-        )
+            })
     }
 
     /// Gets messages from the channel.
@@ -306,11 +306,9 @@ impl ChannelId {
                   None => return None,
               } {
             Guild(channel) => channel.read().unwrap().name().to_string(),
-            Group(channel) => {
-                match channel.read().unwrap().name() {
-                    Cow::Borrowed(name) => name.to_string(),
-                    Cow::Owned(name) => name,
-                }
+            Group(channel) => match channel.read().unwrap().name() {
+                Cow::Borrowed(name) => name.to_string(),
+                Cow::Owned(name) => name,
             },
             Private(channel) => channel.read().unwrap().name(),
         })
@@ -512,9 +510,9 @@ impl From<Channel> for ChannelId {
     /// Gets the Id of a `Channel`.
     fn from(channel: Channel) -> ChannelId {
         match channel {
-            Channel::Group(group) => group.read().unwrap().channel_id,
-            Channel::Guild(ch) => ch.read().unwrap().id,
-            Channel::Private(ch) => ch.read().unwrap().id,
+            Channel::Group(group) => group.with(|g| g.channel_id),
+            Channel::Guild(ch) => ch.with(|c| c.id),
+            Channel::Private(ch) => ch.with(|c| c.id),
         }
     }
 }
@@ -523,9 +521,9 @@ impl<'a> From<&'a Channel> for ChannelId {
     /// Gets the Id of a `Channel`.
     fn from(channel: &Channel) -> ChannelId {
         match *channel {
-            Channel::Group(ref group) => group.read().unwrap().channel_id,
-            Channel::Guild(ref ch) => ch.read().unwrap().id,
-            Channel::Private(ref ch) => ch.read().unwrap().id,
+            Channel::Group(ref group) => group.with(|g| g.channel_id),
+            Channel::Guild(ref ch) => ch.with(|c| c.id),
+            Channel::Private(ref ch) => ch.with(|c| c.id),
         }
     }
 }
diff --git a/src/model/channel/group.rs b/src/model/channel/group.rs
index 7007ad6..94483ec 100644
--- a/src/model/channel/group.rs
+++ b/src/model/channel/group.rs
@@ -1,5 +1,6 @@
 use chrono::{DateTime, FixedOffset};
 use model::*;
+use internal::RwLockExt;
 
 #[cfg(feature = "model")]
 use std::borrow::Cow;
@@ -123,11 +124,8 @@ impl Group {
                                  reaction_type: R)
                                  -> Result<()>
         where M: Into<MessageId>, R: Into<ReactionType> {
-        self.channel_id.delete_reaction(
-            message_id,
-            user_id,
-            reaction_type,
-        )
+        self.channel_id
+            .delete_reaction(message_id, user_id, reaction_type)
     }
 
     /// Edits a [`Message`] in the channel given its Id.
@@ -208,12 +206,12 @@ impl Group {
             Some(ref name) => Cow::Borrowed(name),
             None => {
                 let mut name = match self.recipients.values().nth(0) {
-                    Some(recipient) => recipient.read().unwrap().name.clone(),
+                    Some(recipient) => recipient.with(|c| c.name.clone()),
                     None => return Cow::Borrowed("Empty Group"),
                 };
 
                 for recipient in self.recipients.values().skip(1) {
-                    let _ = write!(name, ", {}", recipient.read().unwrap().name);
+                    let _ = write!(name, ", {}", recipient.with(|r| r.name.clone()));
                 }
 
                 Cow::Owned(name)
@@ -245,12 +243,8 @@ impl Group {
                                    after: Option<U>)
                                    -> Result<Vec<User>>
         where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
-        self.channel_id.reaction_users(
-            message_id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.channel_id
+            .reaction_users(message_id, reaction_type, limit, after)
     }
 
     /// Removes a recipient from the group. If the recipient is already not in
@@ -315,7 +309,7 @@ impl Group {
     /// [`CreateMessage`]: ../builder/struct.CreateMessage.html
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
     #[inline]
-    pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message> {
+pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message>{
         self.channel_id.send_message(f)
     }
 
diff --git a/src/model/channel/guild_channel.rs b/src/model/channel/guild_channel.rs
index 3fadd72..620ba93 100644
--- a/src/model/channel/guild_channel.rs
+++ b/src/model/channel/guild_channel.rs
@@ -300,7 +300,6 @@ impl GuildChannel {
     /// ```
     pub fn edit<F>(&mut self, f: F) -> Result<()>
         where F: FnOnce(EditChannel) -> EditChannel {
-
         #[cfg(feature = "cache")]
         {
             let req = permissions::MANAGE_CHANNELS;
@@ -311,10 +310,7 @@ impl GuildChannel {
         }
 
         let mut map = Map::new();
-        map.insert(
-            "name".to_owned(),
-            Value::String(self.name.clone()),
-        );
+        map.insert("name".to_owned(), Value::String(self.name.clone()));
         map.insert(
             "position".to_owned(),
             Value::Number(Number::from(self.position)),
@@ -543,12 +539,8 @@ impl GuildChannel {
                                    after: Option<U>)
                                    -> Result<Vec<User>>
         where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
-        self.id.reaction_users(
-            message_id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.id
+            .reaction_users(message_id, reaction_type, limit, after)
     }
 
     /// Sends a message with just the given message content in the channel.
@@ -607,7 +599,7 @@ impl GuildChannel {
     /// [`ModelError::MessageTooLong`]: enum.ModelError.html#variant.MessageTooLong
     /// [`Message`]: struct.Message.html
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
-    pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message> {
+pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message>{
         #[cfg(feature = "cache")]
         {
             let req = permissions::SEND_MESSAGES;
diff --git a/src/model/channel/message.rs b/src/model/channel/message.rs
index 27f4e31..399d351 100644
--- a/src/model/channel/message.rs
+++ b/src/model/channel/message.rs
@@ -291,10 +291,9 @@ impl Message {
         }
 
         // And finally replace everyone and here mentions.
-        result.replace("@everyone", "@\u{200B}everyone").replace(
-            "@here",
-            "@\u{200B}here",
-        )
+        result
+            .replace("@everyone", "@\u{200B}everyone")
+            .replace("@here", "@\u{200B}here")
     }
 
     /// Gets the list of [`User`]s who have reacted to a [`Message`] with a
@@ -320,12 +319,8 @@ impl Message {
                                 after: Option<U>)
                                 -> Result<Vec<User>>
         where R: Into<ReactionType>, U: Into<UserId> {
-        self.channel_id.reaction_users(
-            self.id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.channel_id
+            .reaction_users(self.id, reaction_type, limit, after)
     }
 
     /// Returns the associated `Guild` for the message if one is in the cache.
@@ -338,9 +333,8 @@ impl Message {
     /// [`guild_id`]: #method.guild_id
     #[cfg(feature = "cache")]
     pub fn guild(&self) -> Option<Arc<RwLock<Guild>>> {
-        self.guild_id().and_then(|guild_id| {
-            CACHE.read().unwrap().guild(guild_id)
-        })
+        self.guild_id()
+            .and_then(|guild_id| CACHE.read().unwrap().guild(guild_id))
     }
 
     /// Retrieves the Id of the guild that the message was sent in, if sent in
@@ -360,8 +354,7 @@ impl Message {
     #[cfg(feature = "cache")]
     pub fn is_private(&self) -> bool {
         match CACHE.read().unwrap().channel(self.channel_id) {
-            Some(Channel::Group(_)) |
-            Some(Channel::Private(_)) => true,
+            Some(Channel::Group(_)) | Some(Channel::Private(_)) => true,
             _ => false,
         }
     }
@@ -378,7 +371,11 @@ impl Message {
         let count = content.chars().count() as i64;
         let diff = count - (constants::MESSAGE_CODE_LIMIT as i64);
 
-        if diff > 0 { Some(diff as u64) } else { None }
+        if diff > 0 {
+            Some(diff as u64)
+        } else {
+            None
+        }
     }
 
     /// Pins this message to its channel.
diff --git a/src/model/channel/mod.rs b/src/model/channel/mod.rs
index 626f466..0911139 100644
--- a/src/model/channel/mod.rs
+++ b/src/model/channel/mod.rs
@@ -20,6 +20,7 @@ use serde::de::Error as DeError;
 use serde_json;
 use super::utils::deserialize_u64;
 use model::*;
+use internal::RwLockExt;
 
 #[cfg(feature = "model")]
 use std::fmt::{Display, Formatter, Result as FmtResult};
@@ -99,7 +100,7 @@ impl Channel {
     /// [`Message::delete`]: struct.Message.html#method.delete
     /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
     #[inline]
-    pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()> {
+pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()>{
         self.id().delete_message(message_id)
     }
 
@@ -117,11 +118,8 @@ impl Channel {
                                  reaction_type: R)
                                  -> Result<()>
         where M: Into<MessageId>, R: Into<ReactionType> {
-        self.id().delete_reaction(
-            message_id,
-            user_id,
-            reaction_type,
-        )
+        self.id()
+            .delete_reaction(message_id, user_id, reaction_type)
     }
 
     /// Edits a [`Message`] in the channel given its Id.
@@ -158,9 +156,8 @@ impl Channel {
     #[inline]
     pub fn is_nsfw(&self) -> bool {
         match *self {
-            Channel::Guild(ref channel) => channel.read().unwrap().is_nsfw(),
-            Channel::Group(_) |
-            Channel::Private(_) => false,
+            Channel::Guild(ref channel) => channel.with(|c| c.is_nsfw()),
+            Channel::Group(_) | Channel::Private(_) => false,
         }
     }
 
@@ -220,12 +217,8 @@ impl Channel {
                                    after: Option<U>)
                                    -> Result<Vec<User>>
         where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
-        self.id().reaction_users(
-            message_id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.id()
+            .reaction_users(message_id, reaction_type, limit, after)
     }
 
     /// Retrieves the Id of the inner [`Group`], [`GuildChannel`], or
@@ -236,9 +229,9 @@ impl Channel {
     /// [`PrivateChannel`]: struct.PrivateChannel.html
     pub fn id(&self) -> ChannelId {
         match *self {
-            Channel::Group(ref group) => group.read().unwrap().channel_id,
-            Channel::Guild(ref channel) => channel.read().unwrap().id,
-            Channel::Private(ref channel) => channel.read().unwrap().id,
+            Channel::Group(ref group) => group.with(|g| g.channel_id),
+            Channel::Guild(ref ch) => ch.with(|c| c.id),
+            Channel::Private(ref ch) => ch.with(|c| c.id),
         }
     }
 
@@ -326,21 +319,15 @@ impl<'de> Deserialize<'de> for Channel {
         };
 
         match kind {
-            0 | 2 => {
-                serde_json::from_value::<GuildChannel>(Value::Object(v))
-                    .map(|x| Channel::Guild(Arc::new(RwLock::new(x))))
-                    .map_err(DeError::custom)
-            },
-            1 => {
-                serde_json::from_value::<PrivateChannel>(Value::Object(v))
-                    .map(|x| Channel::Private(Arc::new(RwLock::new(x))))
-                    .map_err(DeError::custom)
-            },
-            3 => {
-                serde_json::from_value::<Group>(Value::Object(v))
-                    .map(|x| Channel::Group(Arc::new(RwLock::new(x))))
-                    .map_err(DeError::custom)
-            },
+            0 | 2 => serde_json::from_value::<GuildChannel>(Value::Object(v))
+                .map(|x| Channel::Guild(Arc::new(RwLock::new(x))))
+                .map_err(DeError::custom),
+            1 => serde_json::from_value::<PrivateChannel>(Value::Object(v))
+                .map(|x| Channel::Private(Arc::new(RwLock::new(x))))
+                .map_err(DeError::custom),
+            3 => serde_json::from_value::<Group>(Value::Object(v))
+                .map(|x| Channel::Group(Arc::new(RwLock::new(x))))
+                .map_err(DeError::custom),
             _ => Err(DeError::custom("Unknown channel type")),
         }
     }
@@ -412,10 +399,8 @@ impl ChannelType {
 struct PermissionOverwriteData {
     allow: Permissions,
     deny: Permissions,
-    #[serde(deserialize_with = "deserialize_u64")]
-    id: u64,
-    #[serde(rename = "type")]
-    kind: String,
+    #[serde(deserialize_with = "deserialize_u64")] id: u64,
+    #[serde(rename = "type")] kind: String,
 }
 
 /// A channel-specific permission overwrite for a member or role.
diff --git a/src/model/channel/private_channel.rs b/src/model/channel/private_channel.rs
index 30dc01d..e5e14d9 100644
--- a/src/model/channel/private_channel.rs
+++ b/src/model/channel/private_channel.rs
@@ -2,6 +2,7 @@ use chrono::{DateTime, FixedOffset};
 use std::fmt::{Display, Formatter, Result as FmtResult};
 use super::deserialize_single_recipient;
 use model::*;
+use internal::RwLockExt;
 
 #[cfg(feature = "model")]
 use builder::{CreateMessage, GetMessages};
@@ -169,7 +170,7 @@ impl PrivateChannel {
     }
 
     /// Returns "DM with $username#discriminator".
-    pub fn name(&self) -> String { format!("DM with {}", self.recipient.read().unwrap().tag()) }
+    pub fn name(&self) -> String { format!("DM with {}", self.recipient.with(|r| r.tag())) }
 
     /// Gets the list of [`User`]s who have reacted to a [`Message`] with a
     /// certain [`Emoji`].
@@ -191,12 +192,8 @@ impl PrivateChannel {
                                    after: Option<U>)
                                    -> Result<Vec<User>>
         where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
-        self.id.reaction_users(
-            message_id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.id
+            .reaction_users(message_id, reaction_type, limit, after)
     }
 
     /// Pins a [`Message`] to the channel.
@@ -262,7 +259,7 @@ impl PrivateChannel {
     /// [`CreateMessage`]: ../builder/struct.CreateMessage.html
     /// [`Message`]: struct.Message.html
     #[inline]
-    pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message> {
+pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message>{
         self.id.send_message(f)
     }
 
diff --git a/src/model/channel/reaction.rs b/src/model/channel/reaction.rs
index 88fd24c..be5dfb8 100644
--- a/src/model/channel/reaction.rs
+++ b/src/model/channel/reaction.rs
@@ -46,32 +46,31 @@ impl Reaction {
     /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
     /// [permissions]: permissions
     pub fn delete(&self) -> Result<()> {
-        let user_id =
-            feature_cache! {{
-            let user = if self.user_id == CACHE.read().unwrap().user.id {
-                None
-            } else {
-                Some(self.user_id.0)
-            };
-
-            // If the reaction is one _not_ made by the current user, then ensure
-            // that the current user has permission* to delete the reaction.
-            //
-            // Normally, users can only delete their own reactions.
-            //
-            // * The `Manage Messages` permission.
-            if user.is_some() {
-                let req = permissions::MANAGE_MESSAGES;
-
-                if !utils::user_has_perms(self.channel_id, req).unwrap_or(true) {
-                    return Err(Error::Model(ModelError::InvalidPermissions(req)));
-                }
-            }
-
-            user
-        } else {
-            Some(self.user_id.0)
-        }};
+        let user_id = feature_cache! {{
+                                            let user = if self.user_id == CACHE.read().unwrap().user.id {
+                                                None
+                                            } else {
+                                                Some(self.user_id.0)
+                                            };
+        
+                                            // If the reaction is one _not_ made by the current user, then ensure
+                                            // that the current user has permission* to delete the reaction.
+                                            //
+                                            // Normally, users can only delete their own reactions.
+                                            //
+                                            // * The `Manage Messages` permission.
+                                            if user.is_some() {
+                                                let req = permissions::MANAGE_MESSAGES;
+        
+                                                if !utils::user_has_perms(self.channel_id, req).unwrap_or(true) {
+                                                    return Err(Error::Model(ModelError::InvalidPermissions(req)));
+                                                }
+                                            }
+        
+                                            user
+                                        } else {
+                                            Some(self.user_id.0)
+                                        }};
 
         http::delete_reaction(self.channel_id.0, self.message_id.0, user_id, &self.emoji)
     }
diff --git a/src/model/event.rs b/src/model/event.rs
index 22cf649..7881864 100644
--- a/src/model/event.rs
+++ b/src/model/event.rs
@@ -126,8 +126,7 @@ impl<'de> Deserialize<'de> for GuildDeleteEvent {
 
 #[derive(Clone, Debug, Deserialize)]
 pub struct GuildEmojisUpdateEvent {
-    #[serde(deserialize_with = "deserialize_emojis")]
-    pub emojis: HashMap<EmojiId, Emoji>,
+    #[serde(deserialize_with = "deserialize_emojis")] pub emojis: HashMap<EmojiId, Emoji>,
     pub guild_id: GuildId,
 }
 
@@ -153,9 +152,8 @@ impl<'de> Deserialize<'de> for GuildMemberAddEvent {
 
         Ok(GuildMemberAddEvent {
             guild_id: guild_id,
-            member: Member::deserialize(Value::Object(map)).map_err(
-                DeError::custom,
-            )?,
+            member: Member::deserialize(Value::Object(map))
+                .map_err(DeError::custom)?,
         })
     }
 }
@@ -189,9 +187,8 @@ impl<'de> Deserialize<'de> for GuildMembersChunkEvent {
             .and_then(|v| GuildId::deserialize(v.clone()))
             .map_err(DeError::custom)?;
 
-        let mut members = map.remove("members").ok_or_else(|| {
-            DeError::custom("missing member chunk members")
-        })?;
+        let mut members = map.remove("members")
+            .ok_or_else(|| DeError::custom("missing member chunk members"))?;
 
         if let Some(members) = members.as_array_mut() {
             let num = Value::Number(Number::from(guild_id.0));
@@ -233,8 +230,7 @@ pub struct GuildRoleUpdateEvent {
 
 #[derive(Clone, Debug, Deserialize)]
 pub struct GuildUnavailableEvent {
-    #[serde(rename = "id")]
-    pub guild_id: GuildId,
+    #[serde(rename = "id")] pub guild_id: GuildId,
 }
 
 #[derive(Clone, Debug)]
@@ -272,8 +268,7 @@ pub struct MessageDeleteBulkEvent {
 #[derive(Clone, Copy, Debug, Deserialize)]
 pub struct MessageDeleteEvent {
     pub channel_id: ChannelId,
-    #[serde(rename = "id")]
-    pub message_id: MessageId,
+    #[serde(rename = "id")] pub message_id: MessageId,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -307,24 +302,17 @@ impl<'de> Deserialize<'de> for PresenceUpdateEvent {
         let mut map = JsonMap::deserialize(deserializer)?;
 
         let guild_id = match map.remove("guild_id") {
-            Some(v) => {
-                serde_json::from_value::<Option<GuildId>>(v).map_err(
-                    DeError::custom,
-                )?
-            },
+            Some(v) => serde_json::from_value::<Option<GuildId>>(v)
+                .map_err(DeError::custom)?,
             None => None,
         };
         let roles = match map.remove("roles") {
-            Some(v) => {
-                serde_json::from_value::<Option<Vec<RoleId>>>(v).map_err(
-                    DeError::custom,
-                )?
-            },
+            Some(v) => serde_json::from_value::<Option<Vec<RoleId>>>(v)
+                .map_err(DeError::custom)?,
             None => None,
         };
-        let presence = Presence::deserialize(Value::Object(map)).map_err(
-            DeError::custom,
-        )?;
+        let presence = Presence::deserialize(Value::Object(map))
+            .map_err(DeError::custom)?;
 
         Ok(Self {
             guild_id: guild_id,
@@ -397,8 +385,7 @@ impl<'de> Deserialize<'de> for ReadyEvent {
 
 #[derive(Clone, Debug, Deserialize)]
 pub struct ResumedEvent {
-    #[serde(rename = "_trace")]
-    pub trace: Vec<Option<String>>,
+    #[serde(rename = "_trace")] pub trace: Vec<Option<String>>,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -451,9 +438,8 @@ impl<'de> Deserialize<'de> for VoiceStateUpdateEvent {
 
         Ok(VoiceStateUpdateEvent {
             guild_id: guild_id,
-            voice_state: VoiceState::deserialize(Value::Object(map)).map_err(
-                DeError::custom,
-            )?,
+            voice_state: VoiceState::deserialize(Value::Object(map))
+                .map_err(DeError::custom)?,
         })
     }
 }
@@ -801,20 +787,16 @@ impl VoiceEvent {
         let mut map = JsonMap::deserialize(value)?;
 
         let op = match map.remove("op") {
-            Some(v) => {
-                VoiceOpCode::deserialize(v)
-                    .map_err(JsonError::from)
-                    .map_err(Error::from)?
-            },
+            Some(v) => VoiceOpCode::deserialize(v)
+                .map_err(JsonError::from)
+                .map_err(Error::from)?,
             None => return Err(Error::Decode("expected voice event op", Value::Object(map))),
         };
 
         let d = match map.remove("d") {
-            Some(v) => {
-                JsonMap::deserialize(v).map_err(JsonError::from).map_err(
-                    Error::from,
-                )?
-            },
+            Some(v) => JsonMap::deserialize(v)
+                .map_err(JsonError::from)
+                .map_err(Error::from)?,
             None => {
                 return Err(Error::Decode(
                     "expected voice gateway d",
diff --git a/src/model/gateway.rs b/src/model/gateway.rs
index 1b3a40b..4edf0b8 100644
--- a/src/model/gateway.rs
+++ b/src/model/gateway.rs
@@ -106,9 +106,8 @@ impl<'de> Deserialize<'de> for Game {
         let name = map.remove("name")
             .and_then(|v| String::deserialize(v).ok())
             .unwrap_or_else(String::new);
-        let url = map.remove("url").and_then(|v| {
-            serde_json::from_value::<String>(v).ok()
-        });
+        let url = map.remove("url")
+            .and_then(|v| serde_json::from_value::<String>(v).ok());
 
         Ok(Game {
             kind: kind,
@@ -174,9 +173,8 @@ impl<'de> Deserialize<'de> for Presence {
             .map_err(DeError::custom)?;
 
         let (user_id, user) = if user_map.len() > 1 {
-            let user = User::deserialize(Value::Object(user_map)).map_err(
-                DeError::custom,
-            )?;
+            let user = User::deserialize(Value::Object(user_map))
+                .map_err(DeError::custom)?;
 
             (user.id, Some(Arc::new(RwLock::new(user))))
         } else {
@@ -190,11 +188,8 @@ impl<'de> Deserialize<'de> for Presence {
         };
 
         let game = match map.remove("game") {
-            Some(v) => {
-                serde_json::from_value::<Option<Game>>(v).map_err(
-                    DeError::custom,
-                )?
-            },
+            Some(v) => serde_json::from_value::<Option<Game>>(v)
+                .map_err(DeError::custom)?,
             None => None,
         };
         let last_modified = match map.remove("last_modified") {
@@ -202,11 +197,8 @@ impl<'de> Deserialize<'de> for Presence {
             None => None,
         };
         let nick = match map.remove("nick") {
-            Some(v) => {
-                serde_json::from_value::<Option<String>>(v).map_err(
-                    DeError::custom,
-                )?
-            },
+            Some(v) => serde_json::from_value::<Option<String>>(v)
+                .map_err(DeError::custom)?,
             None => None,
         };
         let status = map.remove("status")
@@ -229,15 +221,13 @@ impl<'de> Deserialize<'de> for Presence {
 #[derive(Clone, Debug, Deserialize)]
 pub struct Ready {
     pub guilds: Vec<GuildStatus>,
-    #[serde(deserialize_with = "deserialize_presences")]
-    pub presences: HashMap<UserId, Presence>,
+    #[serde(deserialize_with = "deserialize_presences")] pub presences: HashMap<UserId, Presence>,
     #[serde(deserialize_with = "deserialize_private_channels")]
-    pub private_channels: HashMap<ChannelId, Channel>,
+    pub private_channels:
+        HashMap<ChannelId, Channel>,
     pub session_id: String,
     pub shard: Option<[u64; 2]>,
-    #[serde(default, rename = "_trace")]
-    pub trace: Vec<String>,
+    #[serde(default, rename = "_trace")] pub trace: Vec<String>,
     pub user: CurrentUser,
-    #[serde(rename = "v")]
-    pub version: u64,
+    #[serde(rename = "v")] pub version: u64,
 }
diff --git a/src/model/guild/audit_log.rs b/src/model/guild/audit_log.rs
index 962b145..6c24662 100644
--- a/src/model/guild/audit_log.rs
+++ b/src/model/guild/audit_log.rs
@@ -91,12 +91,9 @@ pub enum ActionEmoji {
 
 #[derive(Debug, Deserialize)]
 pub struct Change {
-    #[serde(rename = "key")]
-    pub name: String,
-    #[serde(rename = "old_value")]
-    pub old: String,
-    #[serde(rename = "new_value")]
-    pub new: String,
+    #[serde(rename = "key")] pub name: String,
+    #[serde(rename = "old_value")] pub old: String,
+    #[serde(rename = "new_value")] pub new: String,
 }
 
 #[derive(Debug)]
@@ -126,7 +123,7 @@ pub struct AuditLogEntry {
     pub id: AuditLogEntryId,
 }
 
-fn deserialize_target<'de, D: Deserializer<'de>>(de: D) -> Result<Target, D::Error> {
+fn deserialize_target<'de, D: Deserializer<'de>>(de: D) -> Result<Target, D::Error>{
     struct TargetVisitor;
 
     impl<'de> Visitor<'de> for TargetVisitor {
@@ -147,7 +144,7 @@ fn deserialize_target<'de, D: Deserializer<'de>>(de: D) -> Result<Target, D::Err
     de.deserialize_i32(TargetVisitor)
 }
 
-fn deserialize_action<'de, D: Deserializer<'de>>(de: D) -> Result<Action, D::Error> {
+fn deserialize_action<'de, D: Deserializer<'de>>(de: D) -> Result<Action, D::Error>{
     struct ActionVisitor;
 
     impl<'de> Visitor<'de> for ActionVisitor {
@@ -180,8 +177,7 @@ impl<'de> Deserialize<'de> for AuditLogs {
         #[derive(Deserialize)]
         #[serde(field_identifier)]
         enum Field {
-            #[serde(rename = "audit_log_entries")]
-            Entries,
+            #[serde(rename = "audit_log_entries")] Entries,
         }
 
         struct EntriesVisitor;
diff --git a/src/model/guild/guild_id.rs b/src/model/guild/guild_id.rs
index 4d6ba9b..02775ba 100644
--- a/src/model/guild/guild_id.rs
+++ b/src/model/guild/guild_id.rs
@@ -48,7 +48,7 @@ impl GuildId {
     /// [`Guild::ban`]: struct.Guild.html#method.ban
     /// [`User`]: struct.User.html
     /// [Ban Members]: permissions/constant.BAN_MEMBERS.html
-    pub fn ban<U: Into<UserId>, BO: BanOptions>(&self, user: U, ban_options: BO) -> Result<()> {
+pub fn ban<U: Into<UserId>, BO: BanOptions>(&self, user: U, ban_options: BO) -> Result<()>{
         let dmd = ban_options.dmd();
         if dmd > 7 {
             return Err(Error::Model(ModelError::DeleteMessageDaysAmount(dmd)));
@@ -167,7 +167,7 @@ impl GuildId {
     /// [`Guild::create_role`]: struct.Guild.html#method.create_role
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[inline]
-    pub fn create_role<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role> {
+pub fn create_role<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role>{
         http::create_role(self.0, &f(EditRole::default()).0)
     }
 
@@ -199,7 +199,7 @@ impl GuildId {
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-    pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()> {
+pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()>{
         http::delete_guild_integration(self.0, integration_id.into().0)
     }
 
@@ -228,7 +228,7 @@ impl GuildId {
     /// [`Guild::edit`]: struct.Guild.html#method.edit
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-    pub fn edit<F: FnOnce(EditGuild) -> EditGuild>(&mut self, f: F) -> Result<PartialGuild> {
+pub fn edit<F: FnOnce(EditGuild) -> EditGuild>(&mut self, f: F) -> Result<PartialGuild>{
         http::edit_guild(self.0, &f(EditGuild::default()).0)
     }
 
@@ -459,7 +459,7 @@ impl GuildId {
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-    pub fn start_integration_sync<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()> {
+pub fn start_integration_sync<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()>{
         http::start_integration_sync(self.0, integration_id.into().0)
     }
 
diff --git a/src/model/guild/integration.rs b/src/model/guild/integration.rs
index 18da39d..b903a2c 100644
--- a/src/model/guild/integration.rs
+++ b/src/model/guild/integration.rs
@@ -6,8 +6,7 @@ pub struct Integration {
     pub id: IntegrationId,
     pub account: IntegrationAccount,
     pub enabled: bool,
-    #[serde(rename = "expire_behaviour")]
-    pub expire_behaviour: u64,
+    #[serde(rename = "expire_behaviour")] pub expire_behaviour: u64,
     pub expire_grace_period: u64,
     pub kind: String,
     pub name: String,
diff --git a/src/model/guild/member.rs b/src/model/guild/member.rs
index f1a5114..370f555 100644
--- a/src/model/guild/member.rs
+++ b/src/model/guild/member.rs
@@ -168,9 +168,10 @@ impl Member {
 
         let default = Colour::default();
 
-        roles.iter().find(|r| r.colour.0 != default.0).map(
-            |r| r.colour,
-        )
+        roles
+            .iter()
+            .find(|r| r.colour.0 != default.0)
+            .map(|r| r.colour)
     }
 
     /// Calculates the member's display name.
@@ -178,9 +179,10 @@ impl Member {
     /// The nickname takes priority over the member's username if it exists.
     #[inline]
     pub fn display_name(&self) -> Cow<String> {
-        self.nick.as_ref().map(Cow::Borrowed).unwrap_or_else(|| {
-            Cow::Owned(self.user.read().unwrap().name.clone())
-        })
+        self.nick
+            .as_ref()
+            .map(Cow::Borrowed)
+            .unwrap_or_else(|| Cow::Owned(self.user.read().unwrap().name.clone()))
     }
 
     /// Returns the DiscordTag of a Member, taking possible nickname into account.
@@ -202,7 +204,7 @@ impl Member {
     /// [`Guild::edit_member`]: ../model/struct.Guild.html#method.edit_member
     /// [`EditMember`]: ../builder/struct.EditMember.html
     #[cfg(feature = "cache")]
-    pub fn edit<F: FnOnce(EditMember) -> EditMember>(&self, f: F) -> Result<()> {
+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)
@@ -246,11 +248,12 @@ impl Member {
         {
             let req = permissions::KICK_MEMBERS;
 
-            let has_perms = CACHE.read().unwrap().guilds.get(&self.guild_id).map(
-                |guild| {
-                    guild.read().unwrap().has_perms(req)
-                },
-            );
+            let has_perms = CACHE
+                .read()
+                .unwrap()
+                .guilds
+                .get(&self.guild_id)
+                .map(|guild| guild.read().unwrap().has_perms(req));
 
             if let Some(Ok(false)) = has_perms {
                 return Err(Error::Model(ModelError::InvalidPermissions(req)));
@@ -285,10 +288,10 @@ impl Member {
 
         let guild = guild.read().unwrap();
 
-        Ok(guild.permissions_for(
-            ChannelId(guild.id.0),
-            self.user.read().unwrap().id,
-        ))
+        Ok(
+            guild
+                .permissions_for(ChannelId(guild.id.0), self.user.read().unwrap().id),
+        )
     }
 
     /// Removes a [`Role`] from the member, editing its roles in-place if the
diff --git a/src/model/guild/mod.rs b/src/model/guild/mod.rs
index 3fc2a86..7fdd7d4 100644
--- a/src/model/guild/mod.rs
+++ b/src/model/guild/mod.rs
@@ -168,10 +168,7 @@ impl Guild {
             None => return Err(Error::Model(ModelError::ItemMissing)),
         };
 
-        let perms = self.permissions_for(
-            default_channel.id,
-            member.user.read().unwrap().id,
-        );
+        let perms = self.permissions_for(default_channel.id, member.user.read().unwrap().id);
         permissions.remove(perms);
 
         Ok(permissions.is_empty())
@@ -445,7 +442,7 @@ impl Guild {
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-    pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()> {
+pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()>{
         self.id.delete_integration(integration_id)
     }
 
@@ -629,9 +626,9 @@ impl Guild {
 
     /// Returns the formatted URL of the guild's icon, if one exists.
     pub fn icon_url(&self) -> Option<String> {
-        self.icon.as_ref().map(
-            |icon| format!(cdn!("/icons/{}/{}.webp"), self.id, icon),
-        )
+        self.icon
+            .as_ref()
+            .map(|icon| format!(cdn!("/icons/{}/{}.webp"), self.id, icon))
     }
 
     /// Gets all integration of the guild.
@@ -709,10 +706,8 @@ impl Guild {
 
         for (&id, member) in &self.members {
             match self.presences.get(&id) {
-                Some(presence) => {
-                    if status == presence.status {
-                        members.push(member);
-                    }
+                Some(presence) => if status == presence.status {
+                    members.push(member);
                 },
                 None => continue,
             }
@@ -800,8 +795,8 @@ impl Guild {
             Some(everyone) => everyone,
             None => {
                 error!("(╯°□°）╯︵ ┻━┻ @everyone role ({}) missing in '{}'",
-                       self.id,
-                       self.name);
+                self.id,
+                self.name);
 
                 return Permissions::empty();
             },
@@ -820,9 +815,9 @@ impl Guild {
                 permissions |= role.permissions;
             } else {
                 warn!("(╯°□°）╯︵ ┻━┻ {} on {} has non-existent role {:?}",
-                      member.user.read().unwrap().id,
-                      self.id,
-                      role);
+                member.user.read().unwrap().id,
+                self.id,
+                role);
             }
         }
 
@@ -836,8 +831,8 @@ impl Guild {
 
             // If this is a text channel, then throw out voice permissions.
             if channel.kind == ChannelType::Text {
-                permissions &= !(CONNECT | SPEAK | MUTE_MEMBERS | DEAFEN_MEMBERS | MOVE_MEMBERS |
-                                 USE_VAD);
+                permissions &=
+                    !(CONNECT | SPEAK | MUTE_MEMBERS | DEAFEN_MEMBERS | MOVE_MEMBERS | USE_VAD);
             }
 
             // Apply the permission overwrites for the channel for each of the
@@ -868,8 +863,8 @@ impl Guild {
             }
         } else {
             warn!("(╯°□°）╯︵ ┻━┻ Guild {} does not contain channel {}",
-                  self.id,
-                  channel_id);
+            self.id,
+            channel_id);
         }
 
         // The default channel is always readable.
@@ -963,9 +958,9 @@ impl Guild {
 
     /// Returns the formatted URL of the guild's splash image, if one exists.
     pub fn splash_url(&self) -> Option<String> {
-        self.icon.as_ref().map(
-            |icon| format!(cdn!("/splashes/{}/{}.webp"), self.id, icon),
-        )
+        self.icon
+            .as_ref()
+            .map(|icon| format!(cdn!("/splashes/{}/{}.webp"), self.id, icon))
     }
 
     /// Starts an integration sync for the given integration Id.
@@ -974,7 +969,7 @@ impl Guild {
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-    pub fn start_integration_sync<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()> {
+pub fn start_integration_sync<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()>{
         self.id.start_integration_sync(integration_id)
     }
 
@@ -1044,18 +1039,16 @@ impl<'de> Deserialize<'de> for Guild {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
 
-        let id = map.get("id").and_then(|x| x.as_str()).and_then(|x| {
-            x.parse::<u64>().ok()
-        });
+        let id = map.get("id")
+            .and_then(|x| x.as_str())
+            .and_then(|x| x.parse::<u64>().ok());
 
         if let Some(guild_id) = id {
             if let Some(array) = map.get_mut("channels").and_then(|x| x.as_array_mut()) {
                 for value in array {
                     if let Some(channel) = value.as_object_mut() {
-                        channel.insert(
-                            "guild_id".to_owned(),
-                            Value::Number(Number::from(guild_id)),
-                        );
+                        channel
+                            .insert("guild_id".to_owned(), Value::Number(Number::from(guild_id)));
                     }
                 }
             }
@@ -1063,21 +1056,16 @@ impl<'de> Deserialize<'de> for Guild {
             if let Some(array) = map.get_mut("members").and_then(|x| x.as_array_mut()) {
                 for value in array {
                     if let Some(member) = value.as_object_mut() {
-                        member.insert(
-                            "guild_id".to_owned(),
-                            Value::Number(Number::from(guild_id)),
-                        );
+                        member
+                            .insert("guild_id".to_owned(), Value::Number(Number::from(guild_id)));
                     }
                 }
             }
         }
 
         let afk_channel_id = match map.remove("afk_channel_id") {
-            Some(v) => {
-                serde_json::from_value::<Option<ChannelId>>(v).map_err(
-                    DeError::custom,
-                )?
-            },
+            Some(v) => serde_json::from_value::<Option<ChannelId>>(v)
+                .map_err(DeError::custom)?,
             None => None,
         };
         let afk_timeout = map.remove("afk_timeout")
@@ -1229,9 +1217,9 @@ pub struct GuildInfo {
 impl GuildInfo {
     /// Returns the formatted URL of the guild's icon, if the guild has an icon.
     pub fn icon_url(&self) -> Option<String> {
-        self.icon.as_ref().map(
-            |icon| format!(cdn!("/icons/{}/{}.webp"), self.id, icon),
-        )
+        self.icon
+            .as_ref()
+            .map(|icon| format!(cdn!("/icons/{}/{}.webp"), self.id, icon))
     }
 }
 
@@ -1251,9 +1239,9 @@ impl From<u64> for GuildContainer {
 impl InviteGuild {
     /// Returns the formatted URL of the guild's splash image, if one exists.
     pub fn splash_url(&self) -> Option<String> {
-        self.icon.as_ref().map(
-            |icon| format!(cdn!("/splashes/{}/{}.webp"), self.id, icon),
-        )
+        self.icon
+            .as_ref()
+            .map(|icon| format!(cdn!("/splashes/{}/{}.webp"), self.id, icon))
     }
 }
 
diff --git a/src/model/guild/partial_guild.rs b/src/model/guild/partial_guild.rs
index 799f6b6..1690167 100644
--- a/src/model/guild/partial_guild.rs
+++ b/src/model/guild/partial_guild.rs
@@ -16,16 +16,14 @@ pub struct PartialGuild {
     pub default_message_notifications: u64,
     pub embed_channel_id: Option<ChannelId>,
     pub embed_enabled: bool,
-    #[serde(deserialize_with = "deserialize_emojis")]
-    pub emojis: HashMap<EmojiId, Emoji>,
+    #[serde(deserialize_with = "deserialize_emojis")] pub emojis: HashMap<EmojiId, Emoji>,
     pub features: Vec<Feature>,
     pub icon: Option<String>,
     pub mfa_level: u64,
     pub name: String,
     pub owner_id: UserId,
     pub region: String,
-    #[serde(deserialize_with = "deserialize_roles")]
-    pub roles: HashMap<RoleId, Role>,
+    #[serde(deserialize_with = "deserialize_roles")] pub roles: HashMap<RoleId, Role>,
     pub splash: Option<String>,
     pub verification_level: VerificationLevel,
 }
@@ -152,7 +150,7 @@ impl PartialGuild {
     /// [`Guild::create_role`]: struct.Guild.html#method.create_role
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[inline]
-    pub fn create_role<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role> {
+pub fn create_role<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role>{
         self.id.create_role(f)
     }
 
@@ -180,7 +178,7 @@ impl PartialGuild {
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-    pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()> {
+pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()>{
         self.id.delete_integration(integration_id)
     }
 
@@ -317,9 +315,9 @@ impl PartialGuild {
 
     /// Returns a formatted URL of the guild's icon, if the guild has an icon.
     pub fn icon_url(&self) -> Option<String> {
-        self.icon.as_ref().map(|icon| {
-            format!(cdn!("/icons/{}/{}.webp"), self.id, icon)
-        })
+        self.icon
+            .as_ref()
+            .map(|icon| format!(cdn!("/icons/{}/{}.webp"), self.id, icon))
     }
 
     /// Gets all integration of the guild.
@@ -419,9 +417,9 @@ impl PartialGuild {
 
     /// Returns the formatted URL of the guild's splash image, if one exists.
     pub fn splash_url(&self) -> Option<String> {
-        self.icon.as_ref().map(|icon| {
-            format!(cdn!("/splashes/{}/{}.webp"), self.id, icon)
-        })
+        self.icon
+            .as_ref()
+            .map(|icon| format!(cdn!("/splashes/{}/{}.webp"), self.id, icon))
     }
 
     /// Starts an integration sync for the given integration Id.
@@ -430,7 +428,7 @@ impl PartialGuild {
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-    pub fn start_integration_sync<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()> {
+pub fn start_integration_sync<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()>{
         self.id.start_integration_sync(integration_id)
     }
 
diff --git a/src/model/guild/role.rs b/src/model/guild/role.rs
index 5956113..5a6f75c 100644
--- a/src/model/guild/role.rs
+++ b/src/model/guild/role.rs
@@ -92,10 +92,9 @@ impl Role {
     /// [`Role`]: struct.Role.html
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[cfg(all(feature = "builder", feature = "cache"))]
-    pub fn edit<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role> {
-        self.find_guild().and_then(
-            |guild_id| guild_id.edit_role(self.id, f),
-        )
+pub fn edit<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role>{
+        self.find_guild()
+            .and_then(|guild_id| guild_id.edit_role(self.id, f))
     }
 
     /// Searches the cache for the guild that owns the role.
diff --git a/src/model/invite.rs b/src/model/invite.rs
index f48ecbc..c066128 100644
--- a/src/model/invite.rs
+++ b/src/model/invite.rs
@@ -152,8 +152,7 @@ impl Invite {
 pub struct InviteChannel {
     pub id: ChannelId,
     pub name: String,
-    #[serde(rename = "type")]
-    pub kind: ChannelType,
+    #[serde(rename = "type")] pub kind: ChannelType,
 }
 
 /// A minimal amount of information about the guild an invite points to.
diff --git a/src/model/misc.rs b/src/model/misc.rs
index 0d1f146..3310e4a 100644
--- a/src/model/misc.rs
+++ b/src/model/misc.rs
@@ -1,4 +1,5 @@
 use super::*;
+use internal::RwLockExt;
 
 #[cfg(all(feature = "model", feature = "utils"))]
 use std::result::Result as StdResult;
@@ -27,9 +28,9 @@ impl Mentionable for ChannelId {
 impl Mentionable for Channel {
     fn mention(&self) -> String {
         match *self {
-            Channel::Guild(ref x) => format!("<#{}>", x.read().unwrap().id.0),
-            Channel::Private(ref x) => format!("<#{}>", x.read().unwrap().id.0),
-            Channel::Group(ref x) => format!("<#{}>", x.read().unwrap().channel_id.0),
+            Channel::Guild(ref x) => format!("<#{}>", x.with(|x| x.id.0)),
+            Channel::Private(ref x) => format!("<#{}>", x.with(|x| x.id.0)),
+            Channel::Group(ref x) => format!("<#{}>", x.with(|x| x.channel_id.0)),
         }
     }
 }
@@ -39,7 +40,7 @@ impl Mentionable for Emoji {
 }
 
 impl Mentionable for Member {
-    fn mention(&self) -> String { format!("<@{}>", self.user.read().unwrap().id.0) }
+    fn mention(&self) -> String { format!("<@{}>", self.user.with(|u| u.id.0)) }
 }
 
 impl Mentionable for RoleId {
@@ -89,11 +90,9 @@ impl FromStr for User {
 
     fn from_str(s: &str) -> StdResult<Self, Self::Err> {
         match utils::parse_username(s) {
-            Some(x) => {
-                UserId(x as u64).get().map_err(
-                    |e| UserParseError::Rest(Box::new(e)),
-                )
-            },
+            Some(x) => UserId(x as u64)
+                .get()
+                .map_err(|e| UserParseError::Rest(Box::new(e))),
             _ => Err(UserParseError::InvalidUsername),
         }
     }
@@ -162,11 +161,9 @@ impl FromStr for Role {
 
     fn from_str(s: &str) -> StdResult<Self, Self::Err> {
         match utils::parse_role(s) {
-            Some(x) => {
-                match RoleId(x).find() {
-                    Some(user) => Ok(user),
-                    _ => Err(RoleParseError::NotPresentInCache),
-                }
+            Some(x) => match RoleId(x).find() {
+                Some(user) => Ok(user),
+                _ => Err(RoleParseError::NotPresentInCache),
             },
             _ => Err(RoleParseError::InvalidRole),
         }
@@ -245,11 +242,9 @@ impl FromStr for Channel {
 
     fn from_str(s: &str) -> StdResult<Self, ()> {
         match utils::parse_channel(s) {
-            Some(x) => {
-                match ChannelId(x).find() {
-                    Some(channel) => Ok(channel),
-                    _ => Err(()),
-                }
+            Some(x) => match ChannelId(x).find() {
+                Some(channel) => Ok(channel),
+                _ => Err(()),
             },
             _ => Err(()),
         }
diff --git a/src/model/mod.rs b/src/model/mod.rs
index d512ffb..cc8860f 100644
--- a/src/model/mod.rs
+++ b/src/model/mod.rs
@@ -198,41 +198,26 @@ pub struct CurrentApplicationInfo {
     pub id: UserId,
     pub name: String,
     pub owner: User,
-    #[serde(default)]
-    pub rpc_origins: Vec<String>,
+    #[serde(default)] pub rpc_origins: Vec<String>,
 }
 
 /// The name of a region that a voice server can be located in.
 #[derive(Copy, Clone, Debug, Deserialize, Eq, Hash, PartialEq, PartialOrd, Ord, Serialize)]
 pub enum Region {
-    #[serde(rename = "amsterdam")]
-    Amsterdam,
-    #[serde(rename = "brazil")]
-    Brazil,
-    #[serde(rename = "eu-central")]
-    EuCentral,
-    #[serde(rename = "eu-west")]
-    EuWest,
-    #[serde(rename = "frankfurt")]
-    Frankfurt,
-    #[serde(rename = "london")]
-    London,
-    #[serde(rename = "sydney")]
-    Sydney,
-    #[serde(rename = "us-central")]
-    UsCentral,
-    #[serde(rename = "us-east")]
-    UsEast,
-    #[serde(rename = "us-south")]
-    UsSouth,
-    #[serde(rename = "us-west")]
-    UsWest,
-    #[serde(rename = "vip-amsterdam")]
-    VipAmsterdam,
-    #[serde(rename = "vip-us-east")]
-    VipUsEast,
-    #[serde(rename = "vip-us-west")]
-    VipUsWest,
+    #[serde(rename = "amsterdam")] Amsterdam,
+    #[serde(rename = "brazil")] Brazil,
+    #[serde(rename = "eu-central")] EuCentral,
+    #[serde(rename = "eu-west")] EuWest,
+    #[serde(rename = "frankfurt")] Frankfurt,
+    #[serde(rename = "london")] London,
+    #[serde(rename = "sydney")] Sydney,
+    #[serde(rename = "us-central")] UsCentral,
+    #[serde(rename = "us-east")] UsEast,
+    #[serde(rename = "us-south")] UsSouth,
+    #[serde(rename = "us-west")] UsWest,
+    #[serde(rename = "vip-amsterdam")] VipAmsterdam,
+    #[serde(rename = "vip-us-east")] VipUsEast,
+    #[serde(rename = "vip-us-west")] VipUsWest,
 }
 
 impl Region {
@@ -260,6 +245,6 @@ use serde::{Deserialize, Deserializer};
 use std::result::Result as StdResult;
 
 fn deserialize_sync_user<'de, D: Deserializer<'de>>(deserializer: D)
-                                                    -> StdResult<Arc<RwLock<User>>, D::Error> {
+-> StdResult<Arc<RwLock<User>>, D::Error>{
     Ok(Arc::new(RwLock::new(User::deserialize(deserializer)?)))
 }
diff --git a/src/model/user.rs b/src/model/user.rs
index c32eeb8..c3b131b 100644
--- a/src/model/user.rs
+++ b/src/model/user.rs
@@ -25,14 +25,11 @@ use http::{self, GuildPagination};
 pub struct CurrentUser {
     pub id: UserId,
     pub avatar: Option<String>,
-    #[serde(default)]
-    pub bot: bool,
-    #[serde(deserialize_with = "deserialize_u16")]
-    pub discriminator: u16,
+    #[serde(default)] pub bot: bool,
+    #[serde(deserialize_with = "deserialize_u16")] pub discriminator: u16,
     pub email: Option<String>,
     pub mfa_enabled: bool,
-    #[serde(rename = "username")]
-    pub name: String,
+    #[serde(rename = "username")] pub name: String,
     pub verified: bool,
 }
 
@@ -88,10 +85,7 @@ impl CurrentUser {
     pub fn edit<F>(&mut self, f: F) -> Result<()>
         where F: FnOnce(EditProfile) -> EditProfile {
         let mut map = Map::new();
-        map.insert(
-            "username".to_owned(),
-            Value::String(self.name.clone()),
-        );
+        map.insert("username".to_owned(), Value::String(self.name.clone()));
 
         if let Some(email) = self.email.as_ref() {
             map.insert("email".to_owned(), Value::String(email.clone()));
@@ -116,9 +110,8 @@ impl CurrentUser {
     /// [`avatar_url`]: #method.avatar_url
     /// [`default_avatar_url`]: #method.default_avatar_url
     pub fn face(&self) -> String {
-        self.avatar_url().unwrap_or_else(
-            || self.default_avatar_url(),
-        )
+        self.avatar_url()
+            .unwrap_or_else(|| self.default_avatar_url())
     }
 
     /// Gets a list of guilds that the current user is in.
@@ -329,16 +322,11 @@ enum_number!(
 /// [`Invisible`]: #variant.Invisible
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, PartialOrd, Ord, Serialize)]
 pub enum OnlineStatus {
-    #[serde(rename = "dnd")]
-    DoNotDisturb,
-    #[serde(rename = "idle")]
-    Idle,
-    #[serde(rename = "invisible")]
-    Invisible,
-    #[serde(rename = "offline")]
-    Offline,
-    #[serde(rename = "online")]
-    Online,
+    #[serde(rename = "dnd")] DoNotDisturb,
+    #[serde(rename = "idle")] Idle,
+    #[serde(rename = "invisible")] Invisible,
+    #[serde(rename = "offline")] Offline,
+    #[serde(rename = "online")] Online,
 }
 
 impl OnlineStatus {
@@ -492,36 +480,35 @@ impl User {
             return Err(Error::Model(ModelError::MessagingBot));
         }
 
-        let private_channel_id =
-            feature_cache! {{
-            let finding = {
-                let cache = CACHE.read().unwrap();
-
-                let finding = cache.private_channels
-                    .values()
-                    .map(|ch| ch.read().unwrap())
-                    .find(|ch| ch.recipient.read().unwrap().id == self.id)
-                    .map(|ch| ch.id);
-
-                finding
-            };
-
-            if let Some(finding) = finding {
-                finding
-            } else {
-                let map = json!({
-                    "recipient_id": self.id.0,
-                });
-
-                http::create_private_channel(&map)?.id
-            }
-        } else {
-            let map = json!({
-                "recipient_id": self.id.0,
-            });
-
-            http::create_private_channel(&map)?.id
-        }};
+        let private_channel_id = feature_cache! {{
+                                            let finding = {
+                                                let cache = CACHE.read().unwrap();
+        
+                                                let finding = cache.private_channels
+                                                    .values()
+                                                    .map(|ch| ch.read().unwrap())
+                                                    .find(|ch| ch.recipient.read().unwrap().id == self.id)
+                                                    .map(|ch| ch.id);
+        
+                                                finding
+                                            };
+        
+                                            if let Some(finding) = finding {
+                                                finding
+                                            } else {
+                                                let map = json!({
+                                                    "recipient_id": self.id.0,
+                                                });
+        
+                                                http::create_private_channel(&map)?.id
+                                            }
+                                        } else {
+                                            let map = json!({
+                                                "recipient_id": self.id.0,
+                                            });
+        
+                                            http::create_private_channel(&map)?.id
+                                        }};
 
         private_channel_id.send_message(f)
     }
@@ -547,7 +534,7 @@ impl User {
     /// [direct_message]: #method.direct_message
     #[cfg(feature = "builder")]
     #[inline]
-    pub fn dm<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message> {
+pub fn dm<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message>{
         self.direct_message(f)
     }
 
@@ -560,9 +547,8 @@ impl User {
     /// [`avatar_url`]: #method.avatar_url
     /// [`default_avatar_url`]: #method.default_avatar_url
     pub fn face(&self) -> String {
-        self.avatar_url().unwrap_or_else(
-            || self.default_avatar_url(),
-        )
+        self.avatar_url()
+            .unwrap_or_else(|| self.default_avatar_url())
     }
 
     /// Check if a user has a [`Role`]. This will retrieve the [`Guild`] from
@@ -808,9 +794,7 @@ fn default_avatar_url(discriminator: u16) -> String {
 
 #[cfg(feature = "model")]
 fn static_avatar_url(user_id: UserId, hash: Option<&String>) -> Option<String> {
-    hash.map(
-        |hash| cdn!("/avatars/{}/{}.webp?size=1024", user_id, hash),
-    )
+    hash.map(|hash| cdn!("/avatars/{}/{}.webp?size=1024", user_id, hash))
 }
 
 #[cfg(feature = "model")]
diff --git a/src/model/utils.rs b/src/model/utils.rs
index 9fed660..b85b58f 100644
--- a/src/model/utils.rs
+++ b/src/model/utils.rs
@@ -123,11 +123,11 @@ pub fn deserialize_users<'de, D: Deserializer<'de>>(
     Ok(users)
 }
 
-pub fn deserialize_u16<'de, D: Deserializer<'de>>(deserializer: D) -> StdResult<u16, D::Error> {
+pub fn deserialize_u16<'de, D: Deserializer<'de>>(deserializer: D) -> StdResult<u16, D::Error>{
     deserializer.deserialize_u16(U16Visitor)
 }
 
-pub fn deserialize_u64<'de, D: Deserializer<'de>>(deserializer: D) -> StdResult<u64, D::Error> {
+pub fn deserialize_u64<'de, D: Deserializer<'de>>(deserializer: D) -> StdResult<u64, D::Error>{
     deserializer.deserialize_u64(U64Visitor)
 }
 
@@ -156,8 +156,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::Group(_) |
-        Channel::Private(_) => {
+        Channel::Group(_) | Channel::Private(_) => {
             // Both users in DMs, and all users in groups, will have the same
             // permissions.
             //
@@ -176,10 +175,10 @@ 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()
+        .unwrap()
+        .permissions_for(channel_id, current_user.id);
 
     permissions.remove(perms);
 
diff --git a/src/model/webhook.rs b/src/model/webhook.rs
index 39099e0..4725ec1 100644
--- a/src/model/webhook.rs
+++ b/src/model/webhook.rs
@@ -118,10 +118,7 @@ impl Webhook {
         }
 
         if let Some(name) = name {
-            map.insert(
-                "name".to_owned(),
-                Value::String(name.to_owned()),
-            );
+            map.insert("name".to_owned(), Value::String(name.to_owned()));
         }
 
         match http::edit_webhook_with_token(self.id.0, &self.token, &map) {
@@ -185,7 +182,7 @@ impl Webhook {
     pub fn execute<F: FnOnce(ExecuteWebhook) -> ExecuteWebhook>(&self,
                                                                 wait: bool,
                                                                 f: F)
-                                                                -> Result<Option<Message>> {
+-> Result<Option<Message>>{
         http::execute_webhook(
             self.id.0,
             &self.token,
diff --git a/src/utils/message_builder.rs b/src/utils/message_builder.rs
index 8f13db2..2f714ec 100644
--- a/src/utils/message_builder.rs
+++ b/src/utils/message_builder.rs
@@ -852,8 +852,11 @@ impl Content {
     pub fn to_string(&self) -> String {
         let capacity =
             self.inner.len() + if self.bold { 4 } else { 0 } + if self.italic { 2 } else { 0 } +
-            if self.strikethrough { 4 } else { 0 } +
-            if self.underline { 4 } else { 0 } + if self.code { 2 } else { 0 };
+            if self.strikethrough { 4 } else { 0 } + if self.underline {
+                4
+            } else {
+                0
+            } + if self.code { 2 } else { 0 };
         let mut new_str = String::with_capacity(capacity);
 
         if self.bold {
diff --git a/src/voice/connection.rs b/src/voice/connection.rs
index 2d1e8f5..7cc8b3a 100644
--- a/src/voice/connection.rs
+++ b/src/voice/connection.rs
@@ -1,6 +1,11 @@
 use byteorder::{BigEndian, LittleEndian, ReadBytesExt, WriteBytesExt};
-use opus::{Application as CodingMode, Channels, Decoder as OpusDecoder, Encoder as OpusEncoder,
-           packet as opus_packet};
+use opus::{
+    packet as opus_packet,
+    Application as CodingMode,
+    Channels,
+    Decoder as OpusDecoder,
+    Encoder as OpusEncoder,
+};
 use sodiumoxide::crypto::secretbox::{self, Key, Nonce};
 use std::collections::HashMap;
 use std::io::Write;
@@ -11,7 +16,7 @@ use std::thread::{self, Builder as ThreadBuilder, JoinHandle};
 use std::time::Duration;
 use super::audio::{AudioReceiver, AudioSource, HEADER_LEN, SAMPLE_RATE};
 use super::connection_info::ConnectionInfo;
-use super::{CRYPTO_MODE, VoiceError, payload};
+use super::{payload, VoiceError, CRYPTO_MODE};
 use websocket::client::Url as WebsocketUrl;
 use websocket::sync::client::ClientBuilder;
 use websocket::sync::stream::{AsTcpStream, TcpStream, TlsStream};
@@ -110,27 +115,27 @@ impl Connection {
 
             // Find the position in the bytes that contains the first byte of 0,
             // indicating the "end of the address".
-            let index = bytes.iter().skip(4).position(|&x| x == 0).ok_or(
-                Error::Voice(
-                    VoiceError::FindingByte,
-                ),
-            )?;
+            let index = bytes
+                .iter()
+                .skip(4)
+                .position(|&x| x == 0)
+                .ok_or(Error::Voice(VoiceError::FindingByte))?;
 
             let pos = 4 + index;
             let addr = String::from_utf8_lossy(&bytes[4..pos]);
             let port_pos = len - 2;
             let port = (&bytes[port_pos..]).read_u16::<LittleEndian>()?;
 
-            client.send_json(
-                &payload::build_select_protocol(addr, port),
-            )?;
+            client
+                .send_json(&payload::build_select_protocol(addr, port))?;
         }
 
         let key = encryption_key(&mut client)?;
 
-        let _ = client.stream_ref().as_tcp().set_read_timeout(
-            Some(Duration::from_millis(25)),
-        );
+        let _ = client
+            .stream_ref()
+            .as_tcp()
+            .set_read_timeout(Some(Duration::from_millis(25)));
 
         let mutexed_client = Arc::new(Mutex::new(client));
         let thread_items = start_threads(mutexed_client.clone(), &udp)?;
@@ -178,21 +183,17 @@ impl Connection {
                         let timestamp = handle.read_u32::<BigEndian>()?;
                         let ssrc = handle.read_u32::<BigEndian>()?;
 
-                        nonce.0[..HEADER_LEN].clone_from_slice(
-                            &packet[..HEADER_LEN],
-                        );
+                        nonce.0[..HEADER_LEN]
+                            .clone_from_slice(&packet[..HEADER_LEN]);
 
-                        if let Ok(decrypted) = secretbox::open(
-                            &packet[HEADER_LEN..],
-                            &nonce,
-                            &self.key,
-                        ) {
+                        if let Ok(decrypted) =
+                            secretbox::open(&packet[HEADER_LEN..], &nonce, &self.key) {
                             let channels = opus_packet::get_nb_channels(&decrypted)?;
 
                             let entry =
-                                self.decoder_map.entry((ssrc, channels)).or_insert_with(|| {
-                                    OpusDecoder::new(SAMPLE_RATE, channels).unwrap()
-                                });
+                                self.decoder_map.entry((ssrc, channels)).or_insert_with(
+                                    || OpusDecoder::new(SAMPLE_RATE, channels).unwrap(),
+                                );
 
                             let len = entry.decode(&decrypted, &mut buffer, false)?;
 
@@ -200,13 +201,8 @@ impl Connection {
 
                             let b = if is_stereo { len * 2 } else { len };
 
-                            receiver.voice_packet(
-                                ssrc,
-                                seq,
-                                timestamp,
-                                is_stereo,
-                                &buffer[..b],
-                            );
+                            receiver
+                                .voice_packet(ssrc, seq, timestamp, is_stereo, &buffer[..b]);
                         }
                     },
                     ReceiverStatus::Websocket(VoiceEvent::Speaking(ev)) => {
@@ -227,9 +223,10 @@ impl Connection {
 
         // Send the voice websocket keepalive if it's time
         if self.keepalive_timer.check() {
-            self.client.lock().unwrap().send_json(
-                &payload::build_keepalive(),
-            )?;
+            self.client
+                .lock()
+                .unwrap()
+                .send_json(&payload::build_keepalive())?;
         }
 
         // Send UDP keepalive if it's time
@@ -287,17 +284,14 @@ impl Connection {
             cursor.write_u32::<BigEndian>(self.ssrc)?;
         }
 
-        nonce.0[..HEADER_LEN].clone_from_slice(
-            &packet[..HEADER_LEN],
-        );
+        nonce.0[..HEADER_LEN]
+            .clone_from_slice(&packet[..HEADER_LEN]);
 
         let sl_index = packet.len() - 16;
         let buffer_len = if self.encoder_stereo { 960 * 2 } else { 960 };
 
-        let len = self.encoder.encode(
-            &buffer[..buffer_len],
-            &mut packet[HEADER_LEN..sl_index],
-        )?;
+        let len = self.encoder
+            .encode(&buffer[..buffer_len], &mut packet[HEADER_LEN..sl_index])?;
         let crypted = {
             let slice = &packet[HEADER_LEN..HEADER_LEN + len];
             secretbox::seal(slice, &nonce, &self.key)
@@ -359,11 +353,10 @@ impl Connection {
 
         self.speaking = speaking;
 
-        self.client.lock().unwrap().send_json(
-            &payload::build_speaking(
-                speaking,
-            ),
-        )
+        self.client
+            .lock()
+            .unwrap()
+            .send_json(&payload::build_speaking(speaking))
     }
 }
 
@@ -383,9 +376,8 @@ fn generate_url(endpoint: &mut String) -> Result<WebsocketUrl> {
         endpoint.truncate(len - 3);
     }
 
-    WebsocketUrl::parse(&format!("wss://{}", endpoint)).or(Err(
-        Error::Voice(VoiceError::EndpointUrl),
-    ))
+    WebsocketUrl::parse(&format!("wss://{}", endpoint))
+        .or(Err(Error::Voice(VoiceError::EndpointUrl)))
 }
 
 #[inline]
@@ -397,9 +389,8 @@ fn encryption_key(client: &mut Client) -> Result<Key> {
                     return Err(Error::Voice(VoiceError::VoiceModeInvalid));
                 }
 
-                return Key::from_slice(&ready.secret_key).ok_or(Error::Voice(
-                    VoiceError::KeyGen,
-                ));
+                return Key::from_slice(&ready.secret_key)
+                    .ok_or(Error::Voice(VoiceError::KeyGen));
             },
             VoiceEvent::Unknown(op, value) => {
                 debug!(
diff --git a/src/voice/error.rs b/src/voice/error.rs
index 55be1f6..b756bfb 100644
--- a/src/voice/error.rs
+++ b/src/voice/error.rs
@@ -7,20 +7,14 @@ use std::process::Output;
 pub enum VoiceError {
     /// An indicator that an endpoint URL was invalid.
     EndpointUrl,
-    #[doc(hidden)]
-    ExpectedHandshake,
-    #[doc(hidden)]
-    FindingByte,
-    #[doc(hidden)]
-    HostnameResolve,
-    #[doc(hidden)]
-    KeyGen,
+    #[doc(hidden)] ExpectedHandshake,
+    #[doc(hidden)] FindingByte,
+    #[doc(hidden)] HostnameResolve,
+    #[doc(hidden)] KeyGen,
     /// An error occurred while checking if a path is stereo.
     Streams,
-    #[doc(hidden)]
-    VoiceModeInvalid,
-    #[doc(hidden)]
-    VoiceModeUnavailable,
+    #[doc(hidden)] VoiceModeInvalid,
+    #[doc(hidden)] VoiceModeUnavailable,
     /// An error occurred while running `youtube-dl`.
     YouTubeDLRun(Output),
     /// An error occurred while processing the JSON output from `youtube-dl`.
diff --git a/src/voice/handler.rs b/src/voice/handler.rs
index 24b3cd9..9c3f691 100644
--- a/src/voice/handler.rs
+++ b/src/voice/handler.rs
@@ -225,7 +225,7 @@ impl Handler {
     /// can pass in just a boxed receiver, and do not need to specify `Some`.
     ///
     /// Pass `None` to drop the current receiver, if one exists.
-    pub fn listen<O: Into<Option<Box<AudioReceiver>>>>(&mut self, receiver: O) {
+pub fn listen<O: Into<Option<Box<AudioReceiver>>>>(&mut self, receiver: O){
         self.send(VoiceStatus::SetReceiver(receiver.into()))
     }
 
diff --git a/src/voice/mod.rs b/src/voice/mod.rs
index 4707ea8..a94c8a0 100644
--- a/src/voice/mod.rs
+++ b/src/voice/mod.rs
@@ -22,8 +22,7 @@ const CRYPTO_MODE: &'static str = "xsalsa20_poly1305";
 
 pub(crate) enum Status {
     Connect(ConnectionInfo),
-    #[allow(dead_code)]
-    Disconnect,
+    #[allow(dead_code)] Disconnect,
     SetReceiver(Option<Box<AudioReceiver>>),
     SetSender(Option<Box<AudioSource>>),
 }
diff --git a/src/voice/streamer.rs b/src/voice/streamer.rs
index 3f40bae..c8400f0 100644
--- a/src/voice/streamer.rs
+++ b/src/voice/streamer.rs
@@ -101,11 +101,9 @@ pub fn ytdl(uri: &str) -> Result<Box<AudioSource>> {
     };
 
     let uri = match obj.remove("url") {
-        Some(v) => {
-            match v {
-                Value::String(uri) => uri,
-                other => return Err(Error::Voice(VoiceError::YouTubeDLUrl(other))),
-            }
+        Some(v) => match v {
+            Value::String(uri) => uri,
+            other => return Err(Error::Voice(VoiceError::YouTubeDLUrl(other))),
         },
         None => return Err(Error::Voice(VoiceError::YouTubeDLUrl(Value::Object(obj)))),
     };
@@ -131,9 +129,9 @@ fn is_stereo(path: &OsStr) -> Result<bool> {
         .ok_or(Error::Voice(VoiceError::Streams))?;
 
     let check = streams.iter().any(|stream| {
-        let channels = stream.as_object().and_then(|m| {
-            m.get("channels").and_then(|v| v.as_i64())
-        });
+        let channels = stream
+            .as_object()
+            .and_then(|m| m.get("channels").and_then(|v| v.as_i64()));
 
         channels == Some(2)
     });