Change all try's into ?s

This breaks compatibility with < 1.13, but we didn't support that anyway.

9 files changed, 276 insertions, 279 deletions

diff --git a/src/model/channel.rs b/src/model/channel.rs
index 7036a1d..19f59ef 100644
--- a/src/model/channel.rs
+++ b/src/model/channel.rs
@@ -117,10 +117,10 @@ impl Attachment {
     #[cfg(feature = "methods")]
     pub fn download(&self) -> Result<Vec<u8>> {
         let hyper = HyperClient::new();
-        let mut response = try!(hyper.get(&self.url).send());
+        let mut response = hyper.get(&self.url).send()?;
 
         let mut bytes = vec![];
-        try!(response.read_to_end(&mut bytes));
+        response.read_to_end(&mut bytes)?;
 
         Ok(bytes)
     }
@@ -181,11 +181,11 @@ impl Attachment {
     /// [`Message`]: struct.Message.html
     #[cfg(feature = "methods")]
     pub fn download_to_directory<P: AsRef<Path>>(&self, path: P) -> Result<PathBuf> {
-        let bytes = try!(self.download());
+        let bytes = self.download()?;
 
         let filepath: PathBuf = path.as_ref().join(&self.filename);
-        let mut file = try!(File::create(&filepath));
-        try!(file.write(&bytes));
+        let mut file = File::create(&filepath)?;
+        file.write(&bytes)?;
 
         Ok(filepath)
     }
@@ -194,7 +194,7 @@ impl Attachment {
 impl Channel {
     #[doc(hidden)]
     pub fn decode(value: Value) -> Result<Channel> {
-        let map = try!(into_map(value));
+        let map = into_map(value)?;
         match req!(map.get("type").and_then(|x| x.as_u64())) {
             0 | 2 => GuildChannel::decode(Value::Object(map))
                 .map(Channel::Guild),
@@ -217,13 +217,13 @@ impl Channel {
     pub fn delete(&self) -> Result<()> {
         match *self {
             Channel::Group(ref group) => {
-                let _ = try!(group.leave());
+                let _ = group.leave()?;
             },
             Channel::Guild(ref public_channel) => {
-                let _ = try!(public_channel.delete());
+                let _ = public_channel.delete()?;
             },
             Channel::Private(ref private_channel) => {
-                let _ = try!(private_channel.delete());
+                let _ = private_channel.delete()?;
             },
         }
 
@@ -441,7 +441,7 @@ impl Message {
         feature_cache_enabled! {{
             let req = permissions::MANAGE_MESSAGES;
             let is_author = self.author.id != CACHE.read().unwrap().user.id;
-            let has_perms = try!(utils::user_has_perms(self.channel_id, req));
+            let has_perms = utils::user_has_perms(self.channel_id, req)?;
 
             if !is_author && !has_perms {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
@@ -469,7 +469,7 @@ impl Message {
         feature_cache_enabled! {{
             let req = permissions::MANAGE_MESSAGES;
 
-            if !try!(utils::user_has_perms(self.channel_id, req)) {
+            if !utils::user_has_perms(self.channel_id, req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -583,7 +583,7 @@ impl Message {
         feature_cache_enabled! {{
             let req = permissions::MANAGE_MESSAGES;
 
-            if !try!(utils::user_has_perms(self.channel_id, req)) {
+            if !utils::user_has_perms(self.channel_id, req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -610,7 +610,7 @@ impl Message {
         feature_cache_enabled! {{
             let req = permissions::ADD_REACTIONS;
 
-            if !try!(utils::user_has_perms(self.channel_id, req)) {
+            if !utils::user_has_perms(self.channel_id, req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -651,7 +651,7 @@ impl Message {
         feature_cache_enabled! {{
             let req = permissions::SEND_MESSAGES;
 
-            if !try!(utils::user_has_perms(self.channel_id, req)) {
+            if !utils::user_has_perms(self.channel_id, req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -686,7 +686,7 @@ impl Message {
         feature_cache_enabled! {{
             let req = permissions::MANAGE_MESSAGES;
 
-            if !try!(utils::user_has_perms(self.channel_id, req)) {
+            if !utils::user_has_perms(self.channel_id, req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -698,9 +698,9 @@ impl Message {
 impl PermissionOverwrite {
     #[doc(hidden)]
     pub fn decode(value: Value) -> Result<PermissionOverwrite> {
-        let mut map = try!(into_map(value));
-        let id = try!(remove(&mut map, "id").and_then(decode_id));
-        let kind = try!(remove(&mut map, "type").and_then(into_string));
+        let mut map = into_map(value)?;
+        let id = remove(&mut map, "id").and_then(decode_id)?;
+        let kind = remove(&mut map, "type").and_then(into_string)?;
         let kind = match &*kind {
             "member" => PermissionOverwriteType::Member(UserId(id)),
             "role" => PermissionOverwriteType::Role(RoleId(id)),
@@ -709,8 +709,8 @@ impl PermissionOverwrite {
 
         Ok(PermissionOverwrite {
             kind: kind,
-            allow: try!(remove(&mut map, "allow").and_then(Permissions::decode)),
-            deny: try!(remove(&mut map, "deny").and_then(Permissions::decode)),
+            allow: remove(&mut map, "allow").and_then(Permissions::decode)?,
+            deny: remove(&mut map, "deny").and_then(Permissions::decode)?,
         })
     }
 }
@@ -724,15 +724,15 @@ impl PrivateChannel {
 
     #[doc(hidden)]
     pub fn decode(value: Value) -> Result<PrivateChannel> {
-        let mut map = try!(into_map(value));
-        let mut recipients = try!(decode_array(try!(remove(&mut map, "recipients")),
-                                  User::decode));
+        let mut map = into_map(value)?;
+        let mut recipients = decode_array(remove(&mut map, "recipients")?,
+                                  User::decode)?;
 
         Ok(PrivateChannel {
-            id: try!(remove(&mut map, "id").and_then(ChannelId::decode)),
-            kind: try!(remove(&mut map, "type").and_then(ChannelType::decode)),
-            last_message_id: try!(opt(&mut map, "last_message_id", MessageId::decode)),
-            last_pin_timestamp: try!(opt(&mut map, "last_pin_timestamp", into_string)),
+            id: remove(&mut map, "id").and_then(ChannelId::decode)?,
+            kind: remove(&mut map, "type").and_then(ChannelType::decode)?,
+            last_message_id: opt(&mut map, "last_message_id", MessageId::decode)?,
+            last_pin_timestamp: opt(&mut map, "last_pin_timestamp", into_string)?,
             recipient: recipients.remove(0),
         })
     }
@@ -853,7 +853,7 @@ impl GuildChannel {
         feature_cache_enabled! {{
             let req = permissions::CREATE_INVITE;
 
-            if !try!(utils::user_has_perms(self.id, req)) {
+            if !utils::user_has_perms(self.id, req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -865,29 +865,29 @@ impl GuildChannel {
 
     #[doc(hidden)]
     pub fn decode(value: Value) -> Result<GuildChannel> {
-        let mut map = try!(into_map(value));
+        let mut map = into_map(value)?;
 
-        let id = try!(remove(&mut map, "guild_id").and_then(GuildId::decode));
+        let id = remove(&mut map, "guild_id").and_then(GuildId::decode)?;
 
         GuildChannel::decode_guild(Value::Object(map), id)
     }
 
     #[doc(hidden)]
     pub fn decode_guild(value: Value, guild_id: GuildId) -> Result<GuildChannel> {
-        let mut map = try!(into_map(value));
+        let mut map = into_map(value)?;
 
         Ok(GuildChannel {
-            id: try!(remove(&mut map, "id").and_then(ChannelId::decode)),
-            name: try!(remove(&mut map, "name").and_then(into_string)),
+            id: remove(&mut map, "id").and_then(ChannelId::decode)?,
+            name: remove(&mut map, "name").and_then(into_string)?,
             guild_id: guild_id,
-            topic: try!(opt(&mut map, "topic", into_string)),
-            position: req!(try!(remove(&mut map, "position")).as_i64()),
-            kind: try!(remove(&mut map, "type").and_then(ChannelType::decode)),
-            last_message_id: try!(opt(&mut map, "last_message_id", MessageId::decode)),
-            permission_overwrites: try!(decode_array(try!(remove(&mut map, "permission_overwrites")), PermissionOverwrite::decode)),
+            topic: opt(&mut map, "topic", into_string)?,
+            position: req!(remove(&mut map, "position")?.as_i64()),
+            kind: remove(&mut map, "type").and_then(ChannelType::decode)?,
+            last_message_id: opt(&mut map, "last_message_id", MessageId::decode)?,
+            permission_overwrites: decode_array(remove(&mut map, "permission_overwrites")?, PermissionOverwrite::decode)?,
             bitrate: remove(&mut map, "bitrate").ok().and_then(|v| v.as_u64()),
             user_limit: remove(&mut map, "user_limit").ok().and_then(|v| v.as_u64()),
-            last_pin_timestamp: try!(opt(&mut map, "last_pin_timestamp", into_string)),
+            last_pin_timestamp: opt(&mut map, "last_pin_timestamp", into_string)?,
         })
     }
 
@@ -897,7 +897,7 @@ impl GuildChannel {
         let req = permissions::MANAGE_CHANNELS;
 
         feature_cache_enabled! {{
-            if !try!(utils::user_has_perms(self.id, req)) {
+            if !utils::user_has_perms(self.id, req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -924,7 +924,7 @@ impl GuildChannel {
         let req = permissions::MANAGE_CHANNELS;
 
         feature_cache_enabled! {{
-            if !try!(utils::user_has_perms(self.id, req)) {
+            if !utils::user_has_perms(self.id, req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -988,7 +988,7 @@ impl GuildChannel {
         feature_cache_enabled! {{
             let req = permissions::SEND_MESSAGES;
 
-            if !try!(utils::user_has_perms(self.id, req)) {
+            if !utils::user_has_perms(self.id, req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -1151,11 +1151,11 @@ impl ReactionType {
 
     #[doc(hidden)]
     pub fn decode(value: Value) -> Result<Self> {
-        let mut map = try!(into_map(value));
-        let name = try!(remove(&mut map, "name").and_then(into_string));
+        let mut map = into_map(value)?;
+        let name = remove(&mut map, "name").and_then(into_string)?;
 
         // Only custom emoji reactions (`ReactionType::Custom`) have an Id.
-        Ok(match try!(opt(&mut map, "id", EmojiId::decode)) {
+        Ok(match opt(&mut map, "id", EmojiId::decode)? {
             Some(id) => ReactionType::Custom {
                 id: id,
                 name: name,
@@ -1195,11 +1195,11 @@ impl fmt::Display for ReactionType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             ReactionType::Custom { id, ref name } => {
-                try!(f.write_char('<'));
-                try!(f.write_char(':'));
-                try!(f.write_str(&name));
-                try!(f.write_char(':'));
-                try!(fmt::Display::fmt(&id, f));
+                f.write_char('<')?;
+                f.write_char(':')?;
+                f.write_str(&name)?;
+                f.write_char(':')?;
+                fmt::Display::fmt(&id, f)?;
                 f.write_char('>')
             },
             ReactionType::Unicode(ref unicode) => f.write_str(unicode),
diff --git a/src/model/event.rs b/src/model/event.rs
index d459503..4746ed5 100644
--- a/src/model/event.rs
+++ b/src/model/event.rs
@@ -339,27 +339,27 @@ pub enum GatewayEvent {
 
 impl GatewayEvent {
     pub fn decode(value: Value) -> Result<Self> {
-        let mut value = try!(into_map(value));
+        let mut value = into_map(value)?;
 
         let op = req!(value.get("op").and_then(|x| x.as_u64()));
 
-        match try!(OpCode::from_num(op).ok_or(Error::Client(ClientError::InvalidOpCode))) {
+        match OpCode::from_num(op).ok_or(Error::Client(ClientError::InvalidOpCode))? {
             OpCode::Event => Ok(GatewayEvent::Dispatch(
-                req!(try!(remove(&mut value, "s")).as_u64()),
-                try!(Event::decode(
-                    try!(remove(&mut value, "t").and_then(into_string)),
-                    try!(remove(&mut value, "d"))
-                ))
+                req!(remove(&mut value, "s")?.as_u64()),
+                Event::decode(
+                    remove(&mut value, "t").and_then(into_string)?,
+                    remove(&mut value, "d")?
+                )?
             )),
             OpCode::Heartbeat => {
-                Ok(GatewayEvent::Heartbeat(req!(try!(remove(&mut value, "s"))
+                Ok(GatewayEvent::Heartbeat(req!(remove(&mut value, "s")?
                     .as_u64())))
             },
             OpCode::Reconnect => Ok(GatewayEvent::Reconnect),
             OpCode::InvalidSession => Ok(GatewayEvent::InvalidateSession),
             OpCode::Hello => {
-                let mut data = try!(remove(&mut value, "d").and_then(into_map));
-                let interval = req!(try!(remove(&mut data, "heartbeat_interval")).as_u64());
+                let mut data = remove(&mut value, "d").and_then(into_map)?;
+                let interval = req!(remove(&mut data, "heartbeat_interval")?.as_u64());
                 Ok(GatewayEvent::Hello(interval))
             },
             OpCode::HeartbeatAck => Ok(GatewayEvent::HeartbeatAck),
@@ -478,209 +478,209 @@ impl Event {
     fn decode(kind: String, value: Value) -> Result<Event> {
         if kind == "PRESENCES_REPLACE" {
             return Ok(Event::PresencesReplace(PresencesReplaceEvent {
-                presences: try!(decode_array(value, Presence::decode)),
+                presences: decode_array(value, Presence::decode)?,
             }));
         }
 
-        let mut value = try!(into_map(value));
+        let mut value = into_map(value)?;
 
         if kind == "CALL_CREATE" {
             Ok(Event::CallCreate(CallCreateEvent {
-                call: try!(Call::decode(Value::Object(value))),
+                call: Call::decode(Value::Object(value))?,
             }))
         } else if kind == "CALL_DELETE" {
             Ok(Event::CallDelete(CallDeleteEvent {
-                channel_id: try!(remove(&mut value, "channel_id").and_then(ChannelId::decode)),
+                channel_id: remove(&mut value, "channel_id").and_then(ChannelId::decode)?,
             }))
         } else if kind == "CALL_UPDATE" {
             Ok(Event::CallUpdate(CallUpdateEvent {
-                channel_id: try!(remove(&mut value, "channel_id").and_then(ChannelId::decode)),
-                message_id: try!(remove(&mut value, "message_id").and_then(MessageId::decode)),
-                region: try!(remove(&mut value, "region").and_then(into_string)),
-                ringing: try!(decode_array(try!(remove(&mut value, "ringing")), UserId::decode)),
+                channel_id: remove(&mut value, "channel_id").and_then(ChannelId::decode)?,
+                message_id: remove(&mut value, "message_id").and_then(MessageId::decode)?,
+                region: remove(&mut value, "region").and_then(into_string)?,
+                ringing: decode_array(remove(&mut value, "ringing")?, UserId::decode)?,
             }))
         } else if kind == "CHANNEL_CREATE" {
             Ok(Event::ChannelCreate(ChannelCreateEvent {
-                channel: try!(Channel::decode(Value::Object(value))),
+                channel: Channel::decode(Value::Object(value))?,
             }))
         } else if kind == "CHANNEL_DELETE" {
             Ok(Event::ChannelDelete(ChannelDeleteEvent {
-                channel: try!(Channel::decode(Value::Object(value))),
+                channel: Channel::decode(Value::Object(value))?,
             }))
         } else if kind == "CHANNEL_PINS_ACK" {
             Ok(Event::ChannelPinsAck(ChannelPinsAckEvent {
-                channel_id: try!(remove(&mut value, "channel_id").and_then(ChannelId::decode)),
-                timestamp: try!(remove(&mut value, "timestamp").and_then(into_string)),
+                channel_id: remove(&mut value, "channel_id").and_then(ChannelId::decode)?,
+                timestamp: remove(&mut value, "timestamp").and_then(into_string)?,
             }))
         } else if kind == "CHANNEL_PINS_UPDATE" {
             Ok(Event::ChannelPinsUpdate(ChannelPinsUpdateEvent {
-                channel_id: try!(remove(&mut value, "channel_id").and_then(ChannelId::decode)),
-                last_pin_timestamp: try!(opt(&mut value, "last_pin_timestamp", into_string)),
+                channel_id: remove(&mut value, "channel_id").and_then(ChannelId::decode)?,
+                last_pin_timestamp: opt(&mut value, "last_pin_timestamp", into_string)?,
             }))
         } else if kind == "CHANNEL_RECIPIENT_ADD" {
             Ok(Event::ChannelRecipientAdd(ChannelRecipientAddEvent {
-                channel_id: try!(remove(&mut value, "channel_id").and_then(ChannelId::decode)),
-                user: try!(remove(&mut value, "user").and_then(User::decode)),
+                channel_id: remove(&mut value, "channel_id").and_then(ChannelId::decode)?,
+                user: remove(&mut value, "user").and_then(User::decode)?,
             }))
         } else if kind == "CHANNEL_RECIPIENT_REMOVE" {
             Ok(Event::ChannelRecipientRemove(ChannelRecipientRemoveEvent {
-                channel_id: try!(remove(&mut value, "channel_id").and_then(ChannelId::decode)),
-                user: try!(remove(&mut value, "user").and_then(User::decode)),
+                channel_id: remove(&mut value, "channel_id").and_then(ChannelId::decode)?,
+                user: remove(&mut value, "user").and_then(User::decode)?,
             }))
         } else if kind == "CHANNEL_UPDATE" {
             Ok(Event::ChannelUpdate(ChannelUpdateEvent {
-                channel: try!(Channel::decode(Value::Object(value))),
+                channel: Channel::decode(Value::Object(value))?,
             }))
         } else if kind == "FRIEND_SUGGESTION_CREATE" {
             Ok(Event::FriendSuggestionCreate(FriendSuggestionCreateEvent {
-                reasons: try!(decode_array(try!(remove(&mut value, "reasons")), SuggestionReason::decode)),
-                suggested_user: try!(remove(&mut value, "suggested_user").and_then(User::decode)),
+                reasons: decode_array(remove(&mut value, "reasons")?, SuggestionReason::decode)?,
+                suggested_user: remove(&mut value, "suggested_user").and_then(User::decode)?,
             }))
         } else if kind == "FRIEND_SUGGESTION_DELETE" {
             Ok(Event::FriendSuggestionDelete(FriendSuggestionDeleteEvent {
-                suggested_user_id: try!(remove(&mut value, "suggested_user_id").and_then(UserId::decode)),
+                suggested_user_id: remove(&mut value, "suggested_user_id").and_then(UserId::decode)?,
             }))
         } else if kind == "GUILD_BAN_ADD" {
             Ok(Event::GuildBanAdd(GuildBanAddEvent {
-                guild_id: try!(remove(&mut value, "guild_id").and_then(GuildId::decode)),
-                user: try!(remove(&mut value, "user").and_then(User::decode)),
+                guild_id: remove(&mut value, "guild_id").and_then(GuildId::decode)?,
+                user: remove(&mut value, "user").and_then(User::decode)?,
             }))
         } else if kind == "GUILD_BAN_REMOVE" {
             Ok(Event::GuildBanRemove(GuildBanRemoveEvent {
-                guild_id: try!(remove(&mut value, "guild_id").and_then(GuildId::decode)),
-                user: try!(remove(&mut value, "user").and_then(User::decode)),
+                guild_id: remove(&mut value, "guild_id").and_then(GuildId::decode)?,
+                user: remove(&mut value, "user").and_then(User::decode)?,
             }))
         } else if kind == "GUILD_CREATE" {
             if remove(&mut value, "unavailable").ok().and_then(|v| v.as_bool()).unwrap_or(false) {
                 Ok(Event::GuildUnavailable(GuildUnavailableEvent {
-                    guild_id: try!(remove(&mut value, "id").and_then(GuildId::decode)),
+                    guild_id: remove(&mut value, "id").and_then(GuildId::decode)?,
                 }))
             } else {
                 Ok(Event::GuildCreate(GuildCreateEvent {
-                    guild: try!(Guild::decode(Value::Object(value))),
+                    guild: Guild::decode(Value::Object(value))?,
                 }))
             }
         } else if kind == "GUILD_DELETE" {
             if remove(&mut value, "unavailable").ok().and_then(|v| v.as_bool()).unwrap_or(false) {
                 Ok(Event::GuildUnavailable(GuildUnavailableEvent {
-                    guild_id: try!(remove(&mut value, "id").and_then(GuildId::decode)),
+                    guild_id: remove(&mut value, "id").and_then(GuildId::decode)?,
                 }))
             } else {
                 Ok(Event::GuildDelete(GuildDeleteEvent {
-                    guild: try!(PartialGuild::decode(Value::Object(value))),
+                    guild: PartialGuild::decode(Value::Object(value))?,
                 }))
             }
         } else if kind == "GUILD_EMOJIS_UPDATE" {
             Ok(Event::GuildEmojisUpdate(GuildEmojisUpdateEvent {
-                emojis: try!(remove(&mut value, "emojis").and_then(decode_emojis)),
-                guild_id: try!(remove(&mut value, "guild_id").and_then(GuildId::decode)),
+                emojis: remove(&mut value, "emojis").and_then(decode_emojis)?,
+                guild_id: remove(&mut value, "guild_id").and_then(GuildId::decode)?,
             }))
         } else if kind == "GUILD_INTEGRATIONS_UPDATE" {
             Ok(Event::GuildIntegrationsUpdate(GuildIntegrationsUpdateEvent {
-                guild_id: try!(remove(&mut value, "guild_id").and_then(GuildId::decode)),
+                guild_id: remove(&mut value, "guild_id").and_then(GuildId::decode)?,
             }))
         } else if kind == "GUILD_MEMBER_ADD" {
             Ok(Event::GuildMemberAdd(GuildMemberAddEvent {
-                guild_id: try!(remove(&mut value, "guild_id").and_then(GuildId::decode)),
-                member: try!(Member::decode(Value::Object(value))),
+                guild_id: remove(&mut value, "guild_id").and_then(GuildId::decode)?,
+                member: Member::decode(Value::Object(value))?,
             }))
         } else if kind == "GUILD_MEMBER_REMOVE" {
             Ok(Event::GuildMemberRemove(GuildMemberRemoveEvent {
-                guild_id: try!(remove(&mut value, "guild_id").and_then(GuildId::decode)),
-                user: try!(remove(&mut value, "user").and_then(User::decode)),
+                guild_id: remove(&mut value, "guild_id").and_then(GuildId::decode)?,
+                user: remove(&mut value, "user").and_then(User::decode)?,
             }))
         } else if kind == "GUILD_MEMBER_UPDATE" {
             Ok(Event::GuildMemberUpdate(GuildMemberUpdateEvent {
-                guild_id: try!(remove(&mut value, "guild_id").and_then(GuildId::decode)),
-                nick: try!(opt(&mut value, "nick", into_string)),
-                roles: try!(decode_array(try!(remove(&mut value, "roles")), RoleId::decode)),
-                user: try!(remove(&mut value, "user").and_then(User::decode)),
+                guild_id: remove(&mut value, "guild_id").and_then(GuildId::decode)?,
+                nick: opt(&mut value, "nick", into_string)?,
+                roles: decode_array(remove(&mut value, "roles")?, RoleId::decode)?,
+                user: remove(&mut value, "user").and_then(User::decode)?,
             }))
         } else if kind == "GUILD_MEMBERS_CHUNK" {
             Ok(Event::GuildMembersChunk(GuildMembersChunkEvent {
-                guild_id: try!(remove(&mut value, "guild_id").and_then(GuildId::decode)),
-                members: try!(remove(&mut value, "members").and_then(decode_members)),
+                guild_id: remove(&mut value, "guild_id").and_then(GuildId::decode)?,
+                members: remove(&mut value, "members").and_then(decode_members)?,
             }))
         } else if kind == "GUILD_ROLE_CREATE" {
             Ok(Event::GuildRoleCreate(GuildRoleCreateEvent {
-                guild_id: try!(remove(&mut value, "guild_id").and_then(GuildId::decode)),
-                role: try!(remove(&mut value, "role").and_then(Role::decode)),
+                guild_id: remove(&mut value, "guild_id").and_then(GuildId::decode)?,
+                role: remove(&mut value, "role").and_then(Role::decode)?,
             }))
         } else if kind == "GUILD_ROLE_DELETE" {
             Ok(Event::GuildRoleDelete(GuildRoleDeleteEvent {
-                guild_id: try!(remove(&mut value, "guild_id").and_then(GuildId::decode)),
-                role_id: try!(remove(&mut value, "role_id").and_then(RoleId::decode)),
+                guild_id: remove(&mut value, "guild_id").and_then(GuildId::decode)?,
+                role_id: remove(&mut value, "role_id").and_then(RoleId::decode)?,
             }))
         } else if kind == "GUILD_ROLE_UPDATE" {
             Ok(Event::GuildRoleUpdate(GuildRoleUpdateEvent {
-                guild_id: try!(remove(&mut value, "guild_id").and_then(GuildId::decode)),
-                role: try!(remove(&mut value, "role").and_then(Role::decode)),
+                guild_id: remove(&mut value, "guild_id").and_then(GuildId::decode)?,
+                role: remove(&mut value, "role").and_then(Role::decode)?,
             }))
         } else if kind == "GUILD_SYNC" {
             Ok(Event::GuildSync(GuildSyncEvent {
-                guild_id: try!(remove(&mut value, "id").and_then(GuildId::decode)),
-                large: req!(try!(remove(&mut value, "large")).as_bool()),
-                members: try!(remove(&mut value, "members").and_then(decode_members)),
-                presences: try!(remove(&mut value, "presences").and_then(decode_presences)),
+                guild_id: remove(&mut value, "id").and_then(GuildId::decode)?,
+                large: req!(remove(&mut value, "large")?.as_bool()),
+                members: remove(&mut value, "members").and_then(decode_members)?,
+                presences: remove(&mut value, "presences").and_then(decode_presences)?,
             }))
         } else if kind == "GUILD_UPDATE" {
             Ok(Event::GuildUpdate(GuildUpdateEvent {
-                guild: try!(PartialGuild::decode(Value::Object(value))),
+                guild: PartialGuild::decode(Value::Object(value))?,
             }))
         } else if kind == "MESSAGE_ACK" {
             Ok(Event::MessageAck(MessageAckEvent {
-                channel_id: try!(remove(&mut value, "channel_id").and_then(ChannelId::decode)),
-                message_id: try!(opt(&mut value, "message_id", MessageId::decode)),
+                channel_id: remove(&mut value, "channel_id").and_then(ChannelId::decode)?,
+                message_id: opt(&mut value, "message_id", MessageId::decode)?,
             }))
         } else if kind == "MESSAGE_CREATE" {
             Ok(Event::MessageCreate(MessageCreateEvent {
-                message: try!(Message::decode(Value::Object(value))),
+                message: Message::decode(Value::Object(value))?,
             }))
         } else if kind == "MESSAGE_DELETE" {
             Ok(Event::MessageDelete(MessageDeleteEvent {
-                channel_id: try!(remove(&mut value, "channel_id").and_then(ChannelId::decode)),
-                message_id: try!(remove(&mut value, "id").and_then(MessageId::decode)),
+                channel_id: remove(&mut value, "channel_id").and_then(ChannelId::decode)?,
+                message_id: remove(&mut value, "id").and_then(MessageId::decode)?,
             }))
         } else if kind == "MESSAGE_DELETE_BULK" {
             Ok(Event::MessageDeleteBulk(MessageDeleteBulkEvent {
-                channel_id: try!(remove(&mut value, "channel_id").and_then(ChannelId::decode)),
-                ids: try!(decode_array(try!(remove(&mut value, "ids")), MessageId::decode)),
+                channel_id: remove(&mut value, "channel_id").and_then(ChannelId::decode)?,
+                ids: decode_array(remove(&mut value, "ids")?, MessageId::decode)?,
             }))
         } else if kind == "MESSAGE_REACTION_ADD" {
             Ok(Event::ReactionAdd(ReactionAddEvent {
-                reaction: try!(Reaction::decode(Value::Object(value)))
+                reaction: Reaction::decode(Value::Object(value))?
             }))
         } else if kind == "MESSAGE_REACTION_REMOVE" {
             Ok(Event::ReactionRemove(ReactionRemoveEvent {
-                reaction: try!(Reaction::decode(Value::Object(value)))
+                reaction: Reaction::decode(Value::Object(value))?
             }))
         } else if kind == "MESSAGE_REACTION_REMOVE_ALL" {
             Ok(Event::ReactionRemoveAll(ReactionRemoveAllEvent {
-                channel_id: try!(remove(&mut value, "channel_id").and_then(ChannelId::decode)),
-                message_id: try!(remove(&mut value, "message_id").and_then(MessageId::decode)),
+                channel_id: remove(&mut value, "channel_id").and_then(ChannelId::decode)?,
+                message_id: remove(&mut value, "message_id").and_then(MessageId::decode)?,
             }))
         } else if kind == "MESSAGE_UPDATE" {
             Ok(Event::MessageUpdate(MessageUpdateEvent {
-                id: try!(remove(&mut value, "id").and_then(MessageId::decode)),
-                channel_id: try!(remove(&mut value, "channel_id").and_then(ChannelId::decode)),
-                kind: try!(opt(&mut value, "type", MessageType::decode)),
-                content: try!(opt(&mut value, "content", into_string)),
+                id: remove(&mut value, "id").and_then(MessageId::decode)?,
+                channel_id: remove(&mut value, "channel_id").and_then(ChannelId::decode)?,
+                kind: opt(&mut value, "type", MessageType::decode)?,
+                content: opt(&mut value, "content", into_string)?,
                 nonce: remove(&mut value, "nonce").and_then(into_string).ok(),
                 tts: remove(&mut value, "tts").ok().and_then(|v| v.as_bool()),
                 pinned: remove(&mut value, "pinned").ok().and_then(|v| v.as_bool()),
-                timestamp: try!(opt(&mut value, "timestamp", into_string)),
-                edited_timestamp: try!(opt(&mut value, "edited_timestamp", into_string)),
-                author: try!(opt(&mut value, "author", User::decode)),
+                timestamp: opt(&mut value, "timestamp", into_string)?,
+                edited_timestamp: opt(&mut value, "edited_timestamp", into_string)?,
+                author: opt(&mut value, "author", User::decode)?,
                 mention_everyone: remove(&mut value, "mention_everyone").ok().and_then(|v| v.as_bool()),
-                mentions: try!(opt(&mut value, "mentions", |v| decode_array(v, User::decode))),
-                mention_roles: try!(opt(&mut value, "mention_roles", |v| decode_array(v, RoleId::decode))),
-                attachments: try!(opt(&mut value, "attachments", |v| decode_array(v, Attachment::decode))),
-                embeds: try!(opt(&mut value, "embeds", |v| decode_array(v, Ok))),
+                mentions: opt(&mut value, "mentions", |v| decode_array(v, User::decode))?,
+                mention_roles: opt(&mut value, "mention_roles", |v| decode_array(v, RoleId::decode))?,
+                attachments: opt(&mut value, "attachments", |v| decode_array(v, Attachment::decode))?,
+                embeds: opt(&mut value, "embeds", |v| decode_array(v, Ok))?,
             }))
         } else if kind == "PRESENCE_UPDATE" {
-            let guild_id = try!(opt(&mut value, "guild_id", GuildId::decode));
-            let roles = try!(opt(&mut value, "roles", |v| decode_array(v, RoleId::decode)));
-            let presence = try!(Presence::decode(Value::Object(value)));
+            let guild_id = opt(&mut value, "guild_id", GuildId::decode)?;
+            let roles = opt(&mut value, "roles", |v| decode_array(v, RoleId::decode))?;
+            let presence = Presence::decode(Value::Object(value))?;
             Ok(Event::PresenceUpdate(PresenceUpdateEvent {
                 guild_id: guild_id,
                 presence: presence,
@@ -688,70 +688,70 @@ impl Event {
             }))
         } else if kind == "RELATIONSHIP_ADD" {
             Ok(Event::RelationshipAdd(RelationshipAddEvent {
-                relationship: try!(Relationship::decode(Value::Object(value))),
+                relationship: Relationship::decode(Value::Object(value))?,
             }))
         } else if kind == "RELATIONSHIP_REMOVE" {
             Ok(Event::RelationshipRemove(RelationshipRemoveEvent {
-                kind: try!(remove(&mut value, "type").and_then(RelationshipType::decode)),
-                user_id: try!(remove(&mut value, "id").and_then(UserId::decode)),
+                kind: remove(&mut value, "type").and_then(RelationshipType::decode)?,
+                user_id: remove(&mut value, "id").and_then(UserId::decode)?,
             }))
         } else if kind == "READY" {
             Ok(Event::Ready(ReadyEvent {
-                ready: try!(Ready::decode(Value::Object(value))),
+                ready: Ready::decode(Value::Object(value))?,
             }))
         } else if kind == "RESUMED" {
             Ok(Event::Resumed(ResumedEvent {
-                heartbeat_interval: req!(try!(remove(&mut value, "heartbeat_interval")).as_u64()),
-                trace: try!(remove(&mut value, "_trace").and_then(|v| decode_array(v, |v| Ok(into_string(v).ok())))),
+                heartbeat_interval: req!(remove(&mut value, "heartbeat_interval")?.as_u64()),
+                trace: remove(&mut value, "_trace").and_then(|v| decode_array(v, |v| Ok(into_string(v).ok())))?,
             }))
         } else if kind == "TYPING_START" {
             Ok(Event::TypingStart(TypingStartEvent {
-                channel_id: try!(remove(&mut value, "channel_id").and_then(ChannelId::decode)),
-                timestamp: req!(try!(remove(&mut value, "timestamp")).as_u64()),
-                user_id: try!(remove(&mut value, "user_id").and_then(UserId::decode)),
+                channel_id: remove(&mut value, "channel_id").and_then(ChannelId::decode)?,
+                timestamp: req!(remove(&mut value, "timestamp")?.as_u64()),
+                user_id: remove(&mut value, "user_id").and_then(UserId::decode)?,
             }))
         } else if kind == "USER_GUILD_SETTINGS_UPDATE" {
             Ok(Event::UserGuildSettingsUpdate(UserGuildSettingsUpdateEvent {
-                settings: try!(UserGuildSettings::decode(Value::Object(value))),
+                settings: UserGuildSettings::decode(Value::Object(value))?,
             }))
         } else if kind == "USER_NOTE_UPDATE" {
             Ok(Event::UserNoteUpdate(UserNoteUpdateEvent {
-                note: try!(remove(&mut value, "note").and_then(into_string)),
-                user_id: try!(remove(&mut value, "id").and_then(UserId::decode)),
+                note: remove(&mut value, "note").and_then(into_string)?,
+                user_id: remove(&mut value, "id").and_then(UserId::decode)?,
             }))
         } else if kind == "USER_SETTINGS_UPDATE" {
             Ok(Event::UserSettingsUpdate(UserSettingsUpdateEvent {
                 enable_tts_command: remove(&mut value, "enable_tts_command").ok().and_then(|v| v.as_bool()),
                 inline_attachment_media: remove(&mut value, "inline_attachment_media").ok().and_then(|v| v.as_bool()),
                 inline_embed_media: remove(&mut value, "inline_embed_media").ok().and_then(|v| v.as_bool()),
-                locale: try!(opt(&mut value, "locale", into_string)),
+                locale: opt(&mut value, "locale", into_string)?,
                 message_display_compact: remove(&mut value, "message_display_compact").ok().and_then(|v| v.as_bool()),
                 render_embeds: remove(&mut value, "render_embeds").ok().and_then(|v| v.as_bool()),
                 show_current_game: remove(&mut value, "show_current_game").ok().and_then(|v| v.as_bool()),
-                theme: try!(opt(&mut value, "theme", into_string)),
+                theme: opt(&mut value, "theme", into_string)?,
                 convert_emoticons: remove(&mut value, "convert_emoticons").ok().and_then(|v| v.as_bool()),
-                friend_source_flags: try!(opt(&mut value, "friend_source_flags", FriendSourceFlags::decode)),
+                friend_source_flags: opt(&mut value, "friend_source_flags", FriendSourceFlags::decode)?,
             }))
         } else if kind == "USER_UPDATE" {
             Ok(Event::UserUpdate(UserUpdateEvent {
-                current_user: try!(CurrentUser::decode(Value::Object(value))),
+                current_user: CurrentUser::decode(Value::Object(value))?,
             }))
         } else if kind == "VOICE_SERVER_UPDATE" {
             Ok(Event::VoiceServerUpdate(VoiceServerUpdateEvent {
-                guild_id: try!(opt(&mut value, "guild_id", GuildId::decode)),
-                channel_id: try!(opt(&mut value, "channel_id", ChannelId::decode)),
-                endpoint: try!(opt(&mut value, "endpoint", into_string)),
-                token: try!(remove(&mut value, "token").and_then(into_string)),
+                guild_id: opt(&mut value, "guild_id", GuildId::decode)?,
+                channel_id: opt(&mut value, "channel_id", ChannelId::decode)?,
+                endpoint: opt(&mut value, "endpoint", into_string)?,
+                token: remove(&mut value, "token").and_then(into_string)?,
             }))
         } else if kind == "VOICE_STATE_UPDATE" {
             Ok(Event::VoiceStateUpdate(VoiceStateUpdateEvent {
-                guild_id: try!(opt(&mut value, "guild_id", GuildId::decode)),
-                voice_state: try!(VoiceState::decode(Value::Object(value))),
+                guild_id: opt(&mut value, "guild_id", GuildId::decode)?,
+                voice_state: VoiceState::decode(Value::Object(value))?,
             }))
         } else if kind == "WEBHOOKS_UPDATE" {
             Ok(Event::WebhookUpdate(WebhookUpdateEvent {
-                channel_id: try!(remove(&mut value, "channel_id").and_then(ChannelId::decode)),
-                guild_id: try!(remove(&mut value, "guild_id").and_then(GuildId::decode)),
+                channel_id: remove(&mut value, "channel_id").and_then(ChannelId::decode)?,
+                guild_id: remove(&mut value, "guild_id").and_then(GuildId::decode)?,
             }))
         } else {
             Ok(Event::Unknown(UnknownEvent {
@@ -801,47 +801,47 @@ pub enum VoiceEvent {
 
 impl VoiceEvent {
     pub fn decode(value: Value) -> Result<VoiceEvent> {
-        let mut value = try!(into_map(value));
-        let op = req!(try!(remove(&mut value, "op")).as_u64());
-        let mut map = try!(remove(&mut value, "d").and_then(into_map));
+        let mut value = into_map(value)?;
+        let op = req!(remove(&mut value, "op")?.as_u64());
+        let mut map = remove(&mut value, "d").and_then(into_map)?;
 
-        let opcode = try!(VoiceOpCode::from_num(op)
-            .ok_or(Error::Client(ClientError::InvalidOpCode)));
+        let opcode = VoiceOpCode::from_num(op)
+            .ok_or(Error::Client(ClientError::InvalidOpCode))?;
 
         match opcode {
             VoiceOpCode::Heartbeat => {
                 Ok(VoiceEvent::Heartbeat(VoiceHeartbeat {
-                    heartbeat_interval: req!(try!(remove(&mut map, "heartbeat_interval")).as_u64()),
+                    heartbeat_interval: req!(remove(&mut map, "heartbeat_interval")?.as_u64()),
                 }))
             },
             VoiceOpCode::Hello => {
                 Ok(VoiceEvent::Hello(VoiceHello {
-                    heartbeat_interval: req!(try!(remove(&mut map, "heartbeat_interval"))
+                    heartbeat_interval: req!(remove(&mut map, "heartbeat_interval")?
                         .as_u64()),
-                    ip: try!(remove(&mut map, "ip").and_then(into_string)),
-                    modes: try!(decode_array(try!(remove(&mut map, "modes")),
-                                             into_string)),
-                    port: req!(try!(remove(&mut map, "port"))
+                    ip: remove(&mut map, "ip").and_then(into_string)?,
+                    modes: decode_array(remove(&mut map, "modes")?,
+                                             into_string)?,
+                    port: req!(remove(&mut map, "port")?
                         .as_u64()) as u16,
-                    ssrc: req!(try!(remove(&mut map, "ssrc"))
+                    ssrc: req!(remove(&mut map, "ssrc")?
                         .as_u64()) as u32,
                 }))
             },
             VoiceOpCode::KeepAlive => Ok(VoiceEvent::KeepAlive),
             VoiceOpCode::SessionDescription => {
                 Ok(VoiceEvent::Ready(VoiceReady {
-                    mode: try!(remove(&mut map, "mode")
-                        .and_then(into_string)),
-                    secret_key: try!(decode_array(try!(remove(&mut map, "secret_key")),
+                    mode: remove(&mut map, "mode")
+                        .and_then(into_string)?,
+                    secret_key: decode_array(remove(&mut map, "secret_key")?,
                         |v| Ok(req!(v.as_u64()) as u8)
-                    )),
+                    )?,
                 }))
             },
             VoiceOpCode::Speaking => {
                 Ok(VoiceEvent::Speaking(VoiceSpeaking {
-                    speaking: req!(try!(remove(&mut map, "speaking")).as_bool()),
-                    ssrc: req!(try!(remove(&mut map, "ssrc")).as_u64()) as u32,
-                    user_id: try!(remove(&mut map, "user_id").and_then(UserId::decode)),
+                    speaking: req!(remove(&mut map, "speaking")?.as_bool()),
+                    ssrc: req!(remove(&mut map, "ssrc")?.as_u64()) as u32,
+                    user_id: remove(&mut map, "user_id").and_then(UserId::decode)?,
                 }))
             }
             other => Ok(VoiceEvent::Unknown(other, Value::Object(map))),
diff --git a/src/model/gateway.rs b/src/model/gateway.rs
index 0b64e24..67a9a42 100644
--- a/src/model/gateway.rs
+++ b/src/model/gateway.rs
@@ -29,11 +29,11 @@ impl Game {
 
     #[doc(hidden)]
     pub fn decode(value: Value) -> Result<Option<Game>> {
-        let mut map = try!(into_map(value));
+        let mut map = into_map(value)?;
 
         let name = match map.remove("name") {
             Some(Value::Null) | None => return Ok(None),
-            Some(v) => try!(into_string(v)),
+            Some(v) => into_string(v)?,
         };
 
         if name.trim().is_empty() {
@@ -42,8 +42,8 @@ impl Game {
 
         Ok(Some(Game {
             name: name,
-            kind: try!(opt(&mut map, "type", GameType::decode)).unwrap_or(GameType::Playing),
-            url: try!(opt(&mut map, "url", into_string)),
+            kind: opt(&mut map, "type", GameType::decode)?.unwrap_or(GameType::Playing),
+            url: opt(&mut map, "url", into_string)?,
         }))
     }
 }
@@ -51,28 +51,28 @@ impl Game {
 impl Presence {
     #[doc(hidden)]
     pub fn decode(value: Value) -> Result<Presence> {
-        let mut value = try!(into_map(value));
-        let mut user_map = try!(remove(&mut value, "user").and_then(into_map));
+        let mut value = into_map(value)?;
+        let mut user_map = remove(&mut value, "user").and_then(into_map)?;
 
         let (user_id, user) = if user_map.len() > 1 {
-            let user = try!(User::decode(Value::Object(user_map)));
+            let user = User::decode(Value::Object(user_map))?;
             (user.id, Some(user))
         } else {
-            (try!(remove(&mut user_map, "id").and_then(UserId::decode)), None)
+            (remove(&mut user_map, "id").and_then(UserId::decode)?, None)
         };
 
         let game = match value.remove("game") {
             None | Some(Value::Null) => None,
-            Some(v) => try!(Game::decode(v)),
+            Some(v) => Game::decode(v)?,
         };
 
         Ok(Presence {
             user_id: user_id,
-            status: try!(remove(&mut value, "status").and_then(OnlineStatus::decode_str)),
-            last_modified: try!(opt(&mut value, "last_modified", |v| Ok(req!(v.as_u64())))),
+            status: remove(&mut value, "status").and_then(OnlineStatus::decode_str)?,
+            last_modified: opt(&mut value, "last_modified", |v| Ok(req!(v.as_u64())))?,
             game: game,
             user: user,
-            nick: try!(opt(&mut value, "nick", into_string)),
+            nick: opt(&mut value, "nick", into_string)?,
         })
     }
 }
diff --git a/src/model/guild.rs b/src/model/guild.rs
index f11cc80..d0627eb 100644
--- a/src/model/guild.rs
+++ b/src/model/guild.rs
@@ -112,10 +112,10 @@ impl fmt::Display for Emoji {
     ///
     /// This is in the format of: `<:NAME:EMOJI_ID>`.
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(f.write_str("<:"));
-        try!(f.write_str(&self.name));
-        try!(fmt::Write::write_char(f, ':'));
-        try!(fmt::Display::fmt(&self.id, f));
+        f.write_str("<:")?;
+        f.write_str(&self.name)?;
+        fmt::Write::write_char(f, ':')?;
+        fmt::Display::fmt(&self.id, f)?;
         fmt::Write::write_char(f, '>')
     }
 }
@@ -222,7 +222,7 @@ impl Guild {
         feature_cache_enabled! {{
             let req = permissions::BAN_MEMBERS;
 
-            if !try!(self.has_perms(req)) {
+            if !self.has_perms(req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -247,7 +247,7 @@ impl Guild {
         feature_cache_enabled! {{
             let req = permissions::BAN_MEMBERS;
 
-            if !try!(self.has_perms(req)) {
+            if !self.has_perms(req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -283,7 +283,7 @@ impl Guild {
         feature_cache_enabled! {{
             let req = permissions::MANAGE_CHANNELS;
 
-            if !try!(self.has_perms(req)) {
+            if !self.has_perms(req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -317,12 +317,12 @@ impl Guild {
         feature_cache_enabled! {{
             let req = permissions::MANAGE_ROLES;
 
-            if !try!(self.has_perms(req)) {
+            if !self.has_perms(req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
 
-        let role = try!(rest::create_role(self.id.0));
+        let role = rest::create_role(self.id.0)?;
         let map = f(EditRole::new(&role)).0.build();
 
         rest::edit_role(self.id.0, role.id.0, map)
@@ -330,15 +330,15 @@ impl Guild {
 
     #[doc(hidden)]
     pub fn decode(value: Value) -> Result<Guild> {
-        let mut map = try!(into_map(value));
+        let mut map = into_map(value)?;
 
-        let id = try!(remove(&mut map, "id").and_then(GuildId::decode));
+        let id = remove(&mut map, "id").and_then(GuildId::decode)?;
 
         let public_channels = {
             let mut public_channels = HashMap::new();
 
-            let vals = try!(decode_array(try!(remove(&mut map, "channels")),
-                |v| GuildChannel::decode_guild(v, id)));
+            let vals = decode_array(remove(&mut map, "channels")?,
+                |v| GuildChannel::decode_guild(v, id))?;
 
             for public_channel in vals {
                 public_channels.insert(public_channel.id, public_channel);
@@ -348,27 +348,27 @@ impl Guild {
         };
 
         Ok(Guild {
-            afk_channel_id: try!(opt(&mut map, "afk_channel_id", ChannelId::decode)),
-            afk_timeout: req!(try!(remove(&mut map, "afk_timeout")).as_u64()),
+            afk_channel_id: opt(&mut map, "afk_channel_id", ChannelId::decode)?,
+            afk_timeout: req!(remove(&mut map, "afk_timeout")?.as_u64()),
             channels: public_channels,
-            default_message_notifications: req!(try!(remove(&mut map, "default_message_notifications")).as_u64()),
-            emojis: try!(remove(&mut map, "emojis").and_then(decode_emojis)),
-            features: try!(remove(&mut map, "features").and_then(|v| decode_array(v, Feature::decode_str))),
-            icon: try!(opt(&mut map, "icon", into_string)),
+            default_message_notifications: req!(remove(&mut map, "default_message_notifications")?.as_u64()),
+            emojis: remove(&mut map, "emojis").and_then(decode_emojis)?,
+            features: remove(&mut map, "features").and_then(|v| decode_array(v, Feature::decode_str))?,
+            icon: opt(&mut map, "icon", into_string)?,
             id: id,
-            joined_at: try!(remove(&mut map, "joined_at").and_then(into_string)),
-            large: req!(try!(remove(&mut map, "large")).as_bool()),
-            member_count: req!(try!(remove(&mut map, "member_count")).as_u64()),
-            members: try!(remove(&mut map, "members").and_then(decode_members)),
-            mfa_level: req!(try!(remove(&mut map, "mfa_level")).as_u64()),
-            name: try!(remove(&mut map, "name").and_then(into_string)),
-            owner_id: try!(remove(&mut map, "owner_id").and_then(UserId::decode)),
-            presences: try!(remove(&mut map, "presences").and_then(decode_presences)),
-            region: try!(remove(&mut map, "region").and_then(into_string)),
-            roles: try!(remove(&mut map, "roles").and_then(decode_roles)),
-            splash: try!(opt(&mut map, "splash", into_string)),
-            verification_level: try!(remove(&mut map, "verification_level").and_then(VerificationLevel::decode)),
-            voice_states: try!(remove(&mut map, "voice_states").and_then(decode_voice_states)),
+            joined_at: remove(&mut map, "joined_at").and_then(into_string)?,
+            large: req!(remove(&mut map, "large")?.as_bool()),
+            member_count: req!(remove(&mut map, "member_count")?.as_u64()),
+            members: remove(&mut map, "members").and_then(decode_members)?,
+            mfa_level: req!(remove(&mut map, "mfa_level")?.as_u64()),
+            name: remove(&mut map, "name").and_then(into_string)?,
+            owner_id: remove(&mut map, "owner_id").and_then(UserId::decode)?,
+            presences: remove(&mut map, "presences").and_then(decode_presences)?,
+            region: remove(&mut map, "region").and_then(into_string)?,
+            roles: remove(&mut map, "roles").and_then(decode_roles)?,
+            splash: opt(&mut map, "splash", into_string)?,
+            verification_level: remove(&mut map, "verification_level").and_then(VerificationLevel::decode)?,
+            voice_states: remove(&mut map, "voice_states").and_then(decode_voice_states)?,
         })
     }
 
@@ -417,7 +417,7 @@ impl Guild {
         feature_cache_enabled! {{
             let req = permissions::MANAGE_GUILD;
 
-            if !try!(self.has_perms(req)) {
+            if !self.has_perms(req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -465,7 +465,7 @@ impl Guild {
         feature_cache_enabled! {{
             let req = permissions::CHANGE_NICKNAME;
 
-            if !try!(self.has_perms(req)) {
+            if !self.has_perms(req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -497,7 +497,7 @@ impl Guild {
         feature_cache_enabled! {{
             let req = permissions::MANAGE_GUILD;
 
-            if !try!(self.has_perms(req)) {
+            if !self.has_perms(req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -701,7 +701,7 @@ impl Guild {
         feature_cache_enabled! {{
             let req = permissions::KICK_MEMBERS;
 
-            if !try!(self.has_perms(req)) {
+            if !self.has_perms(req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -733,7 +733,7 @@ impl Guild {
         feature_cache_enabled! {{
             let req = permissions::KICK_MEMBERS;
 
-            if !try!(self.has_perms(req)) {
+            if !self.has_perms(req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -762,7 +762,7 @@ impl Guild {
         feature_cache_enabled! {{
             let req = permissions::BAN_MEMBERS;
 
-            if !try!(self.has_perms(req)) {
+            if !self.has_perms(req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -798,7 +798,7 @@ impl Member {
             return Ok(());
         }
 
-        let guild_id = try!(self.find_guild());
+        let guild_id = self.find_guild()?;
 
         match rest::add_member_role(guild_id.0, self.user.id.0, role_id.0) {
             Ok(()) => {
@@ -819,7 +819,7 @@ impl Member {
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[cfg(all(feature = "cache", feature = "methods"))]
     pub fn add_roles(&mut self, role_ids: &[RoleId]) -> Result<()> {
-        let guild_id = try!(self.find_guild());
+        let guild_id = self.find_guild()?;
         self.roles.extend_from_slice(role_ids);
 
         let map = EditMember::default().roles(&self.roles).0.build();
@@ -842,7 +842,7 @@ impl Member {
     /// [Ban Members]: permissions/constant.BAN_MEMBERS.html
     #[cfg(all(feature = "cache", feature = "methods"))]
     pub fn ban(&self, delete_message_days: u8) -> Result<()> {
-        let guild_id = try!(self.find_guild());
+        let guild_id = self.find_guild()?;
 
         rest::ban_user(guild_id.0,
                        self.user.id.0,
@@ -892,7 +892,7 @@ impl Member {
     #[cfg(all(feature = "cache", feature = "methods"))]
     pub fn edit<F>(&self, f: F) -> Result<()>
         where F: FnOnce(EditMember) -> EditMember {
-        let guild_id = try!(self.find_guild());
+        let guild_id = self.find_guild()?;
         let map = f(EditMember::default()).0.build();
 
         rest::edit_member(guild_id.0, self.user.id.0, map)
@@ -936,7 +936,7 @@ impl Member {
             return Ok(());
         }
 
-        let guild_id = try!(self.find_guild());
+        let guild_id = self.find_guild()?;
 
         match rest::remove_member_role(guild_id.0, self.user.id.0, role_id.0) {
             Ok(()) => {
@@ -956,7 +956,7 @@ impl Member {
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[cfg(all(feature = "cache", feature = "methods"))]
     pub fn remove_roles(&mut self, role_ids: &[RoleId]) -> Result<()> {
-        let guild_id = try!(self.find_guild());
+        let guild_id = self.find_guild()?;
         self.roles.retain(|r| !role_ids.contains(r));
 
         let map = EditMember::default().roles(&self.roles).0.build();
@@ -1011,7 +1011,7 @@ impl fmt::Display for Member {
 impl PossibleGuild<Guild> {
     #[doc(hidden)]
     pub fn decode(value: Value) -> Result<Self> {
-        let mut value = try!(into_map(value));
+        let mut value = into_map(value)?;
         if remove(&mut value, "unavailable").ok().and_then(|v| v.as_bool()).unwrap_or(false) {
             remove(&mut value, "id").and_then(GuildId::decode).map(PossibleGuild::Offline)
         } else {
@@ -1033,7 +1033,7 @@ impl PossibleGuild<Guild> {
 impl PossibleGuild<PartialGuild> {
     #[doc(hidden)]
     pub fn decode(value: Value) -> Result<Self> {
-        let mut value = try!(into_map(value));
+        let mut value = into_map(value)?;
         if remove(&mut value, "unavailable").ok().and_then(|v| v.as_bool()).unwrap_or(false) {
             remove(&mut value, "id").and_then(GuildId::decode).map(PossibleGuild::Offline)
         } else {
@@ -1060,7 +1060,7 @@ impl Role {
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[cfg(all(feature = "cache", feature = "methods"))]
     pub fn delete(&self) -> Result<()> {
-        let guild_id = try!(self.find_guild());
+        let guild_id = self.find_guild()?;
 
         rest::delete_role(guild_id.0, self.id.0)
     }
diff --git a/src/model/invite.rs b/src/model/invite.rs
index c05b4d4..64fa44d 100644
--- a/src/model/invite.rs
+++ b/src/model/invite.rs
@@ -55,7 +55,7 @@ impl Invite {
         feature_cache_enabled! {{
             let req = permissions::MANAGE_GUILD;
 
-            if !try!(utils::user_has_perms(self.channel.id, req)) {
+            if !utils::user_has_perms(self.channel.id, req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
@@ -117,7 +117,7 @@ impl RichInvite {
         let req = permissions::MANAGE_GUILD;
 
         feature_cache_enabled! {{
-            if !try!(utils::user_has_perms(self.channel.id, req)) {
+            if !utils::user_has_perms(self.channel.id, req)? {
                 return Err(Error::Client(ClientError::InvalidPermissions(req)));
             }
         }}
diff --git a/src/model/mod.rs b/src/model/mod.rs
index b5eda3c..298912f 100644
--- a/src/model/mod.rs
+++ b/src/model/mod.rs
@@ -26,7 +26,6 @@ mod guild;
 mod id;
 mod misc;
 mod user;
-mod voice;
 
 #[cfg(feature = "methods")]
 mod invite;
@@ -40,7 +39,6 @@ pub use self::id::*;
 pub use self::misc::*;
 pub use self::permissions::Permissions;
 pub use self::user::*;
-pub use self::voice::*;
 
 #[cfg(feature = "methods")]
 pub use self::invite::*;
diff --git a/src/model/user.rs b/src/model/user.rs
index da50e46..f5906ab 100644
--- a/src/model/user.rs
+++ b/src/model/user.rs
@@ -133,14 +133,14 @@ impl User {
                     .insert("recipient_id", self.id.0)
                     .build();
 
-                try!(rest::create_private_channel(map)).id
+                rest::create_private_channel(map)?.id
             }
         } else {
             let map = ObjectBuilder::new()
                 .insert("recipient_id", self.id.0)
                 .build();
 
-            try!(rest::create_private_channel(map)).id
+            rest::create_private_channel(map)?.id
         }};
 
         let map = ObjectBuilder::new()
@@ -210,24 +210,24 @@ impl fmt::Display for User {
 impl UserSettings {
     #[doc(hidden)]
     pub fn decode(value: Value) -> Result<Option<UserSettings>> {
-        let mut map = try!(into_map(value));
+        let mut map = into_map(value)?;
 
         if map.is_empty() {
             return Ok(None);
         }
 
         Ok(UserSettings {
-            convert_emoticons: req!(try!(remove(&mut map, "convert_emoticons")).as_bool()),
-            enable_tts_command: req!(try!(remove(&mut map, "enable_tts_command")).as_bool()),
-            friend_source_flags: try!(remove(&mut map, "friend_source_flags").and_then(FriendSourceFlags::decode)),
-            inline_attachment_media: req!(try!(remove(&mut map, "inline_attachment_media")).as_bool()),
-            inline_embed_media: req!(try!(remove(&mut map, "inline_embed_media")).as_bool()),
-            locale: try!(remove(&mut map, "locale").and_then(into_string)),
-            message_display_compact: req!(try!(remove(&mut map, "message_display_compact")).as_bool()),
-            render_embeds: req!(try!(remove(&mut map, "render_embeds")).as_bool()),
-            restricted_guilds: try!(remove(&mut map, "restricted_guilds").and_then(|v| decode_array(v, GuildId::decode))),
-            show_current_game: req!(try!(remove(&mut map, "show_current_game")).as_bool()),
-            theme: try!(remove(&mut map, "theme").and_then(into_string)),
+            convert_emoticons: req!(remove(&mut map, "convert_emoticons")?.as_bool()),
+            enable_tts_command: req!(remove(&mut map, "enable_tts_command")?.as_bool()),
+            friend_source_flags: remove(&mut map, "friend_source_flags").and_then(FriendSourceFlags::decode)?,
+            inline_attachment_media: req!(remove(&mut map, "inline_attachment_media")?.as_bool()),
+            inline_embed_media: req!(remove(&mut map, "inline_embed_media")?.as_bool()),
+            locale: remove(&mut map, "locale").and_then(into_string)?,
+            message_display_compact: req!(remove(&mut map, "message_display_compact")?.as_bool()),
+            render_embeds: req!(remove(&mut map, "render_embeds")?.as_bool()),
+            restricted_guilds: remove(&mut map, "restricted_guilds").and_then(|v| decode_array(v, GuildId::decode))?,
+            show_current_game: req!(remove(&mut map, "show_current_game")?.as_bool()),
+            theme: remove(&mut map, "theme").and_then(into_string)?,
         }).map(Some)
     }
 }
diff --git a/src/model/utils.rs b/src/model/utils.rs
index 9b4f6e4..2668142 100644
--- a/src/model/utils.rs
+++ b/src/model/utils.rs
@@ -27,18 +27,18 @@ use ::ext::cache::ChannelRef;
 #[macro_escape]
 macro_rules! req {
     ($opt:expr) => {
-        try!($opt.ok_or(Error::Decode(concat!("Type mismatch in model:",
+        $opt.ok_or(Error::Decode(concat!("Type mismatch in model:",
                                               line!(),
                                               ": ",
                                               stringify!($opt)),
-                                      Value::Null)))
+                                      Value::Null))?
     }
 }
 
 pub fn decode_emojis(value: Value) -> Result<HashMap<EmojiId, Emoji>> {
     let mut emojis = HashMap::new();
 
-    for emoji in try!(decode_array(value, Emoji::decode)) {
+    for emoji in decode_array(value, Emoji::decode)? {
         emojis.insert(emoji.id, emoji);
     }
 
@@ -91,7 +91,7 @@ pub fn decode_id(value: Value) -> Result<u64> {
 pub fn decode_members(value: Value) -> Result<HashMap<UserId, Member>> {
     let mut members = HashMap::new();
 
-    for member in try!(decode_array(value, Member::decode)) {
+    for member in decode_array(value, Member::decode)? {
         members.insert(member.user.id, member);
     }
 
@@ -104,11 +104,11 @@ pub fn decode_notes(value: Value) -> Result<HashMap<UserId, String>> {
     let mut notes = HashMap::new();
 
     for (key, value) in into_map(value).unwrap_or(BTreeMap::default()) {
-        let id = UserId(try!(key.parse::<u64>()
+        let id = UserId(key.parse::<u64>()
             .map_err(|_| Error::Decode("Invalid user id in notes",
-                                       Value::String(key)))));
+                                       Value::String(key)))?);
 
-        notes.insert(id, try!(into_string(value)));
+        notes.insert(id, into_string(value)?);
     }
 
     Ok(notes)
@@ -117,7 +117,7 @@ pub fn decode_notes(value: Value) -> Result<HashMap<UserId, String>> {
 pub fn decode_presences(value: Value) -> Result<HashMap<UserId, Presence>> {
     let mut presences = HashMap::new();
 
-    for presence in try!(decode_array(value, Presence::decode)) {
+    for presence in decode_array(value, Presence::decode)? {
         presences.insert(presence.user_id, presence);
     }
 
@@ -128,7 +128,7 @@ pub fn decode_private_channels(value: Value)
     -> Result<HashMap<ChannelId, Channel>> {
     let mut private_channels = HashMap::new();
 
-    for private_channel in try!(decode_array(value, Channel::decode)) {
+    for private_channel in decode_array(value, Channel::decode)? {
         let id = match private_channel {
             Channel::Group(ref group) => group.channel_id,
             Channel::Private(ref channel) => channel.id,
@@ -145,7 +145,7 @@ pub fn decode_read_states(value: Value)
     -> Result<HashMap<ChannelId, ReadState>> {
     let mut read_states = HashMap::new();
 
-    for read_state in try!(decode_array(value, ReadState::decode)) {
+    for read_state in decode_array(value, ReadState::decode)? {
         read_states.insert(read_state.id, read_state);
     }
 
@@ -156,7 +156,7 @@ pub fn decode_relationships(value: Value)
     -> Result<HashMap<UserId, Relationship>> {
     let mut relationships = HashMap::new();
 
-    for relationship in try!(decode_array(value, Relationship::decode)) {
+    for relationship in decode_array(value, Relationship::decode)? {
         relationships.insert(relationship.id, relationship);
     }
 
@@ -166,7 +166,7 @@ pub fn decode_relationships(value: Value)
 pub fn decode_roles(value: Value) -> Result<HashMap<RoleId, Role>> {
     let mut roles = HashMap::new();
 
-    for role in try!(decode_array(value, Role::decode)) {
+    for role in decode_array(value, Role::decode)? {
         roles.insert(role.id, role);
     }
 
@@ -174,20 +174,20 @@ pub fn decode_roles(value: Value) -> Result<HashMap<RoleId, Role>> {
 }
 
 pub fn decode_shards(value: Value) -> Result<[u8; 2]> {
-    let array = try!(into_array(value));
+    let array = into_array(value)?;
 
     Ok([
-        req!(try!(array.get(0)
-            .ok_or(Error::Client(ClientError::InvalidShards))).as_u64()) as u8,
-        req!(try!(array.get(1)
-            .ok_or(Error::Client(ClientError::InvalidShards))).as_u64()) as u8,
+        req!(array.get(0)
+            .ok_or(Error::Client(ClientError::InvalidShards))?.as_u64()) as u8,
+        req!(array.get(1)
+            .ok_or(Error::Client(ClientError::InvalidShards))?.as_u64()) as u8,
     ])
 }
 
 pub fn decode_users(value: Value) -> Result<HashMap<UserId, User>> {
     let mut users = HashMap::new();
 
-    for user in try!(decode_array(value, User::decode)) {
+    for user in decode_array(value, User::decode)? {
         users.insert(user.id, user);
     }
 
@@ -198,7 +198,7 @@ pub fn decode_voice_states(value: Value)
     -> Result<HashMap<UserId, VoiceState>> {
     let mut voice_states = HashMap::new();
 
-    for voice_state in try!(decode_array(value, VoiceState::decode)) {
+    for voice_state in decode_array(value, VoiceState::decode)? {
         voice_states.insert(voice_state.user_id, voice_state);
     }
 
diff --git a/src/model/voice.rs b/src/model/voice.rs
deleted file mode 100644
index 8b13789..0000000
--- a/src/model/voice.rs
+++ /dev/null
@@ -1 +0,0 @@
-