Change the config a bit, and a few nitpicks

20 files changed, 508 insertions, 598 deletions

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