Change the config a bit, and a few nitpicks

50 files changed, 1552 insertions, 1361 deletions

diff --git a/src/builder/create_embed.rs b/src/builder/create_embed.rs
index c0dead6..0d848ee 100644
--- a/src/builder/create_embed.rs
+++ b/src/builder/create_embed.rs
@@ -47,8 +47,7 @@ impl CreateEmbed {
     ///
     /// [`CreateEmbedAuthor`]: struct.CreateEmbedAuthor.html
     pub fn author<F>(mut self, f: F) -> Self
-    where
-        F: FnOnce(CreateEmbedAuthor) -> CreateEmbedAuthor, {
+        where F: FnOnce(CreateEmbedAuthor) -> CreateEmbedAuthor {
         let author = f(CreateEmbedAuthor::default()).0;
 
         self.0.insert("author".to_owned(), Value::Object(author));
@@ -68,8 +67,10 @@ impl CreateEmbed {
     /// Set the colour of the left-hand side of the embed.
     #[cfg(feature = "utils")]
     pub fn colour<C: Into<Colour>>(mut self, colour: C) -> Self {
-        self.0.insert("color".to_owned(),
-                      Value::Number(Number::from(colour.into().0 as u64)));
+        self.0.insert(
+            "color".to_owned(),
+            Value::Number(Number::from(colour.into().0 as u64)),
+        );
 
         CreateEmbed(self.0)
     }
@@ -96,8 +97,10 @@ impl CreateEmbed {
     ///
     /// **Note**: This can't be longer than 2048 characters.
     pub fn description(mut self, description: &str) -> Self {
-        self.0.insert("description".to_owned(),
-                      Value::String(description.to_owned()));
+        self.0.insert(
+            "description".to_owned(),
+            Value::String(description.to_owned()),
+        );
 
         CreateEmbed(self.0)
     }
@@ -113,8 +116,7 @@ impl CreateEmbed {
     ///
     /// [`CreateEmbedField`]: struct.CreateEmbedField.html
     pub fn field<F>(mut self, f: F) -> Self
-    where
-        F: FnOnce(CreateEmbedField) -> CreateEmbedField, {
+        where F: FnOnce(CreateEmbedField) -> CreateEmbedField {
         let field = f(CreateEmbedField::default()).0;
 
         {
@@ -170,8 +172,7 @@ impl CreateEmbed {
     ///
     /// [`CreateEmbedFooter`]: struct.CreateEmbedFooter.html
     pub fn footer<F>(mut self, f: F) -> Self
-    where
-        F: FnOnce(CreateEmbedFooter) -> CreateEmbedFooter, {
+        where F: FnOnce(CreateEmbedFooter) -> CreateEmbedFooter {
         let footer = f(CreateEmbedFooter::default()).0;
 
         self.0.insert("footer".to_owned(), Value::Object(footer));
@@ -352,7 +353,9 @@ impl From<Embed> for CreateEmbed {
         }
 
         for field in embed.fields {
-            b = b.field(move |f| f.inline(field.inline).name(&field.name).value(&field.value));
+            b = b.field(move |f| {
+                f.inline(field.inline).name(&field.name).value(&field.value)
+            });
         }
 
         if let Some(image) = embed.image {
@@ -513,8 +516,7 @@ impl<'a> From<&'a str> for Timestamp {
 }
 
 impl<'a, Tz: TimeZone> From<&'a DateTime<Tz>> for Timestamp
-where
-    Tz::Offset: Display, {
+    where Tz::Offset: Display {
     fn from(dt: &'a DateTime<Tz>) -> Self {
         Timestamp {
             ts: dt.to_rfc3339(),
diff --git a/src/builder/create_message.rs b/src/builder/create_message.rs
index c5a3cc3..c472ab6 100644
--- a/src/builder/create_message.rs
+++ b/src/builder/create_message.rs
@@ -53,8 +53,7 @@ impl CreateMessage {
 
     /// Set an embed for the message.
     pub fn embed<F>(mut self, f: F) -> Self
-    where
-        F: FnOnce(CreateEmbed) -> CreateEmbed, {
+        where F: FnOnce(CreateEmbed) -> CreateEmbed {
         let embed = Value::Object(f(CreateEmbed::default()).0);
 
         self.0.insert("embed".to_owned(), embed);
diff --git a/src/builder/edit_channel.rs b/src/builder/edit_channel.rs
index 5537b48..e3bf78e 100644
--- a/src/builder/edit_channel.rs
+++ b/src/builder/edit_channel.rs
@@ -71,8 +71,10 @@ impl EditChannel {
     ///
     /// [voice]: ../model/enum.ChannelType.html#variant.Voice
     pub fn user_limit(mut self, user_limit: u64) -> Self {
-        self.0.insert("user_limit".to_owned(),
-                      Value::Number(Number::from(user_limit)));
+        self.0.insert(
+            "user_limit".to_owned(),
+            Value::Number(Number::from(user_limit)),
+        );
 
         self
     }
diff --git a/src/builder/edit_guild.rs b/src/builder/edit_guild.rs
index 67b0003..f88db2a 100644
--- a/src/builder/edit_guild.rs
+++ b/src/builder/edit_guild.rs
@@ -23,10 +23,13 @@ impl EditGuild {
     ///
     /// [`afk_timeout`]: #method.afk_timeout
     pub fn afk_channel<C: Into<ChannelId>>(mut self, channel: Option<C>) -> Self {
-        self.0.insert("afk_channel_id".to_owned(), match channel {
-            Some(channel) => Value::Number(Number::from(channel.into().0)),
-            None => Value::Null,
-        });
+        self.0.insert(
+            "afk_channel_id".to_owned(),
+            match channel {
+                Some(channel) => Value::Number(Number::from(channel.into().0)),
+                None => Value::Null,
+            },
+        );
 
         self
     }
@@ -36,8 +39,10 @@ impl EditGuild {
     ///
     /// [`afk_channel`]: #method.afk_channel
     pub fn afk_timeout(mut self, timeout: u64) -> Self {
-        self.0.insert("afk_timeout".to_owned(),
-                      Value::Number(Number::from(timeout)));
+        self.0.insert(
+            "afk_timeout".to_owned(),
+            Value::Number(Number::from(timeout)),
+        );
 
         self
     }
@@ -72,8 +77,10 @@ impl EditGuild {
     ///
     /// [`utils::read_image`]: ../utils/fn.read_image.html
     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())));
+        self.0.insert(
+            "icon".to_owned(),
+            icon.map_or_else(|| Value::Null, |x| Value::String(x.to_owned())),
+        );
 
         self
     }
@@ -92,8 +99,10 @@ impl EditGuild {
     ///
     /// **Note**: The current user must be the owner of the guild.
     pub fn owner<U: Into<UserId>>(mut self, user_id: U) -> Self {
-        self.0.insert("owner_id".to_owned(),
-                      Value::Number(Number::from(user_id.into().0)));
+        self.0.insert(
+            "owner_id".to_owned(),
+            Value::Number(Number::from(user_id.into().0)),
+        );
 
         self
     }
@@ -177,8 +186,7 @@ impl EditGuild {
     /// [`VerificationLevel`]: ../model/enum.VerificationLevel.html
     /// [`VerificationLevel::High`]: ../model/enum.VerificationLevel.html#variant.High
     pub fn verification_level<V>(mut self, verification_level: V) -> Self
-    where
-        V: Into<VerificationLevel>, {
+        where V: Into<VerificationLevel> {
         let num = Value::Number(Number::from(verification_level.into().num()));
 
         self.0.insert("verification_level".to_owned(), num);
diff --git a/src/builder/edit_member.rs b/src/builder/edit_member.rs
index a88ae17..23bf1f2 100644
--- a/src/builder/edit_member.rs
+++ b/src/builder/edit_member.rs
@@ -67,8 +67,10 @@ impl EditMember {
     ///
     /// [Move Members]: ../model/permissions/constant.MOVE_MEMBERS.html
     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)));
+        self.0.insert(
+            "channel_id".to_owned(),
+            Value::Number(Number::from(channel_id.into().0)),
+        );
 
         self
     }
diff --git a/src/builder/edit_profile.rs b/src/builder/edit_profile.rs
index 63daec3..6aa4e78 100644
--- a/src/builder/edit_profile.rs
+++ b/src/builder/edit_profile.rs
@@ -74,8 +74,10 @@ impl EditProfile {
     ///
     /// [provided]: #method.password
     pub fn new_password(mut self, new_password: &str) -> Self {
-        self.0.insert("new_password".to_owned(),
-                      Value::String(new_password.to_owned()));
+        self.0.insert(
+            "new_password".to_owned(),
+            Value::String(new_password.to_owned()),
+        );
 
         self
     }
diff --git a/src/builder/edit_role.rs b/src/builder/edit_role.rs
index 28aecac..bece07c 100644
--- a/src/builder/edit_role.rs
+++ b/src/builder/edit_role.rs
@@ -50,8 +50,10 @@ impl EditRole {
 
         #[cfg(feature = "utils")]
         {
-            map.insert("color".to_owned(),
-                       Value::Number(Number::from(role.colour.0)));
+            map.insert(
+                "color".to_owned(),
+                Value::Number(Number::from(role.colour.0)),
+            );
         }
 
         #[cfg(not(feature = "utils"))]
@@ -63,10 +65,14 @@ impl EditRole {
         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("permissions".to_owned(),
-                   Value::Number(Number::from(role.permissions.bits())));
-        map.insert("position".to_owned(),
-                   Value::Number(Number::from(role.position)));
+        map.insert(
+            "permissions".to_owned(),
+            Value::Number(Number::from(role.permissions.bits())),
+        );
+        map.insert(
+            "position".to_owned(),
+            Value::Number(Number::from(role.position)),
+        );
 
         EditRole(map)
     }
@@ -105,8 +111,10 @@ impl EditRole {
 
     /// The set of permissions to assign the role.
     pub fn permissions(mut self, permissions: Permissions) -> Self {
-        self.0.insert("permissions".to_owned(),
-                      Value::Number(Number::from(permissions.bits())));
+        self.0.insert(
+            "permissions".to_owned(),
+            Value::Number(Number::from(permissions.bits())),
+        );
 
         self
     }
diff --git a/src/builder/execute_webhook.rs b/src/builder/execute_webhook.rs
index 9a0c9d9..0cb276c 100644
--- a/src/builder/execute_webhook.rs
+++ b/src/builder/execute_webhook.rs
@@ -74,8 +74,10 @@ impl ExecuteWebhook {
     ///     .content("Here's a webhook"));
     /// ```
     pub fn avatar_url(mut self, avatar_url: &str) -> Self {
-        self.0.insert("avatar_url".to_owned(),
-                      Value::String(avatar_url.to_owned()));
+        self.0.insert(
+            "avatar_url".to_owned(),
+            Value::String(avatar_url.to_owned()),
+        );
 
         self
     }
diff --git a/src/cache/mod.rs b/src/cache/mod.rs
index d70d32d..5eb2208 100644
--- a/src/cache/mod.rs
+++ b/src/cache/mod.rs
@@ -479,12 +479,10 @@ impl Cache {
     /// [`Guild`]: ../model/struct.Guild.html
     /// [`members`]: ../model/struct.Guild.html#structfield.members
     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())
+        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()
+        })
     }
 
     /// Retrieves a [`PrivateChannel`] from the cache's [`private_channels`]
@@ -553,9 +551,7 @@ impl Cache {
     /// # }
     /// ```
     pub fn role<G, R>(&self, guild_id: G, role_id: R) -> Option<Role>
-    where
-        G: Into<GuildId>,
-        R: Into<RoleId>, {
+        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())
@@ -719,9 +715,9 @@ impl Cache {
 
     pub(crate) 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));
+        self.groups.get_mut(&event.channel_id).map(|group| {
+            group.write().unwrap().recipients.remove(&event.user.id)
+        });
     }
 
     pub(crate) fn update_with_channel_update(&mut self, event: &ChannelUpdateEvent) {
@@ -807,9 +803,9 @@ impl Cache {
     }
 
     pub(crate) 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()));
+        self.guilds.get_mut(&event.guild_id).map(|guild| {
+            guild.write().unwrap().emojis.extend(event.emojis.clone())
+        });
     }
 
     pub(crate) fn update_with_guild_member_add(&mut self, event: &mut GuildMemberAddEvent) {
@@ -863,16 +859,18 @@ impl Cache {
             };
 
             if !found {
-                guild.members.insert(event.user.id,
-                                     Member {
-                                         deaf: false,
-                                         guild_id: event.guild_id,
-                                         joined_at: None,
-                                         mute: false,
-                                         nick: event.nick.clone(),
-                                         roles: event.roles.clone(),
-                                         user: Arc::new(RwLock::new(event.user.clone())),
-                                     });
+                guild.members.insert(
+                    event.user.id,
+                    Member {
+                        deaf: false,
+                        guild_id: event.guild_id,
+                        joined_at: None,
+                        mute: false,
+                        nick: event.nick.clone(),
+                        roles: event.roles.clone(),
+                        user: Arc::new(RwLock::new(event.user.clone())),
+                    },
+                );
             }
 
             item
@@ -886,9 +884,9 @@ impl Cache {
             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()));
+        self.guilds.get_mut(&event.guild_id).map(|guild| {
+            guild.write().unwrap().members.extend(event.members.clone())
+        });
     }
 
     pub(crate) fn update_with_guild_role_create(&mut self, event: &GuildRoleCreateEvent) {
@@ -944,14 +942,14 @@ impl Cache {
 
     pub(crate) fn update_with_presences_replace(&mut self, event: &PresencesReplaceEvent) {
         self.presences.extend({
-                                  let mut p: HashMap<UserId, Presence> = HashMap::default();
+            let mut p: HashMap<UserId, Presence> = HashMap::default();
 
-                                  for presence in &event.presences {
-                                      p.insert(presence.user_id, presence.clone());
-                                  }
+            for presence in &event.presences {
+                p.insert(presence.user_id, presence.clone());
+            }
 
-                                  p
-                              });
+            p
+        });
     }
 
     pub(crate) fn update_with_presence_update(&mut self, event: &mut PresenceUpdateEvent) {
diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index fa6193e..aec821a 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -80,10 +80,12 @@ pub fn dispatch<H: EventHandler + 'static>(event: Event,
     match event {
         Event::MessageCreate(event) => {
             let context = context(conn, data);
-            dispatch_message(context.clone(),
-                             event.message.clone(),
-                             event_handler,
-                             tokio_handle);
+            dispatch_message(
+                context.clone(),
+                event.message.clone(),
+                event_handler,
+                tokio_handle,
+            );
 
             if let Some(ref mut framework) = *framework.lock().unwrap() {
                 helper! {{
diff --git a/src/client/mod.rs b/src/client/mod.rs
index 7549d19..996b943 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -337,10 +337,10 @@ impl<H: EventHandler + 'static> Client<H> {
     /// use std::env;
     ///
     /// let mut client = Client::new(&env::var("DISCORD_TOKEN")?, Handler);
-    /// client.with_framework(MyFramework { commands: { 
-    ///     let mut map = HashMap::new(); 
-    ///     map.insert("ping".to_string(), Box::new(|msg, _| msg.channel_id.say("pong!"))); 
-    ///     map 
+    /// client.with_framework(MyFramework { commands: {
+    ///     let mut map = HashMap::new();
+    ///     map.insert("ping".to_string(), Box::new(|msg, _| msg.channel_id.say("pong!")));
+    ///     map
     /// }});
     /// # Ok(())
     /// # }
@@ -593,8 +593,10 @@ impl<H: EventHandler + 'static> Client<H> {
     /// [`start_shard_range`]: #method.start_shard_range
     /// [Gateway docs]: gateway/index.html#sharding
     pub fn start_shards(&mut self, total_shards: u64) -> Result<()> {
-        self.start_connection([0, total_shards - 1, total_shards],
-                              http::get_gateway()?.url)
+        self.start_connection(
+            [0, total_shards - 1, total_shards],
+            http::get_gateway()?.url,
+        )
     }
 
     /// Establish a range of sharded connections and start listening for events.
@@ -709,11 +711,13 @@ impl<H: EventHandler + 'static> Client<H> {
         for shard_number in shards_index..shards_total {
             let shard_info = [shard_number, shard_data[2]];
 
-            let boot = boot_shard(&BootInfo {
-                                      gateway_url: gateway_url.clone(),
-                                      shard_info: shard_info,
-                                      token: self.token.clone(),
-                                  });
+            let boot_info = BootInfo {
+                gateway_url: gateway_url.clone(),
+                shard_info: shard_info,
+                token: self.token.clone(),
+            };
+
+            let boot = boot_shard(&boot_info);
 
             match boot {
                 Ok(shard) => {
@@ -814,9 +818,11 @@ fn boot_shard(info: &BootInfo) -> Result<Shard> {
             }
         }
 
-        let attempt = Shard::new(info.gateway_url.clone(),
-                                 info.token.clone(),
-                                 info.shard_info);
+        let attempt = Shard::new(
+            info.gateway_url.clone(),
+            info.token.clone(),
+            info.shard_info,
+        );
 
         match attempt {
             Ok(shard) => {
@@ -842,10 +848,10 @@ fn monitor_shard<H: EventHandler + 'static>(mut info: MonitorInfo<H>) {
 
         for _ in 0..3 {
             let boot = boot_shard(&BootInfo {
-                                      gateway_url: info.gateway_url.clone(),
-                                      shard_info: info.shard_info,
-                                      token: info.token.clone(),
-                                  });
+                gateway_url: info.gateway_url.clone(),
+                shard_info: info.shard_info,
+                token: info.token.clone(),
+            });
 
             match boot {
                 Ok(new_shard) => {
@@ -877,9 +883,11 @@ fn monitor_shard<H: EventHandler + 'static>(mut info: MonitorInfo<H>) {
         let mut shard = info.shard.lock();
 
         if let Err(e) = shard.shutdown_clean() {
-            error!("Error shutting down shard {:?}: {:?}",
-                   shard.shard_info(),
-                   e);
+            error!(
+                "Error shutting down shard {:?}: {:?}",
+                shard.shard_info(),
+                e
+            );
         }
     }
 }
diff --git a/src/constants.rs b/src/constants.rs
index 91aef17..05ac85e 100644
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -12,9 +12,11 @@ pub const MESSAGE_CODE_LIMIT: u16 = 2000;
 /// The [UserAgent] sent along with every request.
 ///
 /// [UserAgent]: ../hyper/header/struct.UserAgent.html
-pub const USER_AGENT: &'static str = concat!("DiscordBot (https://github.com/zeyla/serenity, ",
-                                             env!("CARGO_PKG_VERSION"),
-                                             ")");
+pub const USER_AGENT: &'static str = concat!(
+    "DiscordBot (https://github.com/zeyla/serenity, ",
+    env!("CARGO_PKG_VERSION"),
+    ")"
+);
 
 /// List of messages Discord shows on member join.
 pub static JOIN_MESSAGES: &'static [&'static str] = &[
diff --git a/src/ext.rs b/src/ext.rs
index dd1c3cb..9518c04 100644
--- a/src/ext.rs
+++ b/src/ext.rs
@@ -15,7 +15,7 @@
 
 #[cfg(feature = "cache")]
 pub use super::cache;
-#[cfg(feature = "framework")]
+#[cfg(feature = "buitin_framework")]
 pub use super::framework;
 #[cfg(feature = "voice")]
 pub use super::voice;
diff --git a/src/framework/buckets.rs b/src/framework/buckets.rs
index 95b832b..4719b85 100644
--- a/src/framework/buckets.rs
+++ b/src/framework/buckets.rs
@@ -4,6 +4,12 @@ use std::default::Default;
 use client::Context;
 use model::{ChannelId, GuildId, UserId};
 
+#[cfg(feature = "cache")]
+type Check = Fn(&mut Context, Option<GuildId>, ChannelId, UserId) -> bool + 'static;
+
+#[cfg(not(feature = "cache"))]
+type Check = Fn(&mut Context, ChannelId, UserId) -> bool + 'static;
+
 pub(crate) struct Ratelimit {
     pub delay: i64,
     pub limit: Option<(i64, i32)>,
@@ -19,11 +25,7 @@ pub(crate) struct MemberRatelimit {
 pub(crate) struct Bucket {
     pub ratelimit: Ratelimit,
     pub users: HashMap<u64, MemberRatelimit>,
-    #[cfg(feature = "cache")]
-    pub check:
-        Option<Box<Fn(&mut Context, Option<GuildId>, ChannelId, UserId) -> bool + 'static>>,
-    #[cfg(not(feature = "cache"))]
-    pub checK: Option<Box<Fn(&mut Context, ChannelId, UserId) -> bool + 'static>>,
+    pub check: Option<Box<Check>>,
 }
 
 impl Bucket {
diff --git a/src/framework/command.rs b/src/framework/command.rs
index 1484891..4e338d4 100644
--- a/src/framework/command.rs
+++ b/src/framework/command.rs
@@ -69,8 +69,7 @@ pub struct Command {
 
 impl Command {
     pub fn new<F>(f: F) -> Self
-    where
-        F: Fn(&mut Context, &Message, Vec<String>) -> Result<(), String> + 'static, {
+        where F: Fn(&mut Context, &Message, Vec<String>) -> Result<(), String> + 'static {
         Command {
             aliases: Vec::new(),
             checks: Vec::default(),
diff --git a/src/framework/configuration.rs b/src/framework/configuration.rs
index 06e7e6a..28e1af5 100644
--- a/src/framework/configuration.rs
+++ b/src/framework/configuration.rs
@@ -215,8 +215,7 @@ impl Configuration {
     ///     })));
     /// ```
     pub fn dynamic_prefix<F>(mut self, dynamic_prefix: F) -> Self
-    where
-        F: Fn(&mut Context, &Message) -> Option<String> + Send + Sync + 'static, {
+        where F: Fn(&mut Context, &Message) -> Option<String> + Send + Sync + 'static {
         self.dynamic_prefix = Some(Box::new(dynamic_prefix));
 
         self
diff --git a/src/framework/create_command.rs b/src/framework/create_command.rs
index d97f6fa..d2ae31f 100644
--- a/src/framework/create_command.rs
+++ b/src/framework/create_command.rs
@@ -65,8 +65,7 @@ impl CreateCommand {
     /// }
     /// ```
     pub fn check<F>(mut self, check: F) -> Self
-    where
-        F: Fn(&mut Context, &Message, &Arc<Command>) -> bool + Send + Sync + 'static, {
+        where F: Fn(&mut Context, &Message, &Arc<Command>) -> bool + Send + Sync + 'static {
         self.0.checks.push(Box::new(check));
 
         self
@@ -100,8 +99,10 @@ impl CreateCommand {
     ///
     /// [`exec_str`]: #method.exec_str
     pub fn exec<F>(mut self, func: F) -> Self
-    where
-        F: Fn(&mut Context, &Message, Vec<String>) -> Result<(), String> + Send + Sync + 'static, {
+        where F: Fn(&mut Context, &Message, Vec<String>) -> Result<(), String>
+                     + Send
+                     + Sync
+                     + 'static {
         self.0.exec = CommandType::Basic(Box::new(func));
 
         self
@@ -113,12 +114,9 @@ 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>>, &[String])
-           -> Result<(), String>
-            + Send
-            + Sync
-            + 'static, {
+        where F: Fn(&mut Context, &Message, HashMap<String, Arc<CommandGroup>>, &[String])
+                    -> Result<(), String>
+                     + 'static {
         self.0.exec = CommandType::WithCommands(Box::new(f));
 
         self
diff --git a/src/framework/create_group.rs b/src/framework/create_group.rs
index d5b68c3..5c36e4d 100644
--- a/src/framework/create_group.rs
+++ b/src/framework/create_group.rs
@@ -27,26 +27,27 @@ pub struct CreateGroup(pub CommandGroup);
 impl CreateGroup {
     /// Adds a command to group.
     pub fn command<F>(mut self, command_name: &str, f: F) -> Self
-    where
-        F: FnOnce(CreateCommand) -> CreateCommand, {
+        where F: FnOnce(CreateCommand) -> CreateCommand {
         let cmd = f(CreateCommand(Command::default())).0;
 
         for n in &cmd.aliases {
             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())));
+                self.0.commands.insert(
+                    format!("{} {}", prefix, n.to_owned()),
+                    CommandOrAlias::Alias(format!("{} {}", prefix, command_name.to_string())),
+                );
             } else {
-                self.0.commands.insert(n.to_owned(),
-                                       CommandOrAlias::Alias(command_name.to_string()));
+                self.0.commands.insert(
+                    n.to_owned(),
+                    CommandOrAlias::Alias(command_name.to_string()),
+                );
             }
         }
 
-        self.0.commands.insert(command_name.to_owned(),
-                               CommandOrAlias::Command(Arc::new(cmd)));
+        self.0.commands.insert(
+            command_name.to_owned(),
+            CommandOrAlias::Command(Arc::new(cmd)),
+        );
 
         self
     }
@@ -54,8 +55,10 @@ impl CreateGroup {
     /// Adds a command to group with simplified API.
     /// You can return Err(string) if there's an error.
     pub fn on<F>(mut self, command_name: &str, f: F) -> Self
-    where
-        F: Fn(&mut Context, &Message, Vec<String>) -> Result<(), String> + Send + Sync + 'static, {
+        where F: Fn(&mut Context, &Message, Vec<String>) -> Result<(), String>
+                     + Send
+                     + Sync
+                     + 'static {
         let cmd = Arc::new(Command::new(f));
 
         self.0
diff --git a/src/framework/help_commands.rs b/src/framework/help_commands.rs
index 7f863b4..6db3561 100644
--- a/src/framework/help_commands.rs
+++ b/src/framework/help_commands.rs
@@ -33,8 +33,9 @@ use model::{ChannelId, Message};
 use utils::Colour;
 
 fn error_embed(channel_id: &ChannelId, input: &str) {
-    let _ =
-        channel_id.send_message(|m| m.embed(|e| e.colour(Colour::dark_red()).description(input)));
+    let _ = channel_id.send_message(|m| {
+        m.embed(|e| e.colour(Colour::dark_red()).description(input))
+    });
 }
 
 fn remove_aliases(cmds: &HashMap<String, CommandOrAlias>) -> HashMap<&String, &InternalCommand> {
@@ -158,9 +159,10 @@ pub fn with_embeds(_: &mut Context,
 
     let _ = msg.channel_id.send_message(|m| {
         m.embed(|mut e| {
-            e = e.colour(Colour::rosewater())
-                .description("To get help with an individual command, pass its \
-                              name as an argument to this command.");
+            e = e.colour(Colour::rosewater()).description(
+                "To get help with an individual command, pass its \
+                 name as an argument to this command.",
+            );
 
             let mut group_names = groups.keys().collect::<Vec<_>>();
             group_names.sort();
@@ -275,14 +277,16 @@ pub fn plain(_: &mut Context,
                     let _ = write!(result, "**Group:** {}\n", group_name);
                 }
 
+                let only = if command.dm_only {
+                    "Only in DM"
+                } else if command.guild_only {
+                    "Only in guilds"
+                } else {
+                    "In DM and guilds"
+                };
+
                 result.push_str("**Available:** ");
-                result.push_str(if command.dm_only {
-                                    "Only in DM"
-                                } else if command.guild_only {
-                                    "Only in guilds"
-                                } else {
-                                    "In DM and guilds"
-                                });
+                result.push_str(only);
                 result.push_str("\n");
 
                 let _ = msg.channel_id.say(&result);
diff --git a/src/framework/mod.rs b/src/framework/mod.rs
index 9fddc76..14533b5 100644
--- a/src/framework/mod.rs
+++ b/src/framework/mod.rs
@@ -277,8 +277,7 @@ impl BuiltinFramework {
     /// [`prefix`]: struct.Configuration.html#method.prefix
     /// [allowing whitespace]: struct.Configuration.html#method.allow_whitespace
     pub fn configure<F>(mut self, f: F) -> Self
-    where
-        F: FnOnce(Configuration) -> Configuration, {
+        where F: FnOnce(Configuration) -> Configuration {
         self.configuration = f(self.configuration);
 
         self
@@ -308,17 +307,18 @@ impl BuiltinFramework {
     ///         .exec_str("pong!")));
     /// ```
     pub fn bucket<S>(mut self, s: S, delay: i64, time_span: i64, limit: i32) -> Self
-    where
-        S: Into<String>, {
-        self.buckets.insert(s.into(),
-                            Bucket {
-                                ratelimit: Ratelimit {
-                                    delay: delay,
-                                    limit: Some((time_span, limit)),
-                                },
-                                users: HashMap::new(),
-                                check: None,
-                            });
+        where S: Into<String> {
+        self.buckets.insert(
+            s.into(),
+            Bucket {
+                ratelimit: Ratelimit {
+                    delay: delay,
+                    limit: Some((time_span, limit)),
+                },
+                users: HashMap::new(),
+                check: None,
+            },
+        );
 
         self
     }
@@ -359,18 +359,19 @@ impl BuiltinFramework {
                                     limit: i32,
                                     check: Check)
                                     -> Self
-    where
-        Check: Fn(&mut Context, Option<GuildId>, ChannelId, UserId) -> bool + 'static,
-        S: Into<String>, {
-        self.buckets.insert(s.into(),
-                            Bucket {
-                                ratelimit: Ratelimit {
-                                    delay,
-                                    limit: Some((time_span, limit)),
-                                },
-                                users: HashMap::new(),
-                                check: Some(Box::new(check)),
-                            });
+        where Check: Fn(&mut Context, Option<GuildId>, ChannelId, UserId) -> bool + 'static,
+              S: Into<String> {
+        self.buckets.insert(
+            s.into(),
+            Bucket {
+                ratelimit: Ratelimit {
+                    delay,
+                    limit: Some((time_span, limit)),
+                },
+                users: HashMap::new(),
+                check: Some(Box::new(check)),
+            },
+        );
 
         self
     }
@@ -409,18 +410,18 @@ impl BuiltinFramework {
                                     limit: i32,
                                     check: Check)
                                     -> Self
-    where
-        Check: Fn(&mut Context, ChannelId, UserId) -> bool + 'static,
-        S: Into<String>, {
-        self.buckets.insert(s.into(),
-                            Bucket {
-                                ratelimit: Ratelimit {
-                                    delay,
-                                    limit: Some((time_span, limit)),
-                                },
-                                users: HashMap::new(),
-                                check: Some(Box::new(check)),
-                            });
+        where Check: Fn(&mut Context, ChannelId, UserId) -> bool + 'static, S: Into<String> {
+        self.buckets.insert(
+            s.into(),
+            Bucket {
+                ratelimit: Ratelimit {
+                    delay,
+                    limit: Some((time_span, limit)),
+                },
+                users: HashMap::new(),
+                check: Some(Box::new(check)),
+            },
+        );
 
         self
     }
@@ -447,17 +448,18 @@ impl BuiltinFramework {
     ///         .exec_str("pong!")));
     /// ```
     pub fn simple_bucket<S>(mut self, s: S, delay: i64) -> Self
-    where
-        S: Into<String>, {
-        self.buckets.insert(s.into(),
-                            Bucket {
-                                ratelimit: Ratelimit {
-                                    delay: delay,
-                                    limit: None,
-                                },
-                                users: HashMap::new(),
-                                check: None,
-                            });
+        where S: Into<String> {
+        self.buckets.insert(
+            s.into(),
+            Bucket {
+                ratelimit: Ratelimit {
+                    delay: delay,
+                    limit: None,
+                },
+                users: HashMap::new(),
+                check: None,
+            },
+        );
 
         self
     }
@@ -516,23 +518,19 @@ impl BuiltinFramework {
                 if let Some(ref mut bucket) = self.buckets.get_mut(bucket) {
                     let rate_limit = bucket.take(message.author.id.0);
                     match bucket.check {
-                        Some(ref check) => {
-                            if feature_cache! {{ 
+                        Some(ref check) => if feature_cache! {{ 
                                 let guild_id = message.guild_id();
                                 (check)(context, guild_id, message.channel_id, message.author.id) 
                             } else {
                                 (check)(context, message.channel_id, message.author.id)
                             }} {
-                                if rate_limit > 0i64 {
-                                    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));
+                        },
                     }
                 }
             }
@@ -540,18 +538,18 @@ impl BuiltinFramework {
             if let Some(x) = command.min_args {
                 if args < x as usize {
                     return Some(DispatchError::NotEnoughArguments {
-                                    min: x,
-                                    given: args,
-                                });
+                        min: x,
+                        given: args,
+                    });
                 }
             }
 
             if let Some(x) = command.max_args {
                 if args > x as usize {
                     return Some(DispatchError::TooManyArguments {
-                                    max: x,
-                                    given: args,
-                                });
+                        max: x,
+                        given: args,
+                    });
                 }
             }
 
@@ -562,7 +560,9 @@ impl BuiltinFramework {
                 }
 
                 if !self.has_correct_permissions(command, message) {
-                    return Some(DispatchError::LackOfPermissions(command.required_permissions));
+                    return Some(DispatchError::LackOfPermissions(
+                        command.required_permissions,
+                    ));
                 }
 
                 if (!self.configuration.allow_dm && message.is_private()) ||
@@ -636,9 +636,8 @@ impl BuiltinFramework {
     /// # }
     /// ```
     pub fn on<F, S>(mut self, command_name: S, f: F) -> Self
-    where
-        F: Fn(&mut Context, &Message, Vec<String>) -> Result<(), String> + 'static,
-        S: Into<String>, {
+        where F: Fn(&mut Context, &Message, Vec<String>) -> Result<(), String> + 'static,
+              S: Into<String> {
         {
             let ungrouped = self.groups
                 .entry("Ungrouped".to_owned())
@@ -670,9 +669,7 @@ impl BuiltinFramework {
     ///     }));
     /// ```
     pub fn command<F, S>(mut self, command_name: S, f: F) -> Self
-    where
-        F: FnOnce(CreateCommand) -> CreateCommand,
-        S: Into<String>, {
+        where F: FnOnce(CreateCommand) -> CreateCommand, S: Into<String> {
         {
             let ungrouped = self.groups
                 .entry("Ungrouped".to_owned())
@@ -684,10 +681,10 @@ impl BuiltinFramework {
 
                 if let Some(ref prefix) = group.prefix {
                     for v in &cmd.aliases {
-                        group
-                            .commands
-                            .insert(format!("{} {}", prefix, v.to_owned()),
-                                    CommandOrAlias::Alias(format!("{} {}", prefix, name)));
+                        group.commands.insert(
+                            format!("{} {}", prefix, v.to_owned()),
+                            CommandOrAlias::Alias(format!("{} {}", prefix, name)),
+                        );
                     }
                 } else {
                     for v in &cmd.aliases {
@@ -730,9 +727,7 @@ impl BuiltinFramework {
     ///         .command("pong", |c| c.exec_str("ping!"))));
     /// ```
     pub fn group<F, S>(mut self, group_name: S, f: F) -> Self
-    where
-        F: FnOnce(CreateGroup) -> CreateGroup,
-        S: Into<String>, {
+        where F: FnOnce(CreateGroup) -> CreateGroup, S: Into<String> {
         let group = f(CreateGroup(CommandGroup::default())).0;
 
         self.groups.insert(group_name.into(), Arc::new(group));
@@ -777,8 +772,7 @@ impl BuiltinFramework {
     ///     }));
     /// ```
     pub fn on_dispatch_error<F>(mut self, f: F) -> Self
-    where
-        F: Fn(Context, Message, DispatchError) + 'static, {
+        where F: Fn(Context, Message, DispatchError) + 'static {
         self.dispatch_error_handler = Some(Arc::new(f));
 
         self
@@ -834,8 +828,7 @@ impl BuiltinFramework {
     /// ```
     ///
     pub fn before<F>(mut self, f: F) -> Self
-    where
-        F: Fn(&mut Context, &Message, &String) -> bool + 'static, {
+        where F: Fn(&mut Context, &Message, &String) -> bool + 'static {
         self.before = Some(Arc::new(f));
 
         self
@@ -866,8 +859,7 @@ impl BuiltinFramework {
     ///     }));
     /// ```
     pub fn after<F>(mut self, f: F) -> Self
-    where
-        F: Fn(&mut Context, &Message, &String, Result<(), String>) + 'static, {
+        where F: Fn(&mut Context, &Message, &String, Result<(), String>) + 'static {
         self.after = Some(Arc::new(f));
 
         self
@@ -906,9 +898,9 @@ impl ::Framework for BuiltinFramework {
                 }
 
                 built.push_str(match round.get(i) {
-                                   Some(piece) => piece,
-                                   None => continue 'outer,
-                               });
+                    Some(piece) => piece,
+                    None => continue 'outer,
+                });
 
                 let groups = self.groups.clone();
 
@@ -950,12 +942,14 @@ impl ::Framework for BuiltinFramework {
                             }
                         };
 
-                        if let Some(error) = self.should_fail(&mut context,
-                                                              &message,
-                                                              &command,
-                                                              args.len(),
-                                                              &to_check,
-                                                              &built) {
+                        if let Some(error) = self.should_fail(
+                            &mut context,
+                            &message,
+                            &command,
+                            args.len(),
+                            &to_check,
+                            &built,
+                        ) {
                             if let Some(ref handler) = self.dispatch_error_handler {
                                 handler(context, message, error);
                             }
diff --git a/src/gateway/shard.rs b/src/gateway/shard.rs
index af7d5d1..e9f1642 100644
--- a/src/gateway/shard.rs
+++ b/src/gateway/shard.rs
@@ -362,18 +362,22 @@ impl Shard {
 
                 // Received seq is off -- attempt to resume.
                 if s > self.seq + 1 {
-                    info!("[Shard {:?}] Received off sequence (them: {}; us: {}); resuming",
-                          self.shard_info,
-                          s,
-                          self.seq);
+                    info!(
+                        "[Shard {:?}] Received off sequence (them: {}; us: {}); resuming",
+                        self.shard_info,
+                        s,
+                        self.seq
+                    );
 
                     if self.stage == ConnectionStage::Handshake {
                         self.stage = ConnectionStage::Identifying;
 
                         self.identify()?;
                     } else {
-                        warn!("[Shard {:?}] Heartbeat during non-Handshake; auto-reconnecting",
-                              self.shard_info);
+                        warn!(
+                            "[Shard {:?}] Heartbeat during non-Handshake; auto-reconnecting",
+                            self.shard_info
+                        );
 
                         return self.autoreconnect().and(Ok(None));
                     }
@@ -548,10 +552,12 @@ impl Shard {
     /// connection.
     pub fn shutdown_clean(&mut self) -> Result<()> {
         {
-            let message = OwnedMessage::Close(Some(CloseData {
-                                                       status_code: 1000,
-                                                       reason: String::new(),
-                                                   }));
+            let data = CloseData {
+                status_code: 1000,
+                reason: String::new(),
+            };
+
+            let message = OwnedMessage::Close(Some(data));
 
             self.client.send_message(&message)?;
         }
@@ -680,7 +686,9 @@ impl Shard {
         cache
             .guilds
             .keys()
-            .filter(|guild_id| utils::shard_id(guild_id.0, shard_count) == shard_id)
+            .filter(|guild_id| {
+                utils::shard_id(guild_id.0, shard_count) == shard_id
+            })
             .count() as u16
     }
 
@@ -729,10 +737,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);
diff --git a/src/http/mod.rs b/src/http/mod.rs
index fcf2331..0efea78 100644
--- a/src/http/mod.rs
+++ b/src/http/mod.rs
@@ -89,12 +89,16 @@ pub fn set_token(token: &str) { TOKEN.lock().unwrap().clone_from(&token.to_owned
 /// [`Group::add_recipient`]: ../model/struct.Group.html#method.add_recipient
 /// [`User`]: ../model/struct.User.html
 pub fn add_group_recipient(group_id: u64, user_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::None,
-                    put,
-                    "/channels/{}/recipients/{}",
-                    group_id,
-                    user_id))
+    verify(
+        204,
+        request!(
+            Route::None,
+            put,
+            "/channels/{}/recipients/{}",
+            group_id,
+            user_id
+        ),
+    )
 }
 
 /// Adds a single [`Role`] to a [`Member`] in a [`Guild`].
@@ -107,13 +111,17 @@ pub fn add_group_recipient(group_id: u64, user_id: u64) -> Result<()> {
 /// [`Role`]: ../model/struct.Role.html
 /// [Manage Roles]: ../model/permissions/constant.MANAGE_ROLES.html
 pub fn add_member_role(guild_id: u64, user_id: u64, role_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdMembersIdRolesId(guild_id),
-                    put,
-                    "/guilds/{}/members/{}/roles/{}",
-                    guild_id,
-                    user_id,
-                    role_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdMembersIdRolesId(guild_id),
+            put,
+            "/guilds/{}/members/{}/roles/{}",
+            guild_id,
+            user_id,
+            role_id
+        ),
+    )
 }
 
 /// Bans a [`User`] from a [`Guild`], removing their messages sent in the last
@@ -128,14 +136,18 @@ pub fn add_member_role(guild_id: u64, user_id: u64, role_id: u64) -> Result<()>
 /// [`User`]: ../model/struct.User.html
 /// [Ban Members]: ../model/permissions/constant.BAN_MEMBERS.html
 pub fn ban_user(guild_id: u64, user_id: u64, delete_message_days: u8, reason: &str) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdBansUserId(guild_id),
-                    put,
-                    "/guilds/{}/bans/{}?delete_message_days={}&reason={}",
-                    guild_id,
-                    user_id,
-                    delete_message_days,
-                    reason))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdBansUserId(guild_id),
+            put,
+            "/guilds/{}/bans/{}?delete_message_days={}&reason={}",
+            guild_id,
+            user_id,
+            delete_message_days,
+            reason
+        ),
+    )
 }
 
 /// Broadcasts that the current user is typing in the given [`Channel`].
@@ -148,11 +160,15 @@ pub fn ban_user(guild_id: u64, user_id: u64, delete_message_days: u8, reason: &s
 ///
 /// [`Channel`]: ../model/enum.Channel.html
 pub fn broadcast_typing(channel_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdTyping(channel_id),
-                    post,
-                    "/channels/{}/typing",
-                    channel_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdTyping(channel_id),
+            post,
+            "/channels/{}/typing",
+            channel_id
+        ),
+    )
 }
 
 /// Creates a [`GuildChannel`] in the [`Guild`] given its Id.
@@ -167,12 +183,15 @@ pub fn broadcast_typing(channel_id: u64) -> Result<()> {
 /// [Manage Channels]: ../model/permissions/constant.MANAGE_CHANNELS.html
 pub fn create_channel(guild_id: u64, map: &Value) -> Result<GuildChannel> {
     let body = map.to_string();
-    let response = request!(Route::GuildsIdChannels(guild_id),
-                            post(body),
-                            "/guilds/{}/channels",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, GuildChannel>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdChannels(guild_id),
+        post(body),
+        "/guilds/{}/channels",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, GuildChannel>(response)
+        .map_err(From::from)
 }
 
 /// Creates an emoji in the given [`Guild`] with the given data.
@@ -187,12 +206,15 @@ pub fn create_channel(guild_id: u64, map: &Value) -> Result<GuildChannel> {
 /// [Manage Emojis]: ../model/permissions/constant.MANAGE_EMOJIS.html
 pub fn create_emoji(guild_id: u64, map: &Value) -> Result<Emoji> {
     let body = map.to_string();
-    let response = request!(Route::GuildsIdEmojis(guild_id),
-                            post(body),
-                            "/guilds/{}/emojis",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Emoji>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdEmojis(guild_id),
+        post(body),
+        "/guilds/{}/emojis",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Emoji>(response)
+        .map_err(From::from)
 }
 
 /// Creates a guild with the data provided.
@@ -235,7 +257,8 @@ pub fn create_guild(map: &Value) -> Result<PartialGuild> {
     let body = map.to_string();
     let response = request!(Route::Guilds, post(body), "/guilds");
 
-    serde_json::from_reader::<HyperResponse, PartialGuild>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, PartialGuild>(response)
+        .map_err(From::from)
 }
 
 /// Creates an [`Integration`] for a [`Guild`].
@@ -251,12 +274,16 @@ pub fn create_guild(map: &Value) -> Result<PartialGuild> {
 pub fn create_guild_integration(guild_id: u64, integration_id: u64, map: &Value) -> Result<()> {
     let body = map.to_string();
 
-    verify(204,
-           request!(Route::GuildsIdIntegrations(guild_id),
-                    post(body),
-                    "/guilds/{}/integrations/{}",
-                    guild_id,
-                    integration_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdIntegrations(guild_id),
+            post(body),
+            "/guilds/{}/integrations/{}",
+            guild_id,
+            integration_id
+        ),
+    )
 }
 
 /// Creates a [`RichInvite`] for the given [channel][`GuildChannel`].
@@ -273,24 +300,31 @@ pub fn create_guild_integration(guild_id: u64, integration_id: u64, map: &Value)
 /// [docs]: https://discordapp.com/developers/docs/resources/channel#create-channel-invite
 pub fn create_invite(channel_id: u64, map: &JsonMap) -> Result<RichInvite> {
     let body = serde_json::to_string(map)?;
-    let response = request!(Route::ChannelsIdInvites(channel_id),
-                            post(body),
-                            "/channels/{}/invites",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, RichInvite>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsIdInvites(channel_id),
+        post(body),
+        "/channels/{}/invites",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, RichInvite>(response)
+        .map_err(From::from)
 }
 
 /// Creates a permission override for a member or a role in a channel.
 pub fn create_permission(channel_id: u64, target_id: u64, map: &Value) -> Result<()> {
     let body = map.to_string();
 
-    verify(204,
-           request!(Route::ChannelsIdPermissionsOverwriteId(channel_id),
-                    put(body),
-                    "/channels/{}/permissions/{}",
-                    channel_id,
-                    target_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdPermissionsOverwriteId(channel_id),
+            put(body),
+            "/channels/{}/permissions/{}",
+            channel_id,
+            target_id
+        ),
+    )
 }
 
 /// Creates a private channel with a user.
@@ -298,7 +332,8 @@ pub fn create_private_channel(map: &Value) -> Result<PrivateChannel> {
     let body = map.to_string();
     let response = request!(Route::UsersMeChannels, post(body), "/users/@me/channels");
 
-    serde_json::from_reader::<HyperResponse, PrivateChannel>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, PrivateChannel>(response)
+        .map_err(From::from)
 }
 
 /// Reacts to a message.
@@ -306,24 +341,31 @@ pub fn create_reaction(channel_id: u64,
                        message_id: u64,
                        reaction_type: &ReactionType)
                        -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdMessagesIdReactionsUserIdType(channel_id),
-                    put,
-                    "/channels/{}/messages/{}/reactions/{}/@me",
-                    channel_id,
-                    message_id,
-                    reaction_type.as_data()))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdMessagesIdReactionsUserIdType(channel_id),
+            put,
+            "/channels/{}/messages/{}/reactions/{}/@me",
+            channel_id,
+            message_id,
+            reaction_type.as_data()
+        ),
+    )
 }
 
 /// Creates a role.
 pub fn create_role(guild_id: u64, map: &JsonMap) -> Result<Role> {
     let body = serde_json::to_string(map)?;
-    let response = request!(Route::GuildsIdRoles(guild_id),
-                            post(body),
-                            "/guilds/{}/roles",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Role>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdRoles(guild_id),
+        post(body),
+        "/guilds/{}/roles",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Role>(response)
+        .map_err(From::from)
 }
 
 /// Creates a webhook for the given [channel][`GuildChannel`]'s Id, passing in
@@ -358,78 +400,102 @@ pub fn create_role(guild_id: u64, map: &JsonMap) -> Result<Role> {
 /// [`GuildChannel`]: ../model/struct.GuildChannel.html
 pub fn create_webhook(channel_id: u64, map: &Value) -> Result<Webhook> {
     let body = map.to_string();
-    let response = request!(Route::ChannelsIdWebhooks(channel_id),
-                            post(body),
-                            "/channels/{}/webhooks",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, Webhook>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsIdWebhooks(channel_id),
+        post(body),
+        "/channels/{}/webhooks",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Webhook>(response)
+        .map_err(From::from)
 }
 
 /// Deletes a private channel or a channel in a guild.
 pub fn delete_channel(channel_id: u64) -> Result<Channel> {
-    let response = request!(Route::ChannelsId(channel_id),
-                            delete,
-                            "/channels/{}",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, Channel>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsId(channel_id),
+        delete,
+        "/channels/{}",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Channel>(response)
+        .map_err(From::from)
 }
 
 /// Deletes an emoji from a server.
 pub fn delete_emoji(guild_id: u64, emoji_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdEmojisId(guild_id),
-                    delete,
-                    "/guilds/{}/emojis/{}",
-                    guild_id,
-                    emoji_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdEmojisId(guild_id),
+            delete,
+            "/guilds/{}/emojis/{}",
+            guild_id,
+            emoji_id
+        ),
+    )
 }
 
 /// Deletes a guild, only if connected account owns it.
 pub fn delete_guild(guild_id: u64) -> Result<PartialGuild> {
     let response = request!(Route::GuildsId(guild_id), delete, "/guilds/{}", guild_id);
 
-    serde_json::from_reader::<HyperResponse, PartialGuild>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, PartialGuild>(response)
+        .map_err(From::from)
 }
 
 /// Remvoes an integration from a guild.
 pub fn delete_guild_integration(guild_id: u64, integration_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdIntegrationsId(guild_id),
-                    delete,
-                    "/guilds/{}/integrations/{}",
-                    guild_id,
-                    integration_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdIntegrationsId(guild_id),
+            delete,
+            "/guilds/{}/integrations/{}",
+            guild_id,
+            integration_id
+        ),
+    )
 }
 
 /// Deletes an invite by code.
 pub fn delete_invite(code: &str) -> Result<Invite> {
     let response = request!(Route::InvitesCode, delete, "/invites/{}", code);
 
-    serde_json::from_reader::<HyperResponse, Invite>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Invite>(response)
+        .map_err(From::from)
 }
 
 /// Deletes a message if created by us or we have
 /// specific permissions.
 pub fn delete_message(channel_id: u64, message_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdMessagesId(LightMethod::Delete, channel_id),
-                    delete,
-                    "/channels/{}/messages/{}",
-                    channel_id,
-                    message_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdMessagesId(LightMethod::Delete, channel_id),
+            delete,
+            "/channels/{}/messages/{}",
+            channel_id,
+            message_id
+        ),
+    )
 }
 
 /// Deletes a bunch of messages, only works for bots.
 pub fn delete_messages(channel_id: u64, map: &Value) -> Result<()> {
     let body = map.to_string();
 
-    verify(204,
-           request!(Route::ChannelsIdMessagesBulkDelete(channel_id),
-                    post(body),
-                    "/channels/{}/messages/bulk_delete",
-                    channel_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdMessagesBulkDelete(channel_id),
+            post(body),
+            "/channels/{}/messages/bulk_delete",
+            channel_id
+        ),
+    )
 }
 
 /// Deletes all of the [`Reaction`]s associated with a [`Message`].
@@ -450,22 +516,30 @@ pub fn delete_messages(channel_id: u64, map: &Value) -> Result<()> {
 /// [`Message`]: ../model/struct.Message.html
 /// [`Reaction`]: ../model/struct.Reaction.html
 pub fn delete_message_reactions(channel_id: u64, message_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdMessagesIdReactions(channel_id),
-                    delete,
-                    "/channels/{}/messages/{}/reactions",
-                    channel_id,
-                    message_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdMessagesIdReactions(channel_id),
+            delete,
+            "/channels/{}/messages/{}/reactions",
+            channel_id,
+            message_id
+        ),
+    )
 }
 
 /// Deletes a permission override from a role or a member in a channel.
 pub fn delete_permission(channel_id: u64, target_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdPermissionsOverwriteId(channel_id),
-                    delete,
-                    "/channels/{}/permissions/{}",
-                    channel_id,
-                    target_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdPermissionsOverwriteId(channel_id),
+            delete,
+            "/channels/{}/permissions/{}",
+            channel_id,
+            target_id
+        ),
+    )
 }
 
 /// Deletes a reaction from a message if owned by us or
@@ -479,24 +553,32 @@ pub fn delete_reaction(channel_id: u64,
         .map(|uid| uid.to_string())
         .unwrap_or_else(|| "@me".to_string());
 
-    verify(204,
-           request!(Route::ChannelsIdMessagesIdReactionsUserIdType(channel_id),
-                    delete,
-                    "/channels/{}/messages/{}/reactions/{}/{}",
-                    channel_id,
-                    message_id,
-                    reaction_type.as_data(),
-                    user))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdMessagesIdReactionsUserIdType(channel_id),
+            delete,
+            "/channels/{}/messages/{}/reactions/{}/{}",
+            channel_id,
+            message_id,
+            reaction_type.as_data(),
+            user
+        ),
+    )
 }
 
 /// Deletes a role from a server. Can't remove the default everyone role.
 pub fn delete_role(guild_id: u64, role_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdRolesId(guild_id),
-                    delete,
-                    "/guilds/{}/roles/{}",
-                    guild_id,
-                    role_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdRolesId(guild_id),
+            delete,
+            "/guilds/{}/roles/{}",
+            guild_id,
+            role_id
+        ),
+    )
 }
 
 /// Deletes a [`Webhook`] given its Id.
@@ -522,8 +604,10 @@ pub fn delete_role(guild_id: u64, role_id: u64) -> Result<()> {
 /// [`Webhook`]: ../model/struct.Webhook.html
 /// [`delete_webhook_with_token`]: fn.delete_webhook_with_token.html
 pub fn delete_webhook(webhook_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::WebhooksId, delete, "/webhooks/{}", webhook_id))
+    verify(
+        204,
+        request!(Route::WebhooksId, delete, "/webhooks/{}", webhook_id),
+    )
 }
 
 /// Deletes a [`Webhook`] given its Id and unique token.
@@ -547,43 +631,56 @@ pub fn delete_webhook(webhook_id: u64) -> Result<()> {
 pub fn delete_webhook_with_token(webhook_id: u64, token: &str) -> Result<()> {
     let client = request_client!();
 
-    verify(204,
-           retry(|| client.delete(&format!(api!("/webhooks/{}/{}"), webhook_id, token)))
-               .map_err(Error::Hyper)?)
+    verify(
+        204,
+        retry(|| {
+            client
+                .delete(&format!(api!("/webhooks/{}/{}"), webhook_id, token))
+        }).map_err(Error::Hyper)?,
+    )
 }
 
 /// Changes channel information.
 pub fn edit_channel(channel_id: u64, map: &JsonMap) -> Result<GuildChannel> {
     let body = serde_json::to_string(map)?;
-    let response = request!(Route::ChannelsId(channel_id),
-                            patch(body),
-                            "/channels/{}",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, GuildChannel>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsId(channel_id),
+        patch(body),
+        "/channels/{}",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, GuildChannel>(response)
+        .map_err(From::from)
 }
 
 /// Changes emoji information.
 pub fn edit_emoji(guild_id: u64, emoji_id: u64, map: &Value) -> Result<Emoji> {
     let body = map.to_string();
-    let response = request!(Route::GuildsIdEmojisId(guild_id),
-                            patch(body),
-                            "/guilds/{}/emojis/{}",
-                            guild_id,
-                            emoji_id);
-
-    serde_json::from_reader::<HyperResponse, Emoji>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdEmojisId(guild_id),
+        patch(body),
+        "/guilds/{}/emojis/{}",
+        guild_id,
+        emoji_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Emoji>(response)
+        .map_err(From::from)
 }
 
 /// Changes guild information.
 pub fn edit_guild(guild_id: u64, map: &JsonMap) -> Result<PartialGuild> {
     let body = serde_json::to_string(map)?;
-    let response = request!(Route::GuildsId(guild_id),
-                            patch(body),
-                            "/guilds/{}",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, PartialGuild>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsId(guild_id),
+        patch(body),
+        "/guilds/{}",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, PartialGuild>(response)
+        .map_err(From::from)
 }
 
 /// Edits a [`Guild`]'s embed setting.
@@ -591,24 +688,31 @@ pub fn edit_guild(guild_id: u64, map: &JsonMap) -> Result<PartialGuild> {
 /// [`Guild`]: ../model/struct.Guild.html
 pub fn edit_guild_embed(guild_id: u64, map: &Value) -> Result<GuildEmbed> {
     let body = map.to_string();
-    let response = request!(Route::GuildsIdEmbed(guild_id),
-                            patch(body),
-                            "/guilds/{}/embed",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, GuildEmbed>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdEmbed(guild_id),
+        patch(body),
+        "/guilds/{}/embed",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, GuildEmbed>(response)
+        .map_err(From::from)
 }
 
 /// Does specific actions to a member.
 pub fn edit_member(guild_id: u64, user_id: u64, map: &JsonMap) -> Result<()> {
     let body = serde_json::to_string(map)?;
 
-    verify(204,
-           request!(Route::GuildsIdMembersId(guild_id),
-                    patch(body),
-                    "/guilds/{}/members/{}",
-                    guild_id,
-                    user_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdMembersId(guild_id),
+            patch(body),
+            "/guilds/{}/members/{}",
+            guild_id,
+            user_id
+        ),
+    )
 }
 
 /// Edits a message by Id.
@@ -616,13 +720,16 @@ pub fn edit_member(guild_id: u64, user_id: u64, map: &JsonMap) -> Result<()> {
 /// **Note**: Only the author of a message can modify it.
 pub fn edit_message(channel_id: u64, message_id: u64, map: &Value) -> Result<Message> {
     let body = map.to_string();
-    let response = request!(Route::ChannelsIdMessagesId(LightMethod::Any, channel_id),
-                            patch(body),
-                            "/channels/{}/messages/{}",
-                            channel_id,
-                            message_id);
+    let response = request!(
+        Route::ChannelsIdMessagesId(LightMethod::Any, channel_id),
+        patch(body),
+        "/channels/{}/messages/{}",
+        channel_id,
+        message_id
+    );
 
-    serde_json::from_reader::<HyperResponse, Message>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Message>(response)
+        .map_err(From::from)
 }
 
 /// Edits the current user's nickname for the provided [`Guild`] via its Id.
@@ -633,10 +740,12 @@ pub fn edit_message(channel_id: u64, message_id: u64, map: &Value) -> Result<Mes
 pub fn edit_nickname(guild_id: u64, new_nickname: Option<&str>) -> Result<()> {
     let map = json!({ "nick": new_nickname });
     let body = map.to_string();
-    let response = request!(Route::GuildsIdMembersMeNick(guild_id),
-                            patch(body),
-                            "/guilds/{}/members/@me/nick",
-                            guild_id);
+    let response = request!(
+        Route::GuildsIdMembersMeNick(guild_id),
+        patch(body),
+        "/guilds/{}/members/@me/nick",
+        guild_id
+    );
 
     verify(200, response)
 }
@@ -667,19 +776,23 @@ 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.
 pub fn edit_role(guild_id: u64, role_id: u64, map: &JsonMap) -> Result<Role> {
     let body = serde_json::to_string(map)?;
-    let response = request!(Route::GuildsIdRolesId(guild_id),
-                            patch(body),
-                            "/guilds/{}/roles/{}",
-                            guild_id,
-                            role_id);
-
-    serde_json::from_reader::<HyperResponse, Role>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdRolesId(guild_id),
+        patch(body),
+        "/guilds/{}/roles/{}",
+        guild_id,
+        role_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Role>(response)
+        .map_err(From::from)
 }
 
 /// Edits a the webhook with the given data.
@@ -725,7 +838,8 @@ pub fn edit_webhook(webhook_id: u64, map: &Value) -> Result<Webhook> {
     let body = map.to_string();
     let response = request!(Route::WebhooksId, patch(body), "/webhooks/{}", webhook_id);
 
-    serde_json::from_reader::<HyperResponse, Webhook>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Webhook>(response)
+        .map_err(From::from)
 }
 
 /// Edits the webhook with the given data.
@@ -764,7 +878,8 @@ pub fn edit_webhook_with_token(webhook_id: u64, token: &str, map: &JsonMap) -> R
             .body(&body)
     }).map_err(Error::Hyper)?;
 
-    serde_json::from_reader::<HyperResponse, Webhook>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Webhook>(response)
+        .map_err(From::from)
 }
 
 /// Executes a webhook, posting a [`Message`] in the webhook's associated
@@ -838,9 +953,16 @@ pub fn execute_webhook(webhook_id: u64,
 
     let response = retry(|| {
         client
-            .post(&format!(api!("/webhooks/{}/{}?wait={}"), webhook_id, token, wait))
+            .post(&format!(
+                api!("/webhooks/{}/{}?wait={}"),
+                webhook_id,
+                token,
+                wait
+            ))
             .body(&body)
-            .header(ContentType(Mime(TopLevel::Application, SubLevel::Json, vec![])))
+            .header(ContentType(
+                Mime(TopLevel::Application, SubLevel::Json, vec![]),
+            ))
     }).map_err(Error::Hyper)?;
 
     if response.status == StatusCode::NoContent {
@@ -858,12 +980,15 @@ pub fn execute_webhook(webhook_id: u64,
 pub fn get_active_maintenances() -> Result<Vec<Maintenance>> {
     let client = request_client!();
 
-    let response = retry(|| client.get(status!("/scheduled-maintenances/active.json")))?;
+    let response = retry(|| {
+        client.get(status!("/scheduled-maintenances/active.json"))
+    })?;
 
     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![]),
     }
 }
@@ -874,7 +999,8 @@ pub fn get_active_maintenances() -> Result<Vec<Maintenance>> {
 pub fn get_application_info(id: u64) -> Result<ApplicationInfo> {
     let response = request!(Route::None, get, "/oauth2/applications/{}", id);
 
-    serde_json::from_reader::<HyperResponse, ApplicationInfo>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, ApplicationInfo>(response)
+        .map_err(From::from)
 }
 
 /// Gets all oauth2 applications we've made.
@@ -883,44 +1009,55 @@ pub fn get_application_info(id: u64) -> Result<ApplicationInfo> {
 pub fn get_applications() -> Result<Vec<ApplicationInfo>> {
     let response = request!(Route::None, get, "/oauth2/applications");
 
-    serde_json::from_reader::<HyperResponse, Vec<ApplicationInfo>>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Vec<ApplicationInfo>>(response)
+        .map_err(From::from)
 }
 
 /// Gets all the users that are banned in specific guild.
 pub fn get_bans(guild_id: u64) -> Result<Vec<Ban>> {
-    let response = request!(Route::GuildsIdBans(guild_id),
-                            get,
-                            "/guilds/{}/bans",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Ban>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdBans(guild_id),
+        get,
+        "/guilds/{}/bans",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Ban>>(response)
+        .map_err(From::from)
 }
 
 /// Gets all audit logs in a specific guild.
 pub fn get_audit_logs(guild_id: u64) -> Result<AuditLogs> {
-    let response = request!(Route::GuildsIdAuditLogs(guild_id),
-                            get,
-                            "/guilds/{}/audit-logs",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, AuditLogs>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdAuditLogs(guild_id),
+        get,
+        "/guilds/{}/audit-logs",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, AuditLogs>(response)
+        .map_err(From::from)
 }
 
 /// Gets current bot gateway.
 pub fn get_bot_gateway() -> Result<BotGateway> {
     let response = request!(Route::GatewayBot, get, "/gateway/bot");
 
-    serde_json::from_reader::<HyperResponse, BotGateway>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, BotGateway>(response)
+        .map_err(From::from)
 }
 
 /// Gets all invites for a channel.
 pub fn get_channel_invites(channel_id: u64) -> Result<Vec<RichInvite>> {
-    let response = request!(Route::ChannelsIdInvites(channel_id),
-                            get,
-                            "/channels/{}/invites",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<RichInvite>>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsIdInvites(channel_id),
+        get,
+        "/channels/{}/invites",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<RichInvite>>(response)
+        .map_err(From::from)
 }
 
 /// Retrieves the webhooks for the given [channel][`GuildChannel`]'s Id.
@@ -942,32 +1079,41 @@ pub fn get_channel_invites(channel_id: u64) -> Result<Vec<RichInvite>> {
 ///
 /// [`GuildChannel`]: ../model/struct.GuildChannel.html
 pub fn get_channel_webhooks(channel_id: u64) -> Result<Vec<Webhook>> {
-    let response = request!(Route::ChannelsIdWebhooks(channel_id),
-                            get,
-                            "/channels/{}/webhooks",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Webhook>>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsIdWebhooks(channel_id),
+        get,
+        "/channels/{}/webhooks",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Webhook>>(response)
+        .map_err(From::from)
 }
 
 /// Gets channel information.
 pub fn get_channel(channel_id: u64) -> Result<Channel> {
-    let response = request!(Route::ChannelsId(channel_id),
-                            get,
-                            "/channels/{}",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, Channel>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsId(channel_id),
+        get,
+        "/channels/{}",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Channel>(response)
+        .map_err(From::from)
 }
 
 /// Gets all channels in a guild.
 pub fn get_channels(guild_id: u64) -> Result<Vec<GuildChannel>> {
-    let response = request!(Route::ChannelsId(guild_id),
-                            get,
-                            "/guilds/{}/channels",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<GuildChannel>>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsId(guild_id),
+        get,
+        "/guilds/{}/channels",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<GuildChannel>>(response)
+        .map_err(From::from)
 }
 
 /// Gets information about the current application.
@@ -976,79 +1122,98 @@ pub fn get_channels(guild_id: u64) -> Result<Vec<GuildChannel>> {
 pub fn get_current_application_info() -> Result<CurrentApplicationInfo> {
     let response = request!(Route::None, get, "/oauth2/applications/@me");
 
-    serde_json::from_reader::<HyperResponse, CurrentApplicationInfo>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, CurrentApplicationInfo>(response)
+        .map_err(From::from)
 }
 
 /// Gets information about the user we're connected with.
 pub fn get_current_user() -> Result<CurrentUser> {
     let response = request!(Route::UsersMe, get, "/users/@me");
 
-    serde_json::from_reader::<HyperResponse, CurrentUser>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, CurrentUser>(response)
+        .map_err(From::from)
 }
 
 /// Gets current gateway.
 pub fn get_gateway() -> Result<Gateway> {
     let response = request!(Route::Gateway, get, "/gateway");
 
-    serde_json::from_reader::<HyperResponse, Gateway>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Gateway>(response)
+        .map_err(From::from)
 }
 
 /// Gets information about an emoji.
 pub fn get_emoji(guild_id: u64, emoji_id: u64) -> Result<Emoji> {
-    let response = request!(Route::GuildsIdEmojisId(guild_id),
-                            get,
-                            "/guilds/{}/emojis/{}",
-                            guild_id,
-                            emoji_id);
-
-    serde_json::from_reader::<HyperResponse, Emoji>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdEmojisId(guild_id),
+        get,
+        "/guilds/{}/emojis/{}",
+        guild_id,
+        emoji_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Emoji>(response)
+        .map_err(From::from)
 }
 
 /// Gets all emojis in a guild.
 pub fn get_emojis(guild_id: u64) -> Result<Vec<Emoji>> {
-    let response = request!(Route::GuildsIdEmojis(guild_id),
-                            get,
-                            "/guilds/{}/emojis",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Emoji>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdEmojis(guild_id),
+        get,
+        "/guilds/{}/emojis",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Emoji>>(response)
+        .map_err(From::from)
 }
 
 /// Gets guild information.
 pub fn get_guild(guild_id: u64) -> Result<PartialGuild> {
     let response = request!(Route::GuildsId(guild_id), get, "/guilds/{}", guild_id);
 
-    serde_json::from_reader::<HyperResponse, PartialGuild>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, PartialGuild>(response)
+        .map_err(From::from)
 }
 
 /// Gets a guild embed information.
 pub fn get_guild_embed(guild_id: u64) -> Result<GuildEmbed> {
-    let response = request!(Route::GuildsIdEmbed(guild_id),
-                            get,
-                            "/guilds/{}/embeds",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, GuildEmbed>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdEmbed(guild_id),
+        get,
+        "/guilds/{}/embeds",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, GuildEmbed>(response)
+        .map_err(From::from)
 }
 
 /// Gets integrations that a guild has.
 pub fn get_guild_integrations(guild_id: u64) -> Result<Vec<Integration>> {
-    let response = request!(Route::GuildsIdIntegrations(guild_id),
-                            get,
-                            "/guilds/{}/integrations",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Integration>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdIntegrations(guild_id),
+        get,
+        "/guilds/{}/integrations",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Integration>>(response)
+        .map_err(From::from)
 }
 
 /// Gets all invites to a guild.
 pub fn get_guild_invites(guild_id: u64) -> Result<Vec<RichInvite>> {
-    let response = request!(Route::GuildsIdInvites(guild_id),
-                            get,
-                            "/guilds/{}/invites",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<RichInvite>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdInvites(guild_id),
+        get,
+        "/guilds/{}/invites",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<RichInvite>>(response)
+        .map_err(From::from)
 }
 
 /// Gets the members of a guild. Optionally pass a `limit` and the Id of the
@@ -1057,12 +1222,14 @@ pub fn get_guild_members(guild_id: u64,
                          limit: Option<u64>,
                          after: Option<u64>)
                          -> Result<Vec<Member>> {
-    let response = request!(Route::GuildsIdMembers(guild_id),
-                            get,
-                            "/guilds/{}/members?limit={}&after={}",
-                            guild_id,
-                            limit.unwrap_or(500),
-                            after.unwrap_or(0));
+    let response = request!(
+        Route::GuildsIdMembers(guild_id),
+        get,
+        "/guilds/{}/members?limit={}&after={}",
+        guild_id,
+        limit.unwrap_or(500),
+        after.unwrap_or(0)
+    );
 
     let mut v = serde_json::from_reader::<HyperResponse, Value>(response)?;
 
@@ -1082,12 +1249,15 @@ pub fn get_guild_members(guild_id: u64,
 /// Gets the amount of users that can be pruned.
 pub fn get_guild_prune_count(guild_id: u64, map: &Value) -> Result<GuildPrune> {
     let body = map.to_string();
-    let response = request!(Route::GuildsIdPrune(guild_id),
-                            get(body),
-                            "/guilds/{}/prune",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, GuildPrune>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdPrune(guild_id),
+        get(body),
+        "/guilds/{}/prune",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, GuildPrune>(response)
+        .map_err(From::from)
 }
 
 /// Gets regions that a guild can use. If a guild has [`Feature::VipRegions`]
@@ -1095,24 +1265,30 @@ pub fn get_guild_prune_count(guild_id: u64, map: &Value) -> Result<GuildPrune> {
 ///
 /// [`Feature::VipRegions`]: ../model/enum.Feature.html#variant.VipRegions
 pub fn get_guild_regions(guild_id: u64) -> Result<Vec<VoiceRegion>> {
-    let response = request!(Route::GuildsIdRegions(guild_id),
-                            get,
-                            "/guilds/{}/regions",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<VoiceRegion>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdRegions(guild_id),
+        get,
+        "/guilds/{}/regions",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<VoiceRegion>>(response)
+        .map_err(From::from)
 }
 
 /// Retrieves a list of roles in a [`Guild`].
 ///
 /// [`Guild`]: ../model/struct.Guild.html
 pub fn get_guild_roles(guild_id: u64) -> Result<Vec<Role>> {
-    let response = request!(Route::GuildsIdRoles(guild_id),
-                            get,
-                            "/guilds/{}/roles",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Role>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdRoles(guild_id),
+        get,
+        "/guilds/{}/roles",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Role>>(response)
+        .map_err(From::from)
 }
 
 /// Retrieves the webhooks for the given [guild][`Guild`]'s Id.
@@ -1134,12 +1310,15 @@ pub fn get_guild_roles(guild_id: u64) -> Result<Vec<Role>> {
 ///
 /// [`Guild`]: ../model/struct.Guild.html
 pub fn get_guild_webhooks(guild_id: u64) -> Result<Vec<Webhook>> {
-    let response = request!(Route::GuildsIdWebhooks(guild_id),
-                            get,
-                            "/guilds/{}/webhooks",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Webhook>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdWebhooks(guild_id),
+        get,
+        "/guilds/{}/webhooks",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Webhook>>(response)
+        .map_err(From::from)
 }
 
 /// Gets a paginated list of the current user's guilds.
@@ -1176,7 +1355,8 @@ pub fn get_guilds(target: &GuildPagination, limit: u64) -> Result<Vec<GuildInfo>
 
     let response = request!(Route::UsersMeGuilds, get, "{}", uri);
 
-    serde_json::from_reader::<HyperResponse, Vec<GuildInfo>>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Vec<GuildInfo>>(response)
+        .map_err(From::from)
 }
 
 /// Gets information about a specific invite.
@@ -1197,16 +1377,19 @@ pub fn get_invite(code: &str, stats: bool) -> Result<Invite> {
 
     let response = request!(Route::InvitesCode, get, "{}", uri);
 
-    serde_json::from_reader::<HyperResponse, Invite>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Invite>(response)
+        .map_err(From::from)
 }
 
 /// Gets member of a guild.
 pub fn get_member(guild_id: u64, user_id: u64) -> Result<Member> {
-    let response = request!(Route::GuildsIdMembersId(guild_id),
-                            get,
-                            "/guilds/{}/members/{}",
-                            guild_id,
-                            user_id);
+    let response = request!(
+        Route::GuildsIdMembersId(guild_id),
+        get,
+        "/guilds/{}/members/{}",
+        guild_id,
+        user_id
+    );
 
     let mut v = serde_json::from_reader::<HyperResponse, Value>(response)?;
 
@@ -1219,13 +1402,16 @@ pub fn get_member(guild_id: u64, user_id: u64) -> Result<Member> {
 
 /// Gets a message by an Id, bots only.
 pub fn get_message(channel_id: u64, message_id: u64) -> Result<Message> {
-    let response = request!(Route::ChannelsIdMessagesId(LightMethod::Any, channel_id),
-                            get,
-                            "/channels/{}/messages/{}",
-                            channel_id,
-                            message_id);
+    let response = request!(
+        Route::ChannelsIdMessagesId(LightMethod::Any, channel_id),
+        get,
+        "/channels/{}/messages/{}",
+        channel_id,
+        message_id
+    );
 
-    serde_json::from_reader::<HyperResponse, Message>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Message>(response)
+        .map_err(From::from)
 }
 
 /// Gets X messages from a channel.
@@ -1235,17 +1421,21 @@ pub fn get_messages(channel_id: u64, query: &str) -> Result<Vec<Message>> {
 
     let response = request(Route::ChannelsIdMessages(channel_id), || client.get(&url))?;
 
-    serde_json::from_reader::<HyperResponse, Vec<Message>>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Vec<Message>>(response)
+        .map_err(From::from)
 }
 
 /// Gets all pins of a channel.
 pub fn get_pins(channel_id: u64) -> Result<Vec<Message>> {
-    let response = request!(Route::ChannelsIdPins(channel_id),
-                            get,
-                            "/channels/{}/pins",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Message>>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsIdPins(channel_id),
+        get,
+        "/channels/{}/pins",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Message>>(response)
+        .map_err(From::from)
 }
 
 /// Gets user Ids based on their reaction to a message. This endpoint is dumb.
@@ -1255,22 +1445,27 @@ pub fn get_reaction_users(channel_id: u64,
                           limit: u8,
                           after: Option<u64>)
                           -> Result<Vec<User>> {
-    let mut uri = format!("/channels/{}/messages/{}/reactions/{}?limit={}",
-                          channel_id,
-                          message_id,
-                          reaction_type.as_data(),
-                          limit);
+    let mut uri = format!(
+        "/channels/{}/messages/{}/reactions/{}?limit={}",
+        channel_id,
+        message_id,
+        reaction_type.as_data(),
+        limit
+    );
 
     if let Some(user_id) = after {
         write!(uri, "&after={}", user_id)?;
     }
 
-    let response = request!(Route::ChannelsIdMessagesIdReactionsUserIdType(channel_id),
-                            get,
-                            "{}",
-                            uri);
+    let response = request!(
+        Route::ChannelsIdMessagesIdReactionsUserIdType(channel_id),
+        get,
+        "{}",
+        uri
+    );
 
-    serde_json::from_reader::<HyperResponse, Vec<User>>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Vec<User>>(response)
+        .map_err(From::from)
 }
 
 /// Gets the current unresolved incidents from Discord's Status API.
@@ -1284,7 +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![]),
     }
 }
@@ -1295,12 +1491,15 @@ pub fn get_unresolved_incidents() -> Result<Vec<Incident>> {
 pub fn get_upcoming_maintenances() -> Result<Vec<Maintenance>> {
     let client = request_client!();
 
-    let response = retry(|| client.get(status!("/scheduled-maintenances/upcoming.json")))?;
+    let response = retry(|| {
+        client.get(status!("/scheduled-maintenances/upcoming.json"))
+    })?;
 
     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![]),
     }
 }
@@ -1309,21 +1508,24 @@ pub fn get_upcoming_maintenances() -> Result<Vec<Maintenance>> {
 pub fn get_user(user_id: u64) -> Result<User> {
     let response = request!(Route::UsersId, get, "/users/{}", user_id);
 
-    serde_json::from_reader::<HyperResponse, User>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, User>(response)
+        .map_err(From::from)
 }
 
 /// Gets our DM channels.
 pub fn get_user_dm_channels() -> Result<Vec<PrivateChannel>> {
     let response = request!(Route::UsersMeChannels, get, "/users/@me/channels");
 
-    serde_json::from_reader::<HyperResponse, Vec<PrivateChannel>>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Vec<PrivateChannel>>(response)
+        .map_err(From::from)
 }
 
 /// Gets all voice regions.
 pub fn get_voice_regions() -> Result<Vec<VoiceRegion>> {
     let response = request!(Route::VoiceRegions, get, "/voice/regions");
 
-    serde_json::from_reader::<HyperResponse, Vec<VoiceRegion>>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Vec<VoiceRegion>>(response)
+        .map_err(From::from)
 }
 
 /// Retrieves a webhook given its Id.
@@ -1346,7 +1548,8 @@ pub fn get_voice_regions() -> Result<Vec<VoiceRegion>> {
 pub fn get_webhook(webhook_id: u64) -> Result<Webhook> {
     let response = request!(Route::WebhooksId, get, "/webhooks/{}", webhook_id);
 
-    serde_json::from_reader::<HyperResponse, Webhook>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Webhook>(response)
+        .map_err(From::from)
 }
 
 /// Retrieves a webhook given its Id and unique token.
@@ -1369,46 +1572,62 @@ pub fn get_webhook(webhook_id: u64) -> Result<Webhook> {
 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)))
-        .map_err(Error::Hyper)?;
+    let response = retry(|| {
+        client
+            .get(&format!(api!("/webhooks/{}/{}"), webhook_id, token))
+    }).map_err(Error::Hyper)?;
 
-    serde_json::from_reader::<HyperResponse, Webhook>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Webhook>(response)
+        .map_err(From::from)
 }
 
 /// Kicks a member from a guild.
 pub fn kick_member(guild_id: u64, user_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdMembersId(guild_id),
-                    delete,
-                    "/guilds/{}/members/{}",
-                    guild_id,
-                    user_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdMembersId(guild_id),
+            delete,
+            "/guilds/{}/members/{}",
+            guild_id,
+            user_id
+        ),
+    )
 }
 
 /// Leaves a group DM.
 pub fn leave_group(guild_id: u64) -> Result<Group> {
     let response = request!(Route::None, delete, "/channels/{}", guild_id);
 
-    serde_json::from_reader::<HyperResponse, Group>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Group>(response)
+        .map_err(From::from)
 }
 
 /// Leaves a guild.
 pub fn leave_guild(guild_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::UsersMeGuildsId,
-                    delete,
-                    "/users/@me/guilds/{}",
-                    guild_id))
+    verify(
+        204,
+        request!(
+            Route::UsersMeGuildsId,
+            delete,
+            "/users/@me/guilds/{}",
+            guild_id
+        ),
+    )
 }
 
 /// Deletes a user from group DM.
 pub fn remove_group_recipient(group_id: u64, user_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::None,
-                    delete,
-                    "/channels/{}/recipients/{}",
-                    group_id,
-                    user_id))
+    verify(
+        204,
+        request!(
+            Route::None,
+            delete,
+            "/channels/{}/recipients/{}",
+            group_id,
+            user_id
+        ),
+    )
 }
 
 /// Sends file(s) to a channel.
@@ -1421,8 +1640,7 @@ pub fn remove_group_recipient(group_id: u64, user_id: u64) -> Result<()> {
 ///
 /// [`HttpError::InvalidRequest`]: enum.HttpError.html#variant.InvalidRequest
 pub fn send_files<'a, T>(channel_id: u64, files: Vec<T>, map: JsonMap) -> Result<Message>
-where
-    T: Into<AttachmentType<'a>>, {
+    where T: Into<AttachmentType<'a>> {
     let uri = format!(api!("/channels/{}/messages"), channel_id);
     let url = match Url::parse(&uri) {
         Ok(url) => url,
@@ -1479,38 +1697,50 @@ where
         return Err(Error::Http(HttpError::InvalidRequest(response.status)));
     }
 
-    serde_json::from_reader::<HyperResponse, Message>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Message>(response)
+        .map_err(From::from)
 }
 
 /// Sends a message to a channel.
 pub fn send_message(channel_id: u64, map: &Value) -> Result<Message> {
     let body = map.to_string();
-    let response = request!(Route::ChannelsIdMessages(channel_id),
-                            post(body),
-                            "/channels/{}/messages",
-                            channel_id);
+    let response = request!(
+        Route::ChannelsIdMessages(channel_id),
+        post(body),
+        "/channels/{}/messages",
+        channel_id
+    );
 
-    serde_json::from_reader::<HyperResponse, Message>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Message>(response)
+        .map_err(From::from)
 }
 
 /// Pins a message in a channel.
 pub fn pin_message(channel_id: u64, message_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdPinsMessageId(channel_id),
-                    put,
-                    "/channels/{}/pins/{}",
-                    channel_id,
-                    message_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdPinsMessageId(channel_id),
+            put,
+            "/channels/{}/pins/{}",
+            channel_id,
+            message_id
+        ),
+    )
 }
 
 /// Unbans a user from a guild.
 pub fn remove_ban(guild_id: u64, user_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdBansUserId(guild_id),
-                    delete,
-                    "/guilds/{}/bans/{}",
-                    guild_id,
-                    user_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdBansUserId(guild_id),
+            delete,
+            "/guilds/{}/bans/{}",
+            guild_id,
+            user_id
+        ),
+    )
 }
 
 /// Deletes a single [`Role`] from a [`Member`] in a [`Guild`].
@@ -1523,49 +1753,63 @@ pub fn remove_ban(guild_id: u64, user_id: u64) -> Result<()> {
 /// [`Role`]: ../model/struct.Role.html
 /// [Manage Roles]: ../model/permissions/constant.MANAGE_ROLES.html
 pub fn remove_member_role(guild_id: u64, user_id: u64, role_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdMembersIdRolesId(guild_id),
-                    delete,
-                    "/guilds/{}/members/{}/roles/{}",
-                    guild_id,
-                    user_id,
-                    role_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdMembersIdRolesId(guild_id),
+            delete,
+            "/guilds/{}/members/{}/roles/{}",
+            guild_id,
+            user_id,
+            role_id
+        ),
+    )
 }
 
 /// Starts removing some members from a guild based on the last time they've been online.
 pub fn start_guild_prune(guild_id: u64, map: &Value) -> Result<GuildPrune> {
     let body = map.to_string();
-    let response = request!(Route::GuildsIdPrune(guild_id),
-                            post(body),
-                            "/guilds/{}/prune",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, GuildPrune>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdPrune(guild_id),
+        post(body),
+        "/guilds/{}/prune",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, GuildPrune>(response)
+        .map_err(From::from)
 }
 
 /// Starts syncing an integration with a guild.
 pub fn start_integration_sync(guild_id: u64, integration_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdIntegrationsIdSync(guild_id),
-                    post,
-                    "/guilds/{}/integrations/{}/sync",
-                    guild_id,
-                    integration_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdIntegrationsIdSync(guild_id),
+            post,
+            "/guilds/{}/integrations/{}/sync",
+            guild_id,
+            integration_id
+        ),
+    )
 }
 
 /// Unpins a message from a channel.
 pub fn unpin_message(channel_id: u64, message_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdPinsMessageId(channel_id),
-                    delete,
-                    "/channels/{}/pins/{}",
-                    channel_id,
-                    message_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdPinsMessageId(channel_id),
+            delete,
+            "/channels/{}/pins/{}",
+            channel_id,
+            message_id
+        ),
+    )
 }
 
 fn request<'a, F>(route: Route, f: F) -> Result<HyperResponse>
-where
-    F: Fn() -> RequestBuilder<'a>, {
+    where F: Fn() -> RequestBuilder<'a> {
     let response = ratelimiting::perform(route, || {
         f()
             .header(header::Authorization(TOKEN.lock().unwrap().clone()))
@@ -1580,8 +1824,7 @@ where
 }
 
 pub(crate) fn retry<'a, F>(f: F) -> HyperResult<HyperResponse>
-where
-    F: Fn() -> RequestBuilder<'a>, {
+    where F: Fn() -> RequestBuilder<'a> {
     let req = || {
         f()
             .header(header::UserAgent(constants::USER_AGENT.to_owned()))
diff --git a/src/http/ratelimiting.rs b/src/http/ratelimiting.rs
index 12066a9..f0eb8fc 100644
--- a/src/http/ratelimiting.rs
+++ b/src/http/ratelimiting.rs
@@ -346,8 +346,7 @@ pub enum Route {
 }
 
 pub(crate) fn perform<'a, F>(route: Route, f: F) -> Result<Response>
-where
-    F: Fn() -> RequestBuilder<'a>, {
+    where F: Fn() -> RequestBuilder<'a> {
     loop {
         // This will block if another thread already has the global
         // unlocked already (due to receiving an x-ratelimit-global).
@@ -367,10 +366,10 @@ where
             .entry(route)
             .or_insert_with(|| {
                 Arc::new(Mutex::new(RateLimit {
-                                        limit: i64::MAX,
-                                        remaining: i64::MAX,
-                                        reset: i64::MAX,
-                                    }))
+                    limit: i64::MAX,
+                    remaining: i64::MAX,
+                    reset: i64::MAX,
+                }))
             })
             .clone();
 
@@ -398,14 +397,15 @@ where
             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)
             };
@@ -462,9 +462,11 @@ impl RateLimit {
         if self.remaining == 0 {
             let delay = (diff * 1000) + 500;
 
-            debug!("Pre-emptive ratelimit on route {:?} for {:?}ms",
-                   route,
-                   delay);
+            debug!(
+                "Pre-emptive ratelimit on route {:?} for {:?}ms",
+                route,
+                delay
+            );
             thread::sleep(Duration::from_millis(delay));
 
             return;
@@ -487,30 +489,26 @@ impl RateLimit {
         }
 
         Ok(if response.status != StatusCode::TooManyRequests {
-               false
-           } else 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));
+            false
+        } else 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
+        })
     }
 }
 
 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/ws_impl.rs b/src/internal/ws_impl.rs
index 6166f2b..7aedb28 100644
--- a/src/internal/ws_impl.rs
+++ b/src/internal/ws_impl.rs
@@ -7,9 +7,7 @@ use gateway::GatewayError;
 use internal::prelude::*;
 
 pub trait ReceiverExt {
-    fn recv_json<F, T>(&mut self, decode: F) -> Result<T>
-    where
-        F: FnOnce(Value) -> Result<T>;
+    fn recv_json<F, T>(&mut self, decode: F) -> Result<T> where F: FnOnce(Value) -> Result<T>;
 }
 
 pub trait SenderExt {
@@ -18,8 +16,7 @@ pub trait SenderExt {
 
 impl ReceiverExt for WsClient<TlsStream<TcpStream>> {
     fn recv_json<F, T>(&mut self, decode: F) -> Result<T>
-    where
-        F: FnOnce(Value) -> Result<T>, {
+        where F: FnOnce(Value) -> Result<T> {
         let message = self.recv_message()?;
 
         if let OwnedMessage::Ping(ref x) = message {
diff --git a/src/model/channel/channel_id.rs b/src/model/channel/channel_id.rs
index 62d8820..4de9710 100644
--- a/src/model/channel/channel_id.rs
+++ b/src/model/channel/channel_id.rs
@@ -80,9 +80,7 @@ impl ChannelId {
     /// [Add Reactions]: permissions/constant.ADD_REACTIONS.html
     #[inline]
     pub fn create_reaction<M, R>(&self, message_id: M, reaction_type: R) -> Result<()>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>, {
+        where M: Into<MessageId>, R: Into<ReactionType> {
         http::create_reaction(self.0, message_id.into().0, &reaction_type.into())
     }
 
@@ -138,10 +136,13 @@ impl ChannelId {
     ///
     /// [Manage Channel]: permissions/constant.MANAGE_CHANNELS.html
     pub fn delete_permission(&self, permission_type: PermissionOverwriteType) -> Result<()> {
-        http::delete_permission(self.0, match permission_type {
-            PermissionOverwriteType::Member(id) => id.0,
-            PermissionOverwriteType::Role(id) => id.0,
-        })
+        http::delete_permission(
+            self.0,
+            match permission_type {
+                PermissionOverwriteType::Member(id) => id.0,
+                PermissionOverwriteType::Role(id) => id.0,
+            },
+        )
     }
 
     /// Deletes the given [`Reaction`] from the channel.
@@ -156,13 +157,13 @@ impl ChannelId {
                                  user_id: Option<UserId>,
                                  reaction_type: R)
                                  -> Result<()>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>, {
-        http::delete_reaction(self.0,
-                              message_id.into().0,
-                              user_id.map(|uid| uid.0),
-                              &reaction_type.into())
+        where M: Into<MessageId>, R: Into<ReactionType> {
+        http::delete_reaction(
+            self.0,
+            message_id.into().0,
+            user_id.map(|uid| uid.0),
+            &reaction_type.into(),
+        )
     }
 
 
@@ -209,9 +210,7 @@ impl ChannelId {
     /// [`Message`]: struct.Message.html
     /// [`the limit`]: ../builder/struct.CreateMessage.html#method.content
     pub fn edit_message<F, M>(&self, message_id: M, f: F) -> Result<Message>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage,
-        M: Into<MessageId>, {
+        where F: FnOnce(CreateMessage) -> CreateMessage, M: Into<MessageId> {
         let map = f(CreateMessage::default()).0;
 
         if let Some(content) = map.get("content") {
@@ -256,11 +255,13 @@ 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| {
-            msg.transform_content();
+        http::get_message(self.0, message_id.into().0).map(
+            |mut msg| {
+                msg.transform_content();
 
-            msg
-        })
+                msg
+            },
+        )
     }
 
     /// Gets messages from the channel.
@@ -272,8 +273,7 @@ impl ChannelId {
     /// [`Channel::messages`]: enum.Channel.html#method.messages
     /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
     pub fn messages<F>(&self, f: F) -> Result<Vec<Message>>
-    where
-        F: FnOnce(GetMessages) -> GetMessages, {
+        where F: FnOnce(GetMessages) -> GetMessages {
         let mut map = f(GetMessages::default()).0;
         let mut query = format!("?limit={}", map.remove("limit").unwrap_or(50));
 
@@ -302,18 +302,16 @@ impl ChannelId {
         use self::Channel::*;
 
         Some(match match self.find() {
-                       Some(c) => c,
-                       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,
-                     }
-                 },
-                 Private(channel) => channel.read().unwrap().name(),
-             })
+                  Some(c) => c,
+                  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,
+            },
+            Private(channel) => channel.read().unwrap().name(),
+        })
     }
 
     /// Pins a [`Message`] to the channel.
@@ -348,17 +346,16 @@ impl ChannelId {
                                    limit: Option<u8>,
                                    after: Option<U>)
                                    -> Result<Vec<User>>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>,
-        U: Into<UserId>, {
+        where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
         let limit = limit.map_or(50, |x| if x > 100 { 100 } else { x });
 
-        http::get_reaction_users(self.0,
-                                 message_id.into().0,
-                                 &reaction_type.into(),
-                                 limit,
-                                 after.map(|u| u.into().0))
+        http::get_reaction_users(
+            self.0,
+            message_id.into().0,
+            &reaction_type.into(),
+            limit,
+            after.map(|u| u.into().0),
+        )
     }
 
     /// Sends a message with just the given message content in the channel.
@@ -436,9 +433,7 @@ impl ChannelId {
     /// [Attach Files]: permissions/constant.ATTACH_FILES.html
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
     pub fn send_files<'a, F, T>(&self, files: Vec<T>, f: F) -> Result<Message>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage,
-        T: Into<AttachmentType<'a>>, {
+        where F: FnOnce(CreateMessage) -> CreateMessage, T: Into<AttachmentType<'a>> {
         let mut map = f(CreateMessage::default()).0;
 
         if let Some(content) = map.get("content") {
@@ -474,8 +469,7 @@ impl ChannelId {
     /// [`CreateMessage`]: ../builder/struct.CreateMessage.html
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
     pub fn send_message<F>(&self, f: F) -> Result<Message>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage, {
+        where F: FnOnce(CreateMessage) -> CreateMessage {
         let CreateMessage(map, reactions) = f(CreateMessage::default());
 
         Message::check_content_length(&map)?;
diff --git a/src/model/channel/embed.rs b/src/model/channel/embed.rs
index 5aea7b0..435f706 100644
--- a/src/model/channel/embed.rs
+++ b/src/model/channel/embed.rs
@@ -88,8 +88,7 @@ impl Embed {
     /// ```
     #[inline]
     pub fn fake<F>(f: F) -> Value
-    where
-        F: FnOnce(CreateEmbed) -> CreateEmbed, {
+        where F: FnOnce(CreateEmbed) -> CreateEmbed {
         Value::Object(f(CreateEmbed::default()).0)
     }
 }
diff --git a/src/model/channel/group.rs b/src/model/channel/group.rs
index 42c1249..11d6162 100644
--- a/src/model/channel/group.rs
+++ b/src/model/channel/group.rs
@@ -75,9 +75,7 @@ impl Group {
     /// [Add Reactions]: permissions/constant.ADD_REACTIONS.html
     #[inline]
     pub fn create_reaction<M, R>(&self, message_id: M, reaction_type: R) -> Result<()>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>, {
+        where M: Into<MessageId>, R: Into<ReactionType> {
         self.channel_id.create_reaction(message_id, reaction_type)
     }
 
@@ -124,9 +122,7 @@ impl Group {
                                  user_id: Option<UserId>,
                                  reaction_type: R)
                                  -> Result<()>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>, {
+        where M: Into<MessageId>, R: Into<ReactionType> {
         self.channel_id
             .delete_reaction(message_id, user_id, reaction_type)
     }
@@ -152,17 +148,15 @@ impl Group {
     /// [`the limit`]: ../builder/struct.CreateMessage.html#method.content
     #[inline]
     pub fn edit_message<F, M>(&self, message_id: M, f: F) -> Result<Message>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage,
-        M: Into<MessageId>, {
+        where F: FnOnce(CreateMessage) -> CreateMessage, M: Into<MessageId> {
         self.channel_id.edit_message(message_id, f)
     }
 
     /// Returns the formatted URI of the group's icon if one exists.
     pub fn icon_url(&self) -> Option<String> {
-        self.icon
-            .as_ref()
-            .map(|icon| format!(cdn!("/channel-icons/{}/{}.webp"), self.channel_id, icon))
+        self.icon.as_ref().map(|icon| {
+            format!(cdn!("/channel-icons/{}/{}.webp"), self.channel_id, icon)
+        })
     }
 
     /// Determines if the channel is NSFW.
@@ -197,8 +191,7 @@ impl Group {
     /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
     #[inline]
     pub fn messages<F>(&self, f: F) -> Result<Vec<Message>>
-    where
-        F: FnOnce(GetMessages) -> GetMessages, {
+        where F: FnOnce(GetMessages) -> GetMessages {
         self.channel_id.messages(f)
     }
 
@@ -248,10 +241,7 @@ impl Group {
                                    limit: Option<u8>,
                                    after: Option<U>)
                                    -> Result<Vec<User>>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>,
-        U: Into<UserId>, {
+        where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
         self.channel_id
             .reaction_users(message_id, reaction_type, limit, after)
     }
@@ -304,9 +294,7 @@ impl Group {
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
     #[inline]
     pub fn send_files<'a, F, T>(&self, files: Vec<T>, f: F) -> Result<Message>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage,
-        T: Into<AttachmentType<'a>>, {
+        where F: FnOnce(CreateMessage) -> CreateMessage, T: Into<AttachmentType<'a>> {
         self.channel_id.send_files(files, f)
     }
 
diff --git a/src/model/channel/guild_channel.rs b/src/model/channel/guild_channel.rs
index 250e112..99a8682 100644
--- a/src/model/channel/guild_channel.rs
+++ b/src/model/channel/guild_channel.rs
@@ -105,8 +105,7 @@ impl GuildChannel {
     /// let invite = channel.create_invite(|i| i.max_uses(5));
     /// ```
     pub fn create_invite<F>(&self, f: F) -> Result<RichInvite>
-    where
-        F: FnOnce(CreateInvite) -> CreateInvite, {
+        where F: FnOnce(CreateInvite) -> CreateInvite {
         #[cfg(feature = "cache")]
         {
             let req = permissions::CREATE_INVITE;
@@ -286,9 +285,7 @@ impl GuildChannel {
                                  user_id: Option<UserId>,
                                  reaction_type: R)
                                  -> Result<()>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>, {
+        where M: Into<MessageId>, R: Into<ReactionType> {
         self.id.delete_reaction(message_id, user_id, reaction_type)
     }
 
@@ -304,8 +301,7 @@ impl GuildChannel {
     /// channel.edit(|c| c.name("test").bitrate(86400));
     /// ```
     pub fn edit<F>(&mut self, f: F) -> Result<()>
-    where
-        F: FnOnce(EditChannel) -> EditChannel, {
+        where F: FnOnce(EditChannel) -> EditChannel {
 
         #[cfg(feature = "cache")]
         {
@@ -318,10 +314,14 @@ impl GuildChannel {
 
         let mut map = Map::new();
         map.insert("name".to_owned(), Value::String(self.name.clone()));
-        map.insert("position".to_owned(),
-                   Value::Number(Number::from(self.position)));
-        map.insert("type".to_owned(),
-                   Value::String(self.kind.name().to_owned()));
+        map.insert(
+            "position".to_owned(),
+            Value::Number(Number::from(self.position)),
+        );
+        map.insert(
+            "type".to_owned(),
+            Value::String(self.kind.name().to_owned()),
+        );
 
         let edited = f(EditChannel(map)).0;
 
@@ -356,9 +356,7 @@ impl GuildChannel {
     /// [`the limit`]: ../builder/struct.CreateMessage.html#method.content
     #[inline]
     pub fn edit_message<F, M>(&self, message_id: M, f: F) -> Result<Message>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage,
-        M: Into<MessageId>, {
+        where F: FnOnce(CreateMessage) -> CreateMessage, M: Into<MessageId> {
         self.id.edit_message(message_id, f)
     }
 
@@ -412,8 +410,7 @@ impl GuildChannel {
     /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
     #[inline]
     pub fn messages<F>(&self, f: F) -> Result<Vec<Message>>
-    where
-        F: FnOnce(GetMessages) -> GetMessages, {
+        where F: FnOnce(GetMessages) -> GetMessages {
         self.id.messages(f)
     }
 
@@ -544,10 +541,7 @@ impl GuildChannel {
                                    limit: Option<u8>,
                                    after: Option<U>)
                                    -> Result<Vec<User>>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>,
-        U: Into<UserId>, {
+        where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
         self.id
             .reaction_users(message_id, reaction_type, limit, after)
     }
@@ -585,9 +579,7 @@ impl GuildChannel {
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
     #[inline]
     pub fn send_files<'a, F, T>(&self, files: Vec<T>, f: F) -> Result<Message>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage,
-        T: Into<AttachmentType<'a>>, {
+        where F: FnOnce(CreateMessage) -> CreateMessage, T: Into<AttachmentType<'a>> {
         self.id.send_files(files, f)
     }
 
diff --git a/src/model/channel/message.rs b/src/model/channel/message.rs
index 8b479bc..6fdab2a 100644
--- a/src/model/channel/message.rs
+++ b/src/model/channel/message.rs
@@ -206,8 +206,7 @@ impl Message {
     /// [`CreateMessage`]: ../builder/struct.CreateMessage.html
     /// [`the limit`]: ../builder/struct.CreateMessage.html#method.content
     pub fn edit<F>(&mut self, f: F) -> Result<()>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage, {
+        where F: FnOnce(CreateMessage) -> CreateMessage {
         #[cfg(feature = "cache")]
         {
             if self.author.id != CACHE.read().unwrap().user.id {
@@ -244,8 +243,10 @@ impl Message {
     pub(crate) fn transform_content(&mut self) {
         match self.kind {
             MessageType::PinsAdd => {
-                self.content = format!("{} pinned a message to this channel. See all the pins.",
-                                       self.author);
+                self.content = format!(
+                    "{} pinned a message to this channel. See all the pins.",
+                    self.author
+                );
             },
             MessageType::MemberJoin => {
                 let sec = self.timestamp.timestamp() as usize;
@@ -316,9 +317,7 @@ impl Message {
                                 limit: Option<u8>,
                                 after: Option<U>)
                                 -> Result<Vec<User>>
-    where
-        R: Into<ReactionType>,
-        U: Into<UserId>, {
+        where R: Into<ReactionType>, U: Into<UserId> {
         self.channel_id
             .reaction_users(self.id, reaction_type, limit, after)
     }
diff --git a/src/model/channel/mod.rs b/src/model/channel/mod.rs
index 02be9d8..cbe6085 100644
--- a/src/model/channel/mod.rs
+++ b/src/model/channel/mod.rs
@@ -62,9 +62,7 @@ impl Channel {
     /// [Add Reactions]: permissions/constant.ADD_REACTIONS.html
     #[inline]
     pub fn create_reaction<M, R>(&self, message_id: M, reaction_type: R) -> Result<()>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>, {
+        where M: Into<MessageId>, R: Into<ReactionType> {
         self.id().create_reaction(message_id, reaction_type)
     }
 
@@ -118,9 +116,7 @@ impl Channel {
                                  user_id: Option<UserId>,
                                  reaction_type: R)
                                  -> Result<()>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>, {
+        where M: Into<MessageId>, R: Into<ReactionType> {
         self.id()
             .delete_reaction(message_id, user_id, reaction_type)
     }
@@ -146,9 +142,7 @@ impl Channel {
     /// [`the limit`]: ../builder/struct.CreateMessage.html#method.content
     #[inline]
     pub fn edit_message<F, M>(&self, message_id: M, f: F) -> Result<Message>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage,
-        M: Into<MessageId>, {
+        where F: FnOnce(CreateMessage) -> CreateMessage, M: Into<MessageId> {
         self.id().edit_message(message_id, f)
     }
 
@@ -194,8 +188,7 @@ impl Channel {
     /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
     #[inline]
     pub fn messages<F>(&self, f: F) -> Result<Vec<Message>>
-    where
-        F: FnOnce(GetMessages) -> GetMessages, {
+        where F: FnOnce(GetMessages) -> GetMessages {
         self.id().messages(f)
     }
 
@@ -222,10 +215,7 @@ impl Channel {
                                    limit: Option<u8>,
                                    after: Option<U>)
                                    -> Result<Vec<User>>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>,
-        U: Into<UserId>, {
+        where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
         self.id()
             .reaction_users(message_id, reaction_type, limit, after)
     }
@@ -277,9 +267,7 @@ impl Channel {
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
     #[inline]
     pub fn send_files<'a, F, T>(&self, files: Vec<T>, f: F) -> Result<Message>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage,
-        T: Into<AttachmentType<'a>>, {
+        where F: FnOnce(CreateMessage) -> CreateMessage, T: Into<AttachmentType<'a>> {
         self.id().send_files(files, f)
     }
 
@@ -304,8 +292,7 @@ impl Channel {
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
     #[inline]
     pub fn send_message<F>(&self, f: F) -> Result<Message>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage, {
+        where F: FnOnce(CreateMessage) -> CreateMessage {
         self.id().send_message(f)
     }
 
@@ -331,21 +318,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")),
         }
     }
@@ -443,10 +424,10 @@ impl<'de> Deserialize<'de> for PermissionOverwrite {
         };
 
         Ok(PermissionOverwrite {
-               allow: data.allow,
-               deny: data.deny,
-               kind: kind,
-           })
+            allow: data.allow,
+            deny: data.deny,
+            kind: kind,
+        })
     }
 }
 
diff --git a/src/model/channel/private_channel.rs b/src/model/channel/private_channel.rs
index 893bb84..277c6a1 100644
--- a/src/model/channel/private_channel.rs
+++ b/src/model/channel/private_channel.rs
@@ -51,9 +51,7 @@ impl PrivateChannel {
     /// [`Message::react`]: struct.Message.html#method.react
     /// [Add Reactions]: permissions/constant.ADD_REACTIONS.html
     pub fn create_reaction<M, R>(&self, message_id: M, reaction_type: R) -> Result<()>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>, {
+        where M: Into<MessageId>, R: Into<ReactionType> {
         self.id.create_reaction(message_id, reaction_type)
     }
 
@@ -106,9 +104,7 @@ impl PrivateChannel {
                                  user_id: Option<UserId>,
                                  reaction_type: R)
                                  -> Result<()>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>, {
+        where M: Into<MessageId>, R: Into<ReactionType> {
         self.id.delete_reaction(message_id, user_id, reaction_type)
     }
 
@@ -133,9 +129,7 @@ impl PrivateChannel {
     /// [`the limit`]: ../builder/struct.CreateMessage.html#method.content
     #[inline]
     pub fn edit_message<F, M>(&self, message_id: M, f: F) -> Result<Message>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage,
-        M: Into<MessageId>, {
+        where F: FnOnce(CreateMessage) -> CreateMessage, M: Into<MessageId> {
         self.id.edit_message(message_id, f)
     }
 
@@ -170,8 +164,7 @@ impl PrivateChannel {
     /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
     #[inline]
     pub fn messages<F>(&self, f: F) -> Result<Vec<Message>>
-    where
-        F: FnOnce(GetMessages) -> GetMessages, {
+        where F: FnOnce(GetMessages) -> GetMessages {
         self.id.messages(f)
     }
 
@@ -197,10 +190,7 @@ impl PrivateChannel {
                                    limit: Option<u8>,
                                    after: Option<U>)
                                    -> Result<Vec<User>>
-    where
-        M: Into<MessageId>,
-        R: Into<ReactionType>,
-        U: Into<UserId>, {
+        where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
         self.id
             .reaction_users(message_id, reaction_type, limit, after)
     }
@@ -249,9 +239,7 @@ impl PrivateChannel {
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
     #[inline]
     pub fn send_files<'a, F, T>(&self, files: Vec<T>, f: F) -> Result<Message>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage,
-        T: Into<AttachmentType<'a>>, {
+        where F: FnOnce(CreateMessage) -> CreateMessage, T: Into<AttachmentType<'a>> {
         self.id.send_files(files, f)
     }
 
diff --git a/src/model/channel/reaction.rs b/src/model/channel/reaction.rs
index 5ecb038..ac522a0 100644
--- a/src/model/channel/reaction.rs
+++ b/src/model/channel/reaction.rs
@@ -103,14 +103,14 @@ impl Reaction {
                        limit: Option<u8>,
                        after: Option<U>)
                        -> Result<Vec<User>>
-    where
-        R: Into<ReactionType>,
-        U: Into<UserId>, {
-        http::get_reaction_users(self.channel_id.0,
-                                 self.message_id.0,
-                                 &reaction_type.into(),
-                                 limit.unwrap_or(50),
-                                 after.map(|u| u.into().0))
+        where R: Into<ReactionType>, U: Into<UserId> {
+        http::get_reaction_users(
+            self.channel_id.0,
+            self.message_id.0,
+            &reaction_type.into(),
+            limit.unwrap_or(50),
+            after.map(|u| u.into().0),
+        )
     }
 }
 
@@ -205,13 +205,13 @@ impl<'de> Deserialize<'de> for ReactionType {
                 let name = name.ok_or_else(|| DeError::missing_field("name"))?;
 
                 Ok(if let Some(id) = id {
-                       ReactionType::Custom {
-                           id: id,
-                           name: name,
-                       }
-                   } else {
-                       ReactionType::Unicode(name)
-                   })
+                    ReactionType::Custom {
+                        id: id,
+                        name: name,
+                    }
+                } else {
+                    ReactionType::Unicode(name)
+                })
             }
         }
 
diff --git a/src/model/event.rs b/src/model/event.rs
index 32ef560..4178847 100644
--- a/src/model/event.rs
+++ b/src/model/event.rs
@@ -37,8 +37,8 @@ pub struct ChannelCreateEvent {
 impl<'de> Deserialize<'de> for ChannelCreateEvent {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
-               channel: Channel::deserialize(deserializer)?,
-           })
+            channel: Channel::deserialize(deserializer)?,
+        })
     }
 }
 
@@ -50,8 +50,8 @@ pub struct ChannelDeleteEvent {
 impl<'de> Deserialize<'de> for ChannelDeleteEvent {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
-               channel: Channel::deserialize(deserializer)?,
-           })
+            channel: Channel::deserialize(deserializer)?,
+        })
     }
 }
 
@@ -81,8 +81,8 @@ pub struct ChannelUpdateEvent {
 impl<'de> Deserialize<'de> for ChannelUpdateEvent {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
-               channel: Channel::deserialize(deserializer)?,
-           })
+            channel: Channel::deserialize(deserializer)?,
+        })
     }
 }
 
@@ -106,8 +106,8 @@ pub struct GuildCreateEvent {
 impl<'de> Deserialize<'de> for GuildCreateEvent {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
-               guild: Guild::deserialize(deserializer)?,
-           })
+            guild: Guild::deserialize(deserializer)?,
+        })
     }
 }
 
@@ -119,8 +119,8 @@ pub struct GuildDeleteEvent {
 impl<'de> Deserialize<'de> for GuildDeleteEvent {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
-               guild: PartialGuild::deserialize(deserializer)?,
-           })
+            guild: PartialGuild::deserialize(deserializer)?,
+        })
     }
 }
 
@@ -152,10 +152,10 @@ impl<'de> Deserialize<'de> for GuildMemberAddEvent {
             .map_err(DeError::custom)?;
 
         Ok(GuildMemberAddEvent {
-               guild_id: guild_id,
-               member: Member::deserialize(Value::Object(map))
-                   .map_err(DeError::custom)?,
-           })
+            guild_id: guild_id,
+            member: Member::deserialize(Value::Object(map))
+                .map_err(DeError::custom)?,
+        })
     }
 }
 
@@ -205,9 +205,9 @@ impl<'de> Deserialize<'de> for GuildMembersChunkEvent {
             Deserialize::deserialize(members).map_err(DeError::custom)?;
 
         Ok(GuildMembersChunkEvent {
-               guild_id: guild_id,
-               members: members,
-           })
+            guild_id: guild_id,
+            members: members,
+        })
     }
 }
 
@@ -243,8 +243,8 @@ pub struct GuildUpdateEvent {
 impl<'de> Deserialize<'de> for GuildUpdateEvent {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
-               guild: PartialGuild::deserialize(deserializer)?,
-           })
+            guild: PartialGuild::deserialize(deserializer)?,
+        })
     }
 }
 
@@ -256,8 +256,8 @@ pub struct MessageCreateEvent {
 impl<'de> Deserialize<'de> for MessageCreateEvent {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
-               message: Message::deserialize(deserializer)?,
-           })
+            message: Message::deserialize(deserializer)?,
+        })
     }
 }
 
@@ -305,27 +305,23 @@ 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)?;
 
         Ok(Self {
-               guild_id: guild_id,
-               presence: presence,
-               roles: roles,
-           })
+            guild_id: guild_id,
+            presence: presence,
+            roles: roles,
+        })
     }
 }
 
@@ -339,8 +335,8 @@ impl<'de> Deserialize<'de> for PresencesReplaceEvent {
         let presences: Vec<Presence> = Deserialize::deserialize(deserializer)?;
 
         Ok(Self {
-               presences: presences,
-           })
+            presences: presences,
+        })
     }
 }
 
@@ -352,8 +348,8 @@ pub struct ReactionAddEvent {
 impl<'de> Deserialize<'de> for ReactionAddEvent {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
-               reaction: Reaction::deserialize(deserializer)?,
-           })
+            reaction: Reaction::deserialize(deserializer)?,
+        })
     }
 }
 
@@ -365,8 +361,8 @@ pub struct ReactionRemoveEvent {
 impl<'de> Deserialize<'de> for ReactionRemoveEvent {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
-               reaction: Reaction::deserialize(deserializer)?,
-           })
+            reaction: Reaction::deserialize(deserializer)?,
+        })
     }
 }
 
@@ -385,8 +381,8 @@ pub struct ReadyEvent {
 impl<'de> Deserialize<'de> for ReadyEvent {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
-               ready: Ready::deserialize(deserializer)?,
-           })
+            ready: Ready::deserialize(deserializer)?,
+        })
     }
 }
 
@@ -417,8 +413,8 @@ pub struct UserUpdateEvent {
 impl<'de> Deserialize<'de> for UserUpdateEvent {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
-               current_user: CurrentUser::deserialize(deserializer)?,
-           })
+            current_user: CurrentUser::deserialize(deserializer)?,
+        })
     }
 }
 
@@ -445,10 +441,10 @@ impl<'de> Deserialize<'de> for VoiceStateUpdateEvent {
         };
 
         Ok(VoiceStateUpdateEvent {
-               guild_id: guild_id,
-               voice_state: VoiceState::deserialize(Value::Object(map))
-                   .map_err(DeError::custom)?,
-           })
+            guild_id: guild_id,
+            voice_state: VoiceState::deserialize(Value::Object(map))
+                .map_err(DeError::custom)?,
+        })
     }
 }
 
@@ -479,41 +475,42 @@ impl GatewayEvent {
             .and_then(OpCode::deserialize)?;
 
         Ok(match op {
-               OpCode::Event => {
-                   let s = map.remove("s")
-                       .ok_or_else(|| DeError::custom("expected gateway event sequence"))
-                       .and_then(u64::deserialize)?;
-                   let t = map.remove("t")
-                       .ok_or_else(|| DeError::custom("expected gateway event type"))
-                       .and_then(String::deserialize)?;
-                   let d =
-                map.remove("d")
-                    .ok_or_else(|| Error::Decode("expected gateway event d", Value::Object(map)))?;
-
-                   GatewayEvent::Dispatch(s, Event::decode(t, d)?)
-               },
-               OpCode::Heartbeat => {
-                   let s = map.remove("s")
-                       .ok_or_else(|| DeError::custom("Expected heartbeat s"))
-                       .and_then(u64::deserialize)?;
-
-                   GatewayEvent::Heartbeat(s)
-               },
-               OpCode::Reconnect => GatewayEvent::Reconnect,
-               OpCode::InvalidSession => GatewayEvent::InvalidateSession,
-               OpCode::Hello => {
-                   let mut d = map.remove("d")
-                       .ok_or_else(|| DeError::custom("expected gateway hello d"))
-                       .and_then(JsonMap::deserialize)?;
-                   let interval = d.remove("heartbeat_interval")
-                       .ok_or_else(|| DeError::custom("expected gateway hello interval"))
-                       .and_then(u64::deserialize)?;
-
-                   GatewayEvent::Hello(interval)
-               },
-               OpCode::HeartbeatAck => GatewayEvent::HeartbeatAck,
-               _ => return Err(Error::Gateway(GatewayError::InvalidOpCode)),
-           })
+            OpCode::Event => {
+                let s = map.remove("s")
+                    .ok_or_else(|| DeError::custom("expected gateway event sequence"))
+                    .and_then(u64::deserialize)?;
+                let t = map.remove("t")
+                    .ok_or_else(|| DeError::custom("expected gateway event type"))
+                    .and_then(String::deserialize)?;
+                let d = map.remove("d")
+                    .ok_or_else(|| {
+                        Error::Decode("expected gateway event d", Value::Object(map))
+                    })?;
+
+                GatewayEvent::Dispatch(s, Event::decode(t, d)?)
+            },
+            OpCode::Heartbeat => {
+                let s = map.remove("s")
+                    .ok_or_else(|| DeError::custom("Expected heartbeat s"))
+                    .and_then(u64::deserialize)?;
+
+                GatewayEvent::Heartbeat(s)
+            },
+            OpCode::Reconnect => GatewayEvent::Reconnect,
+            OpCode::InvalidSession => GatewayEvent::InvalidateSession,
+            OpCode::Hello => {
+                let mut d = map.remove("d")
+                    .ok_or_else(|| DeError::custom("expected gateway hello d"))
+                    .and_then(JsonMap::deserialize)?;
+                let interval = d.remove("heartbeat_interval")
+                    .ok_or_else(|| DeError::custom("expected gateway hello interval"))
+                    .and_then(u64::deserialize)?;
+
+                GatewayEvent::Hello(interval)
+            },
+            OpCode::HeartbeatAck => GatewayEvent::HeartbeatAck,
+            _ => return Err(Error::Gateway(GatewayError::InvalidOpCode)),
+        })
     }
 }
 
@@ -638,107 +635,101 @@ impl Event {
     #[cfg(feature = "gateway")]
     fn decode(kind: String, value: Value) -> Result<Event> {
         Ok(match &kind[..] {
-               "CHANNEL_CREATE" => Event::ChannelCreate(ChannelCreateEvent::deserialize(value)?),
-               "CHANNEL_DELETE" => Event::ChannelDelete(ChannelDeleteEvent::deserialize(value)?),
-               "CHANNEL_PINS_UPDATE" => {
-                   Event::ChannelPinsUpdate(ChannelPinsUpdateEvent::deserialize(value)?)
-               },
-               "CHANNEL_RECIPIENT_ADD" => {
-                   Event::ChannelRecipientAdd(ChannelRecipientAddEvent::deserialize(value)?)
-               },
-               "CHANNEL_RECIPIENT_REMOVE" => {
-                   Event::ChannelRecipientRemove(ChannelRecipientRemoveEvent::deserialize(value)?)
-               },
-               "CHANNEL_UPDATE" => Event::ChannelUpdate(ChannelUpdateEvent::deserialize(value)?),
-               "GUILD_BAN_ADD" => Event::GuildBanAdd(GuildBanAddEvent::deserialize(value)?),
-               "GUILD_BAN_REMOVE" => {
-                   Event::GuildBanRemove(GuildBanRemoveEvent::deserialize(value)?)
-               },
-               "GUILD_CREATE" => {
-                   let mut map = JsonMap::deserialize(value)?;
-
-                   if map.remove("unavailable")
-                          .and_then(|v| v.as_bool())
-                          .unwrap_or(false) {
-                       Event::GuildUnavailable(GuildUnavailableEvent::deserialize(Value::Object(map))?)
-                   } else {
-                       Event::GuildCreate(GuildCreateEvent::deserialize(Value::Object(map))?)
-                   }
-               },
-               "GUILD_DELETE" => {
-                   let mut map = JsonMap::deserialize(value)?;
-
-                   if map.remove("unavailable")
-                          .and_then(|v| v.as_bool())
-                          .unwrap_or(false) {
-                       Event::GuildUnavailable(GuildUnavailableEvent::deserialize(Value::Object(map))?)
-                   } else {
-                       Event::GuildDelete(GuildDeleteEvent::deserialize(Value::Object(map))?)
-                   }
-               },
-               "GUILD_EMOJIS_UPDATE" => {
-                   Event::GuildEmojisUpdate(GuildEmojisUpdateEvent::deserialize(value)?)
-               },
-               "GUILD_INTEGRATIONS_UPDATE" => {
-                   Event::GuildIntegrationsUpdate(GuildIntegrationsUpdateEvent::deserialize(value)?)
-               },
-               "GUILD_MEMBER_ADD" => {
-                   Event::GuildMemberAdd(GuildMemberAddEvent::deserialize(value)?)
-               },
-               "GUILD_MEMBER_REMOVE" => {
-                   Event::GuildMemberRemove(GuildMemberRemoveEvent::deserialize(value)?)
-               },
-               "GUILD_MEMBER_UPDATE" => {
-                   Event::GuildMemberUpdate(GuildMemberUpdateEvent::deserialize(value)?)
-               },
-               "GUILD_MEMBERS_CHUNK" => {
-                   Event::GuildMembersChunk(GuildMembersChunkEvent::deserialize(value)?)
-               },
-               "GUILD_ROLE_CREATE" => {
-                   Event::GuildRoleCreate(GuildRoleCreateEvent::deserialize(value)?)
-               },
-               "GUILD_ROLE_DELETE" => {
-                   Event::GuildRoleDelete(GuildRoleDeleteEvent::deserialize(value)?)
-               },
-               "GUILD_ROLE_UPDATE" => {
-                   Event::GuildRoleUpdate(GuildRoleUpdateEvent::deserialize(value)?)
-               },
-               "GUILD_UPDATE" => Event::GuildUpdate(GuildUpdateEvent::deserialize(value)?),
-               "MESSAGE_CREATE" => Event::MessageCreate(MessageCreateEvent::deserialize(value)?),
-               "MESSAGE_DELETE" => Event::MessageDelete(MessageDeleteEvent::deserialize(value)?),
-               "MESSAGE_DELETE_BULK" => {
-                   Event::MessageDeleteBulk(MessageDeleteBulkEvent::deserialize(value)?)
-               },
-               "MESSAGE_REACTION_ADD" => Event::ReactionAdd(ReactionAddEvent::deserialize(value)?),
-               "MESSAGE_REACTION_REMOVE" => {
-                   Event::ReactionRemove(ReactionRemoveEvent::deserialize(value)?)
-               },
-               "MESSAGE_REACTION_REMOVE_ALL" => {
-                   Event::ReactionRemoveAll(ReactionRemoveAllEvent::deserialize(value)?)
-               },
-               "MESSAGE_UPDATE" => Event::MessageUpdate(MessageUpdateEvent::deserialize(value)?),
-               "PRESENCE_UPDATE" => Event::PresenceUpdate(PresenceUpdateEvent::deserialize(value)?),
-               "PRESENCES_REPLACE" => {
-                   Event::PresencesReplace(PresencesReplaceEvent::deserialize(value)?)
-               },
-               "READY" => Event::Ready(ReadyEvent::deserialize(value)?),
-               "RESUMED" => Event::Resumed(ResumedEvent::deserialize(value)?),
-               "TYPING_START" => Event::TypingStart(TypingStartEvent::deserialize(value)?),
-               "USER_UPDATE" => Event::UserUpdate(UserUpdateEvent::deserialize(value)?),
-               "VOICE_SERVER_UPDATE" => {
-                   Event::VoiceServerUpdate(VoiceServerUpdateEvent::deserialize(value)?)
-               },
-               "VOICE_STATE_UPDATE" => {
-                   Event::VoiceStateUpdate(VoiceStateUpdateEvent::deserialize(value)?)
-               },
-               "WEBHOOKS_UPDATE" => Event::WebhookUpdate(WebhookUpdateEvent::deserialize(value)?),
-               _ => {
-                   Event::Unknown(UnknownEvent {
-                                      kind: kind,
-                                      value: value,
-                                  })
-               },
-           })
+            "CHANNEL_CREATE" => Event::ChannelCreate(ChannelCreateEvent::deserialize(value)?),
+            "CHANNEL_DELETE" => Event::ChannelDelete(ChannelDeleteEvent::deserialize(value)?),
+            "CHANNEL_PINS_UPDATE" => {
+                Event::ChannelPinsUpdate(ChannelPinsUpdateEvent::deserialize(value)?)
+            },
+            "CHANNEL_RECIPIENT_ADD" => {
+                Event::ChannelRecipientAdd(ChannelRecipientAddEvent::deserialize(value)?)
+            },
+            "CHANNEL_RECIPIENT_REMOVE" => {
+                Event::ChannelRecipientRemove(ChannelRecipientRemoveEvent::deserialize(value)?)
+            },
+            "CHANNEL_UPDATE" => Event::ChannelUpdate(ChannelUpdateEvent::deserialize(value)?),
+            "GUILD_BAN_ADD" => Event::GuildBanAdd(GuildBanAddEvent::deserialize(value)?),
+            "GUILD_BAN_REMOVE" => Event::GuildBanRemove(GuildBanRemoveEvent::deserialize(value)?),
+            "GUILD_CREATE" => {
+                let mut map = JsonMap::deserialize(value)?;
+
+                if map.remove("unavailable")
+                       .and_then(|v| v.as_bool())
+                       .unwrap_or(false) {
+                    Event::GuildUnavailable(GuildUnavailableEvent::deserialize(Value::Object(map))?)
+                } else {
+                    Event::GuildCreate(GuildCreateEvent::deserialize(Value::Object(map))?)
+                }
+            },
+            "GUILD_DELETE" => {
+                let mut map = JsonMap::deserialize(value)?;
+
+                if map.remove("unavailable")
+                       .and_then(|v| v.as_bool())
+                       .unwrap_or(false) {
+                    Event::GuildUnavailable(GuildUnavailableEvent::deserialize(Value::Object(map))?)
+                } else {
+                    Event::GuildDelete(GuildDeleteEvent::deserialize(Value::Object(map))?)
+                }
+            },
+            "GUILD_EMOJIS_UPDATE" => {
+                Event::GuildEmojisUpdate(GuildEmojisUpdateEvent::deserialize(value)?)
+            },
+            "GUILD_INTEGRATIONS_UPDATE" => {
+                Event::GuildIntegrationsUpdate(GuildIntegrationsUpdateEvent::deserialize(value)?)
+            },
+            "GUILD_MEMBER_ADD" => Event::GuildMemberAdd(GuildMemberAddEvent::deserialize(value)?),
+            "GUILD_MEMBER_REMOVE" => {
+                Event::GuildMemberRemove(GuildMemberRemoveEvent::deserialize(value)?)
+            },
+            "GUILD_MEMBER_UPDATE" => {
+                Event::GuildMemberUpdate(GuildMemberUpdateEvent::deserialize(value)?)
+            },
+            "GUILD_MEMBERS_CHUNK" => {
+                Event::GuildMembersChunk(GuildMembersChunkEvent::deserialize(value)?)
+            },
+            "GUILD_ROLE_CREATE" => {
+                Event::GuildRoleCreate(GuildRoleCreateEvent::deserialize(value)?)
+            },
+            "GUILD_ROLE_DELETE" => {
+                Event::GuildRoleDelete(GuildRoleDeleteEvent::deserialize(value)?)
+            },
+            "GUILD_ROLE_UPDATE" => {
+                Event::GuildRoleUpdate(GuildRoleUpdateEvent::deserialize(value)?)
+            },
+            "GUILD_UPDATE" => Event::GuildUpdate(GuildUpdateEvent::deserialize(value)?),
+            "MESSAGE_CREATE" => Event::MessageCreate(MessageCreateEvent::deserialize(value)?),
+            "MESSAGE_DELETE" => Event::MessageDelete(MessageDeleteEvent::deserialize(value)?),
+            "MESSAGE_DELETE_BULK" => {
+                Event::MessageDeleteBulk(MessageDeleteBulkEvent::deserialize(value)?)
+            },
+            "MESSAGE_REACTION_ADD" => Event::ReactionAdd(ReactionAddEvent::deserialize(value)?),
+            "MESSAGE_REACTION_REMOVE" => {
+                Event::ReactionRemove(ReactionRemoveEvent::deserialize(value)?)
+            },
+            "MESSAGE_REACTION_REMOVE_ALL" => {
+                Event::ReactionRemoveAll(ReactionRemoveAllEvent::deserialize(value)?)
+            },
+            "MESSAGE_UPDATE" => Event::MessageUpdate(MessageUpdateEvent::deserialize(value)?),
+            "PRESENCE_UPDATE" => Event::PresenceUpdate(PresenceUpdateEvent::deserialize(value)?),
+            "PRESENCES_REPLACE" => {
+                Event::PresencesReplace(PresencesReplaceEvent::deserialize(value)?)
+            },
+            "READY" => Event::Ready(ReadyEvent::deserialize(value)?),
+            "RESUMED" => Event::Resumed(ResumedEvent::deserialize(value)?),
+            "TYPING_START" => Event::TypingStart(TypingStartEvent::deserialize(value)?),
+            "USER_UPDATE" => Event::UserUpdate(UserUpdateEvent::deserialize(value)?),
+            "VOICE_SERVER_UPDATE" => {
+                Event::VoiceServerUpdate(VoiceServerUpdateEvent::deserialize(value)?)
+            },
+            "VOICE_STATE_UPDATE" => {
+                Event::VoiceStateUpdate(VoiceStateUpdateEvent::deserialize(value)?)
+            },
+            "WEBHOOKS_UPDATE" => Event::WebhookUpdate(WebhookUpdateEvent::deserialize(value)?),
+            _ => Event::Unknown(UnknownEvent {
+                kind: kind,
+                value: value,
+            }),
+        })
     }
 }
 
@@ -801,33 +792,34 @@ 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",
+                    Value::Object(map),
+                ))
             },
-            None => return Err(Error::Decode("expected voice gateway d", Value::Object(map))),
         };
         let v = Value::Object(d);
 
         Ok(match op {
-               VoiceOpCode::Heartbeat => VoiceEvent::Heartbeat(VoiceHeartbeat::deserialize(v)?),
-               VoiceOpCode::Hello => VoiceEvent::Hello(VoiceHello::deserialize(v)?),
-               VoiceOpCode::KeepAlive => VoiceEvent::KeepAlive,
-               VoiceOpCode::SessionDescription => {
-                   VoiceEvent::Ready(VoiceSessionDescription::deserialize(v)?)
-               },
-               VoiceOpCode::Speaking => VoiceEvent::Speaking(VoiceSpeaking::deserialize(v)?),
-               other => VoiceEvent::Unknown(other, v),
-           })
+            VoiceOpCode::Heartbeat => VoiceEvent::Heartbeat(VoiceHeartbeat::deserialize(v)?),
+            VoiceOpCode::Hello => VoiceEvent::Hello(VoiceHello::deserialize(v)?),
+            VoiceOpCode::KeepAlive => VoiceEvent::KeepAlive,
+            VoiceOpCode::SessionDescription => {
+                VoiceEvent::Ready(VoiceSessionDescription::deserialize(v)?)
+            },
+            VoiceOpCode::Speaking => VoiceEvent::Speaking(VoiceSpeaking::deserialize(v)?),
+            other => VoiceEvent::Unknown(other, v),
+        })
     }
 }
diff --git a/src/model/gateway.rs b/src/model/gateway.rs
index b0aed98..0c9f33e 100644
--- a/src/model/gateway.rs
+++ b/src/model/gateway.rs
@@ -107,10 +107,10 @@ impl<'de> Deserialize<'de> for Game {
             .and_then(|v| serde_json::from_value::<String>(v).ok());
 
         Ok(Game {
-               kind: kind,
-               name: name,
-               url: url,
-           })
+            kind: kind,
+            name: name,
+            url: url,
+        })
     }
 }
 
@@ -185,10 +185,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") {
@@ -196,10 +194,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")
@@ -208,13 +204,13 @@ impl<'de> Deserialize<'de> for Presence {
             .map_err(DeError::custom)?;
 
         Ok(Presence {
-               game: game,
-               last_modified: last_modified,
-               nick: nick,
-               status: status,
-               user: user,
-               user_id: user_id,
-           })
+            game: game,
+            last_modified: last_modified,
+            nick: nick,
+            status: status,
+            user: user,
+            user_id: user_id,
+        })
     }
 }
 
diff --git a/src/model/guild/audit_log.rs b/src/model/guild/audit_log.rs
index 020ad77..742425e 100644
--- a/src/model/guild/audit_log.rs
+++ b/src/model/guild/audit_log.rs
@@ -91,22 +91,22 @@ fn deserialize_target<'de, D: Deserializer<'de>>(de: D) -> Result<Target, D::Err
 
         fn visit_i32<E: de::Error>(self, value: i32) -> Result<Target, E> {
             Ok(if value < 10 {
-                   Target::Guild
-               } else if value < 20 {
-                   Target::Channel
-               } else if value < 30 {
-                   Target::User
-               } else if value < 40 {
-                   Target::Role
-               } else if value < 50 {
-                   Target::Invite
-               } else if value < 60 {
-                   Target::Webhook
-               } else if value < 70 {
-                   Target::Emoji
-               } else {
-                   return Err(E::custom(format!("Unexpected target number: {}", value)));
-               })
+                Target::Guild
+            } else if value < 20 {
+                Target::Channel
+            } else if value < 30 {
+                Target::User
+            } else if value < 40 {
+                Target::Role
+            } else if value < 50 {
+                Target::Invite
+            } else if value < 60 {
+                Target::Webhook
+            } else if value < 70 {
+                Target::Emoji
+            } else {
+                return Err(E::custom(format!("Unexpected target number: {}", value)));
+            })
         }
     }
 
@@ -126,58 +126,58 @@ fn deserialize_action<'de, D: Deserializer<'de>>(de: D) -> Result<Action, D::Err
         fn visit_i32<E: de::Error>(self, value: i32) -> Result<Action, E> {
             // todo: improve this
             Ok(if value == 1 {
-                   Action::GuildUpdate
-               } else if value == 10 {
-                   Action::ChannelCreate
-               } else if value == 11 {
-                   Action::ChannelUpdate
-               } else if value == 12 {
-                   Action::ChannelDelete
-               } else if value == 13 {
-                   Action::ChannelOverwriteCreate
-               } else if value == 14 {
-                   Action::ChannelOverwriteUpdate
-               } else if value == 15 {
-                   Action::ChannelOverwriteDelete
-               } else if value == 20 {
-                   Action::MemberKick
-               } else if value == 21 {
-                   Action::MemberPrune
-               } else if value == 22 {
-                   Action::MemberBanAdd
-               } else if value == 23 {
-                   Action::MemberBanRemove
-               } else if value == 24 {
-                   Action::MemberUpdate
-               } else if value == 25 {
-                   Action::MemberRoleUpdate
-               } else if value == 30 {
-                   Action::RoleCreate
-               } else if value == 31 {
-                   Action::RoleUpdate
-               } else if value == 32 {
-                   Action::RoleDelete
-               } else if value == 40 {
-                   Action::InviteCreate
-               } else if value == 41 {
-                   Action::InviteUpdate
-               } else if value == 42 {
-                   Action::InviteDelete
-               } else if value == 50 {
-                   Action::WebhookCreate
-               } else if value == 51 {
-                   Action::WebhookUpdate
-               } else if value == 52 {
-                   Action::WebhookDelete
-               } else if value == 60 {
-                   Action::EmojiCreate
-               } else if value == 61 {
-                   Action::EmojiUpdate
-               } else if value == 62 {
-                   Action::EmojiDelete
-               } else {
-                   return Err(E::custom(format!("Unexpected action number: {}", value)));
-               })
+                Action::GuildUpdate
+            } else if value == 10 {
+                Action::ChannelCreate
+            } else if value == 11 {
+                Action::ChannelUpdate
+            } else if value == 12 {
+                Action::ChannelDelete
+            } else if value == 13 {
+                Action::ChannelOverwriteCreate
+            } else if value == 14 {
+                Action::ChannelOverwriteUpdate
+            } else if value == 15 {
+                Action::ChannelOverwriteDelete
+            } else if value == 20 {
+                Action::MemberKick
+            } else if value == 21 {
+                Action::MemberPrune
+            } else if value == 22 {
+                Action::MemberBanAdd
+            } else if value == 23 {
+                Action::MemberBanRemove
+            } else if value == 24 {
+                Action::MemberUpdate
+            } else if value == 25 {
+                Action::MemberRoleUpdate
+            } else if value == 30 {
+                Action::RoleCreate
+            } else if value == 31 {
+                Action::RoleUpdate
+            } else if value == 32 {
+                Action::RoleDelete
+            } else if value == 40 {
+                Action::InviteCreate
+            } else if value == 41 {
+                Action::InviteUpdate
+            } else if value == 42 {
+                Action::InviteDelete
+            } else if value == 50 {
+                Action::WebhookCreate
+            } else if value == 51 {
+                Action::WebhookUpdate
+            } else if value == 52 {
+                Action::WebhookDelete
+            } else if value == 60 {
+                Action::EmojiCreate
+            } else if value == 61 {
+                Action::EmojiUpdate
+            } else if value == 62 {
+                Action::EmojiDelete
+            } else {
+                return Err(E::custom(format!("Unexpected action number: {}", value)));
+            })
         }
     }
 
@@ -214,11 +214,11 @@ impl<'de> Deserialize<'de> for AuditLogs {
                 };
 
                 Ok(AuditLogs {
-                       entries: audit_log_entries
-                           .into_iter()
-                           .map(|entry| (entry.id, entry))
-                           .collect(),
-                   })
+                    entries: audit_log_entries
+                        .into_iter()
+                        .map(|entry| (entry.id, entry))
+                        .collect(),
+                })
             }
         }
 
diff --git a/src/model/guild/guild_id.rs b/src/model/guild/guild_id.rs
index a0b69d1..08fd1a1 100644
--- a/src/model/guild/guild_id.rs
+++ b/src/model/guild/guild_id.rs
@@ -145,8 +145,7 @@ impl GuildId {
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     pub fn create_integration<I>(&self, integration_id: I, kind: &str) -> Result<()>
-    where
-        I: Into<IntegrationId>, {
+        where I: Into<IntegrationId> {
         let integration_id = integration_id.into();
         let map = json!({
             "id": integration_id.0,
@@ -263,9 +262,7 @@ impl GuildId {
     /// ```
     #[inline]
     pub fn edit_member<F, U>(&self, user_id: U, f: F) -> Result<()>
-    where
-        F: FnOnce(EditMember) -> EditMember,
-        U: Into<UserId>, {
+        where F: FnOnce(EditMember) -> EditMember, U: Into<UserId> {
         http::edit_member(self.0, user_id.into().0, &f(EditMember::default()).0)
     }
 
@@ -299,9 +296,7 @@ impl GuildId {
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[inline]
     pub fn edit_role<F, R>(&self, role_id: R, f: F) -> Result<Role>
-    where
-        F: FnOnce(EditRole) -> EditRole,
-        R: Into<RoleId>, {
+        where F: FnOnce(EditRole) -> EditRole, R: Into<RoleId> {
         http::edit_role(self.0, role_id.into().0, &f(EditRole::default()).0)
     }
 
@@ -381,8 +376,7 @@ impl GuildId {
     /// [`User`]: struct.User.html
     #[inline]
     pub fn members<U>(&self, limit: Option<u64>, after: Option<U>) -> Result<Vec<Member>>
-    where
-        U: Into<UserId>, {
+        where U: Into<UserId> {
         http::get_guild_members(self.0, limit, after.map(|x| x.into().0))
     }
 
@@ -392,12 +386,12 @@ impl GuildId {
     ///
     /// [Move Members]: permissions/constant.MOVE_MEMBERS.html
     pub fn move_member<C, U>(&self, user_id: U, channel_id: C) -> Result<()>
-    where
-        C: Into<ChannelId>,
-        U: Into<UserId>, {
+        where C: Into<ChannelId>, U: Into<UserId> {
         let mut map = Map::new();
-        map.insert("channel_id".to_owned(),
-                   Value::Number(Number::from(channel_id.into().0)));
+        map.insert(
+            "channel_id".to_owned(),
+            Value::Number(Number::from(channel_id.into().0)),
+        );
 
         http::edit_member(self.0, user_id.into().0, &map)
     }
diff --git a/src/model/guild/member.rs b/src/model/guild/member.rs
index dcf503d..70590b0 100644
--- a/src/model/guild/member.rs
+++ b/src/model/guild/member.rs
@@ -138,10 +138,12 @@ impl Member {
             return Err(Error::ExceededLimit);
         }
 
-        http::ban_user(self.guild_id.0,
-                       self.user.read().unwrap().id.0,
-                       ban_options.dmd(),
-                       &*reason)
+        http::ban_user(
+            self.guild_id.0,
+            self.user.read().unwrap().id.0,
+            ban_options.dmd(),
+            &*reason,
+        )
     }
 
     /// Determines the member's colour.
@@ -181,9 +183,11 @@ impl Member {
     /// Returns the DiscordTag of a Member, taking possible nickname into account.
     #[inline]
     pub fn distinct(&self) -> String {
-        format!("{}#{}",
-                self.display_name(),
-                self.user.read().unwrap().discriminator)
+        format!(
+            "{}#{}",
+            self.display_name(),
+            self.user.read().unwrap().discriminator
+        )
     }
 
     /// Edits the member with the given data. See [`Guild::edit_member`] for
@@ -279,7 +283,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 70d82cb..c46dba6 100644
--- a/src/model/guild/mod.rs
+++ b/src/model/guild/mod.rs
@@ -168,7 +168,9 @@ impl Guild {
     /// [Ban Members]: permissions/constant.BAN_MEMBERS.html
     pub fn ban<U: Into<UserId>>(&self, user: U, delete_message_days: u8) -> Result<()> {
         if delete_message_days > 7 {
-            return Err(Error::Model(ModelError::DeleteMessageDaysAmount(delete_message_days)));
+            return Err(Error::Model(
+                ModelError::DeleteMessageDaysAmount(delete_message_days),
+            ));
         }
 
         #[cfg(feature = "cache")]
@@ -321,8 +323,7 @@ impl Guild {
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
     pub fn create_integration<I>(&self, integration_id: I, kind: &str) -> Result<()>
-    where
-        I: Into<IntegrationId>, {
+        where I: Into<IntegrationId> {
         self.id.create_integration(integration_id, kind)
     }
 
@@ -349,8 +350,7 @@ impl Guild {
     /// [`Role`]: struct.Role.html
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     pub fn create_role<F>(&self, f: F) -> Result<Role>
-    where
-        F: FnOnce(EditRole) -> EditRole, {
+        where F: FnOnce(EditRole) -> EditRole {
         #[cfg(feature = "cache")]
         {
             let req = permissions::MANAGE_ROLES;
@@ -452,8 +452,7 @@ impl Guild {
     /// [`ModelError::InvalidPermissions`]: enum.ModelError.html#variant.InvalidPermissions
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     pub fn edit<F>(&mut self, f: F) -> Result<()>
-    where
-        F: FnOnce(EditGuild) -> EditGuild, {
+        where F: FnOnce(EditGuild) -> EditGuild {
         #[cfg(feature = "cache")]
         {
             let req = permissions::MANAGE_GUILD;
@@ -515,9 +514,7 @@ impl Guild {
     /// ```
     #[inline]
     pub fn edit_member<F, U>(&self, user_id: U, f: F) -> Result<()>
-    where
-        F: FnOnce(EditMember) -> EditMember,
-        U: Into<UserId>, {
+        where F: FnOnce(EditMember) -> EditMember, U: Into<UserId> {
         self.id.edit_member(user_id, f)
     }
 
@@ -563,9 +560,7 @@ impl Guild {
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[inline]
     pub fn edit_role<F, R>(&self, role_id: R, f: F) -> Result<Role>
-    where
-        F: FnOnce(EditRole) -> EditRole,
-        R: Into<RoleId>, {
+        where F: FnOnce(EditRole) -> EditRole, R: Into<RoleId> {
         self.id.edit_role(role_id, f)
     }
 
@@ -662,8 +657,7 @@ impl Guild {
     /// [`User`]: struct.User.html
     #[inline]
     pub fn members<U>(&self, limit: Option<u64>, after: Option<U>) -> Result<Vec<Member>>
-    where
-        U: Into<UserId>, {
+        where U: Into<UserId> {
         self.id.members(limit, after)
     }
 
@@ -674,10 +668,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,
             }
@@ -727,9 +719,9 @@ impl Guild {
                 name_matches && discrim_matches
             })
             .or_else(|| {
-                self.members
-                    .values()
-                    .find(|member| member.nick.as_ref().map_or(false, |nick| nick == name))
+                self.members.values().find(|member| {
+                    member.nick.as_ref().map_or(false, |nick| nick == name)
+                })
             })
     }
 
@@ -740,9 +732,7 @@ impl Guild {
     /// [Move Members]: permissions/constant.MOVE_MEMBERS.html
     #[inline]
     pub fn move_member<C, U>(&self, user_id: U, channel_id: C) -> Result<()>
-    where
-        C: Into<ChannelId>,
-        U: Into<UserId>, {
+        where C: Into<ChannelId>, U: Into<UserId> {
         self.id.move_member(user_id, channel_id)
     }
 
@@ -750,9 +740,7 @@ impl Guild {
     ///
     /// [`User`]: struct.User.html
     pub fn permissions_for<C, U>(&self, channel_id: C, user_id: U) -> Permissions
-    where
-        C: Into<ChannelId>,
-        U: Into<UserId>, {
+        where C: Into<ChannelId>, U: Into<UserId> {
         use super::permissions::*;
 
         let user_id = user_id.into();
@@ -1030,17 +1018,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")
@@ -1052,7 +1039,9 @@ impl<'de> Deserialize<'de> for Guild {
             .and_then(deserialize_guild_channels)
             .map_err(DeError::custom)?;
         let default_message_notifications = map.remove("default_message_notifications")
-            .ok_or_else(|| DeError::custom("expected guild default_message_notifications"))
+            .ok_or_else(|| {
+                DeError::custom("expected guild default_message_notifications")
+            })
             .and_then(u64::deserialize)
             .map_err(DeError::custom)?;
         let emojis = map.remove("emojis")
@@ -1125,28 +1114,28 @@ impl<'de> Deserialize<'de> for Guild {
             .map_err(DeError::custom)?;
 
         Ok(Self {
-               afk_channel_id: afk_channel_id,
-               afk_timeout: afk_timeout,
-               channels: channels,
-               default_message_notifications: default_message_notifications,
-               emojis: emojis,
-               features: features,
-               icon: icon,
-               id: id,
-               joined_at: joined_at,
-               large: large,
-               member_count: member_count,
-               members: members,
-               mfa_level: mfa_level,
-               name: name,
-               owner_id: owner_id,
-               presences: presences,
-               region: region,
-               roles: roles,
-               splash: splash,
-               verification_level: verification_level,
-               voice_states: voice_states,
-           })
+            afk_channel_id: afk_channel_id,
+            afk_timeout: afk_timeout,
+            channels: channels,
+            default_message_notifications: default_message_notifications,
+            emojis: emojis,
+            features: features,
+            icon: icon,
+            id: id,
+            joined_at: joined_at,
+            large: large,
+            member_count: member_count,
+            members: members,
+            mfa_level: mfa_level,
+            name: name,
+            owner_id: owner_id,
+            presences: presences,
+            region: region,
+            roles: roles,
+            splash: splash,
+            verification_level: verification_level,
+            voice_states: voice_states,
+        })
     }
 }
 
diff --git a/src/model/guild/partial_guild.rs b/src/model/guild/partial_guild.rs
index d070e54..88256f0 100644
--- a/src/model/guild/partial_guild.rs
+++ b/src/model/guild/partial_guild.rs
@@ -58,7 +58,9 @@ impl PartialGuild {
     /// [Ban Members]: permissions/constant.BAN_MEMBERS.html
     pub fn ban<U: Into<UserId>>(&self, user: U, delete_message_days: u8) -> Result<()> {
         if delete_message_days > 7 {
-            return Err(Error::Model(ModelError::DeleteMessageDaysAmount(delete_message_days)));
+            return Err(Error::Model(
+                ModelError::DeleteMessageDaysAmount(delete_message_days),
+            ));
         }
 
         self.id.ban(user, delete_message_days)
@@ -131,8 +133,7 @@ impl PartialGuild {
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
     pub fn create_integration<I>(&self, integration_id: I, kind: &str) -> Result<()>
-    where
-        I: Into<IntegrationId>, {
+        where I: Into<IntegrationId> {
         self.id.create_integration(integration_id, kind)
     }
 
@@ -205,8 +206,7 @@ impl PartialGuild {
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     pub fn edit<F>(&mut self, f: F) -> Result<()>
-    where
-        F: FnOnce(EditGuild) -> EditGuild, {
+        where F: FnOnce(EditGuild) -> EditGuild {
         match self.id.edit(f) {
             Ok(guild) => {
                 self.afk_channel_id = guild.afk_channel_id;
@@ -261,9 +261,7 @@ impl PartialGuild {
     /// ```
     #[inline]
     pub fn edit_member<F, U>(&self, user_id: U, f: F) -> Result<()>
-    where
-        F: FnOnce(EditMember) -> EditMember,
-        U: Into<UserId>, {
+        where F: FnOnce(EditMember) -> EditMember, U: Into<UserId> {
         self.id.edit_member(user_id, f)
     }
 
@@ -356,8 +354,7 @@ impl PartialGuild {
     ///
     /// [`User`]: struct.User.html
     pub fn members<U>(&self, limit: Option<u64>, after: Option<U>) -> Result<Vec<Member>>
-    where
-        U: Into<UserId>, {
+        where U: Into<UserId> {
         self.id.members(limit, after)
     }
 
@@ -368,9 +365,7 @@ impl PartialGuild {
     /// [Move Members]: permissions/constant.MOVE_MEMBERS.html
     #[inline]
     pub fn move_member<C, U>(&self, user_id: U, channel_id: C) -> Result<()>
-    where
-        C: Into<ChannelId>,
-        U: Into<UserId>, {
+        where C: Into<ChannelId>, U: Into<UserId> {
         self.id.move_member(user_id, channel_id)
     }
 
diff --git a/src/model/invite.rs b/src/model/invite.rs
index 042faa3..f48ecbc 100644
--- a/src/model/invite.rs
+++ b/src/model/invite.rs
@@ -61,9 +61,7 @@ impl Invite {
     /// [Create Invite]: permissions/constant.CREATE_INVITE.html
     /// [permission]: permissions/index.html
     pub fn create<C, F>(channel_id: C, f: F) -> Result<RichInvite>
-    where
-        C: Into<ChannelId>,
-        F: FnOnce(CreateInvite) -> CreateInvite, {
+        where C: Into<ChannelId>, F: FnOnce(CreateInvite) -> CreateInvite {
         let channel_id = channel_id.into();
 
         #[cfg(feature = "cache")]
diff --git a/src/model/misc.rs b/src/model/misc.rs
index 9420968..d2c17c5 100644
--- a/src/model/misc.rs
+++ b/src/model/misc.rs
@@ -58,11 +58,9 @@ impl FromStr for User {
 
     fn from_str(s: &str) -> StdResult<Self, ()> {
         match utils::parse_username(s) {
-            Some(x) => {
-                match UserId(x as u64).find() {
-                    Some(user) => Ok(user.read().unwrap().clone()),
-                    _ => Err(()),
-                }
+            Some(x) => match UserId(x as u64).find() {
+                Some(user) => Ok(user.read().unwrap().clone()),
+                _ => Err(()),
             },
             _ => Err(()),
         }
@@ -84,11 +82,9 @@ impl FromStr for Role {
 
     fn from_str(s: &str) -> StdResult<Self, ()> {
         match utils::parse_role(s) {
-            Some(x) => {
-                match RoleId(x).find() {
-                    Some(user) => Ok(user),
-                    _ => Err(()),
-                }
+            Some(x) => match RoleId(x).find() {
+                Some(user) => Ok(user),
+                _ => Err(()),
             },
             _ => Err(()),
         }
@@ -143,11 +139,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/permissions.rs b/src/model/permissions.rs
index a98fedd..7870518 100644
--- a/src/model/permissions.rs
+++ b/src/model/permissions.rs
@@ -426,7 +426,9 @@ impl Permissions {
 
 impl<'de> Deserialize<'de> for Permissions {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
-        Ok(Permissions::from_bits_truncate(deserializer.deserialize_u64(U64Visitor)?))
+        Ok(Permissions::from_bits_truncate(
+            deserializer.deserialize_u64(U64Visitor)?,
+        ))
     }
 }
 
diff --git a/src/model/user.rs b/src/model/user.rs
index 56e5fbf..16d5a06 100644
--- a/src/model/user.rs
+++ b/src/model/user.rs
@@ -86,8 +86,7 @@ impl CurrentUser {
     /// CACHE.write().unwrap().user.edit(|p| p.avatar(Some(&avatar)));
     /// ```
     pub fn edit<F>(&mut self, f: F) -> Result<()>
-    where
-        F: FnOnce(EditProfile) -> EditProfile, {
+        where F: FnOnce(EditProfile) -> EditProfile {
         let mut map = Map::new();
         map.insert("username".to_owned(), Value::String(self.name.clone()));
 
@@ -213,8 +212,10 @@ impl CurrentUser {
             Err(e) => return Err(e),
         };
 
-        let mut url = format!("https://discordapp.com/api/oauth2/authorize?client_id={}&scope=bot",
-                              client_id);
+        let mut url = format!(
+            "https://discordapp.com/api/oauth2/authorize?client_id={}&scope=bot",
+            client_id
+        );
 
         if bits != 0 {
             write!(url, "&permissions={}", bits)?;
@@ -481,8 +482,7 @@ impl User {
     #[allow(let_and_return)]
     #[cfg(feature = "builder")]
     pub fn direct_message<F>(&self, f: F) -> Result<Message>
-    where
-        F: FnOnce(CreateMessage) -> CreateMessage, {
+        where F: FnOnce(CreateMessage) -> CreateMessage {
         if self.bot {
             return Err(Error::Model(ModelError::MessagingBot));
         }
@@ -580,9 +580,7 @@ impl User {
     /// [`Cache`]: ../cache/struct.Cache.html
     // no-cache would warn on guild_id.
     pub fn has_role<G, R>(&self, guild: G, role: R) -> bool
-    where
-        G: Into<GuildContainer>,
-        R: Into<RoleId>, {
+        where G: Into<GuildContainer>, R: Into<RoleId> {
         let role_id = role.into();
 
         match guild.into() {
diff --git a/src/model/webhook.rs b/src/model/webhook.rs
index 9422d46..5e10d90 100644
--- a/src/model/webhook.rs
+++ b/src/model/webhook.rs
@@ -107,12 +107,14 @@ impl Webhook {
         let mut map = Map::new();
 
         if let Some(avatar) = avatar {
-            map.insert("avatar".to_owned(),
-                       if avatar.is_empty() {
-                           Value::Null
-                       } else {
-                           Value::String(avatar.to_owned())
-                       });
+            map.insert(
+                "avatar".to_owned(),
+                if avatar.is_empty() {
+                    Value::Null
+                } else {
+                    Value::String(avatar.to_owned())
+                },
+            );
         }
 
         if let Some(name) = name {
@@ -181,10 +183,12 @@ impl Webhook {
                                                                 wait: bool,
                                                                 f: F)
                                                                 -> Result<Option<Message>> {
-        http::execute_webhook(self.id.0,
-                              &self.token,
-                              wait,
-                              &f(ExecuteWebhook::default()).0)
+        http::execute_webhook(
+            self.id.0,
+            &self.token,
+            wait,
+            &f(ExecuteWebhook::default()).0,
+        )
     }
 
     /// Retrieves the latest information about the webhook, editing the
diff --git a/src/utils/mod.rs b/src/utils/mod.rs
index 9cd68a1..8467613 100644
--- a/src/utils/mod.rs
+++ b/src/utils/mod.rs
@@ -299,12 +299,10 @@ pub fn parse_emoji(mention: &str) -> Option<EmojiIdentifier> {
         }
 
         match id.parse::<u64>() {
-            Ok(x) => {
-                Some(EmojiIdentifier {
-                         name: name,
-                         id: EmojiId(x),
-                     })
-            },
+            Ok(x) => Some(EmojiIdentifier {
+                name: name,
+                id: EmojiId(x),
+            }),
             _ => None,
         }
     } else {
diff --git a/src/voice/connection.rs b/src/voice/connection.rs
index 6f8343c..7cc8b3a 100644
--- a/src/voice/connection.rs
+++ b/src/voice/connection.rs
@@ -145,23 +145,23 @@ impl Connection {
         let encoder = OpusEncoder::new(SAMPLE_RATE, Channels::Mono, CodingMode::Audio)?;
 
         Ok(Connection {
-               audio_timer: Timer::new(1000 * 60 * 4),
-               client: mutexed_client,
-               decoder_map: HashMap::new(),
-               destination: destination,
-               encoder: encoder,
-               encoder_stereo: false,
-               key: key,
-               keepalive_timer: Timer::new(hello.heartbeat_interval),
-               udp: udp,
-               sequence: 0,
-               silence_frames: 0,
-               speaking: false,
-               ssrc: hello.ssrc,
-               thread_items: thread_items,
-               timestamp: 0,
-               user_id: info.user_id,
-           })
+            audio_timer: Timer::new(1000 * 60 * 4),
+            client: mutexed_client,
+            decoder_map: HashMap::new(),
+            destination: destination,
+            encoder: encoder,
+            encoder_stereo: false,
+            key: key,
+            keepalive_timer: Timer::new(hello.heartbeat_interval),
+            udp: udp,
+            sequence: 0,
+            silence_frames: 0,
+            speaking: false,
+            ssrc: hello.ssrc,
+            thread_items: thread_items,
+            timestamp: 0,
+            user_id: info.user_id,
+        })
     }
 
     #[allow(unused_variables)]
@@ -183,7 +183,8 @@ 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) {
@@ -200,7 +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)) => {
@@ -282,7 +284,8 @@ 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 };
@@ -386,12 +389,15 @@ 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!("[Voice] Expected ready for key; got: op{}/v{:?}",
-                       op.num(),
-                       value);
+                debug!(
+                    "[Voice] Expected ready for key; got: op{}/v{:?}",
+                    op.num(),
+                    value
+                );
             },
             _ => {},
         }
@@ -437,24 +443,24 @@ fn start_threads(client: Arc<Mutex<Client>>, udp: &UdpSocket) -> Result<ThreadIt
     let ws_thread = ThreadBuilder::new()
         .name(format!("{} WS", thread_name))
         .spawn(move || loop {
-                   while let Ok(msg) = client.lock().unwrap().recv_json(VoiceEvent::decode) {
-                       if tx_clone.send(ReceiverStatus::Websocket(msg)).is_ok() {
-                           return;
-                       }
-                   }
+            while let Ok(msg) = client.lock().unwrap().recv_json(VoiceEvent::decode) {
+                if tx_clone.send(ReceiverStatus::Websocket(msg)).is_ok() {
+                    return;
+                }
+            }
 
-                   if ws_close_reader.try_recv().is_ok() {
-                       return;
-                   }
+            if ws_close_reader.try_recv().is_ok() {
+                return;
+            }
 
-                   thread::sleep(Duration::from_millis(25));
-               })?;
+            thread::sleep(Duration::from_millis(25));
+        })?;
 
     Ok(ThreadItems {
-           rx: rx,
-           udp_close_sender: udp_close_sender,
-           udp_thread: udp_thread,
-           ws_close_sender: ws_close_sender,
-           ws_thread: ws_thread,
-       })
+        rx: rx,
+        udp_close_sender: udp_close_sender,
+        udp_thread: udp_thread,
+        ws_close_sender: ws_close_sender,
+        ws_thread: ws_thread,
+    })
 }
diff --git a/src/voice/handler.rs b/src/voice/handler.rs
index fb1bf28..24b3cd9 100644
--- a/src/voice/handler.rs
+++ b/src/voice/handler.rs
@@ -153,12 +153,12 @@ impl Handler {
 
         // Safe as all of these being present was already checked.
         self.send(VoiceStatus::Connect(ConnectionInfo {
-                                           endpoint: endpoint,
-                                           guild_id: guild_id,
-                                           session_id: session_id,
-                                           token: token,
-                                           user_id: user_id,
-                                       }));
+            endpoint: endpoint,
+            guild_id: guild_id,
+            session_id: session_id,
+            token: token,
+            user_id: user_id,
+        }));
 
         true
     }
diff --git a/src/voice/manager.rs b/src/voice/manager.rs
index 785aef8..34d2a40 100644
--- a/src/voice/manager.rs
+++ b/src/voice/manager.rs
@@ -64,9 +64,7 @@ impl Manager {
     /// [`get`]: #method.get
     #[allow(map_entry)]
     pub fn join<C, G>(&mut self, guild_id: G, channel_id: C) -> &mut Handler
-    where
-        C: Into<ChannelId>,
-        G: Into<GuildId>, {
+        where C: Into<ChannelId>, G: Into<GuildId> {
         let channel_id = channel_id.into();
         let guild_id = guild_id.into();
 
diff --git a/src/voice/streamer.rs b/src/voice/streamer.rs
index c755da2..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)))),
     };
diff --git a/src/voice/threading.rs b/src/voice/threading.rs
index f272282..fc3a947 100644
--- a/src/voice/threading.rs
+++ b/src/voice/threading.rs
@@ -67,8 +67,10 @@ fn runner(rx: &MpscReceiver<Status>) {
                 match cycle {
                     Ok(()) => false,
                     Err(why) => {
-                        error!("(╯°□°）╯︵ ┻━┻ Error updating connection: {:?}",
-                               why);
+                        error!(
+                            "(╯°□°）╯︵ ┻━┻ Error updating connection: {:?}",
+                            why
+                        );
 
                         true
                     },