Change all try's into ?s

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

20 files changed, 496 insertions, 501 deletions

diff --git a/src/client/context.rs b/src/client/context.rs
index af90447..f0ead27 100644
--- a/src/client/context.rs
+++ b/src/client/context.rs
@@ -507,7 +507,7 @@ impl Context {
         // edit.
         //
         // [this]: http://github.com/hammerandchisel/discord-api-docs/issues/156
-        let role = try!(rest::create_role(id));
+        let role = rest::create_role(id)?;
         let map = f(EditRole::default()).0.build();
 
         rest::edit_role(id, role.id.0, map)
@@ -775,7 +775,7 @@ impl Context {
                                        F: FnOnce(EditChannel) -> EditChannel {
         let channel_id = channel_id.into();
 
-        let map = match try!(self.get_channel(channel_id)) {
+        let map = match self.get_channel(channel_id)? {
             Channel::Guild(channel) => {
                 let map = ObjectBuilder::new()
                     .insert("name", channel.name)
@@ -906,7 +906,7 @@ impl Context {
     /// ```
     pub fn edit_profile<F: FnOnce(EditProfile) -> EditProfile>(&self, f: F)
         -> Result<CurrentUser> {
-        let user = try!(rest::get_current_user());
+        let user = rest::get_current_user()?;
 
         let mut map = ObjectBuilder::new()
             .insert("avatar", user.avatar)
@@ -1070,7 +1070,7 @@ impl Context {
 
         let mut channels = HashMap::new();
 
-        for channel in try!(rest::get_channels(guild_id.0)) {
+        for channel in rest::get_channels(guild_id.0)? {
             channels.insert(channel.id, channel);
         }
 
@@ -1250,18 +1250,18 @@ impl Context {
         let query = {
             let mut map = f(GetMessages::default()).0;
             let mut query = String::new();
-            try!(write!(query, "?limit={}", map.remove("limit").unwrap_or(50)));
+            write!(query, "?limit={}", map.remove("limit").unwrap_or(50))?;
 
             if let Some(after) = map.remove("after") {
-                try!(write!(query, "&after={}", after));
+                write!(query, "&after={}", after)?;
             }
 
             if let Some(around) = map.remove("around") {
-                try!(write!(query, "&around={}", around));
+                write!(query, "&around={}", around)?;
             }
 
             if let Some(before) = map.remove("before") {
-                try!(write!(query, "&before={}", before));
+                write!(query, "&before={}", before)?;
             }
 
             query
diff --git a/src/client/gateway/prep.rs b/src/client/gateway/prep.rs
index 6aa40f3..3844a8d 100644
--- a/src/client/gateway/prep.rs
+++ b/src/client/gateway/prep.rs
@@ -34,7 +34,7 @@ pub fn parse_ready(event: GatewayEvent,
 
             let _ = tx.send(GatewayStatus::SendMessage(identification));
 
-            match try!(receiver.recv_json(GatewayEvent::decode)) {
+            match receiver.recv_json(GatewayEvent::decode)? {
                 GatewayEvent::Dispatch(seq, Event::Ready(event)) => {
                     Ok((event, seq))
                 },
diff --git a/src/client/gateway/shard.rs b/src/client/gateway/shard.rs
index ab9ef73..232d2c3 100644
--- a/src/client/gateway/shard.rs
+++ b/src/client/gateway/shard.rs
@@ -102,17 +102,17 @@ impl Shard {
                shard_info: Option<[u8; 2]>,
                login_type: LoginType)
                -> Result<(Shard, ReadyEvent, Receiver<WebSocketStream>)> {
-        let url = try!(prep::build_gateway_url(base_url));
+        let url = prep::build_gateway_url(base_url)?;
 
-        let response = try!(try!(WsClient::connect(url)).send());
-        try!(response.validate());
+        let response = WsClient::connect(url)?.send()?;
+        response.validate()?;
 
         let (mut sender, mut receiver) = response.begin().split();
 
         let identification = prep::identify(token, shard_info);
-        try!(sender.send_json(&identification));
+        sender.send_json(&identification)?;
 
-        let heartbeat_interval = match try!(receiver.recv_json(GatewayEvent::decode)) {
+        let heartbeat_interval = match receiver.recv_json(GatewayEvent::decode)? {
             GatewayEvent::Hello(interval) => interval,
             other => {
                 debug!("Unexpected event during connection start: {:?}", other);
@@ -128,16 +128,16 @@ impl Shard {
                                   info[1] - 1),
             None => "serenity keepalive [unsharded]".to_owned(),
         };
-        try!(ThreadBuilder::new()
+        ThreadBuilder::new()
             .name(thread_name)
-            .spawn(move || prep::keepalive(heartbeat_interval, sender, rx)));
+            .spawn(move || prep::keepalive(heartbeat_interval, sender, rx))?;
 
         // Parse READY
-        let event = try!(receiver.recv_json(GatewayEvent::decode));
-        let (ready, sequence) = try!(prep::parse_ready(event,
+        let event = receiver.recv_json(GatewayEvent::decode)?;
+        let (ready, sequence) = prep::parse_ready(event,
                                                        &tx,
                                                        &mut receiver,
-                                                       identification));
+                                                       identification)?;
 
         Ok((feature_voice! {{
             Shard {
@@ -356,11 +356,11 @@ impl Shard {
             let mut sender = Sender::new(stream.by_ref(), true);
             let message = WsMessage::close_because(1000, "");
 
-            try!(sender.send_message(&message));
+            sender.send_message(&message)?;
         }
 
-        try!(stream.flush());
-        try!(stream.shutdown(Shutdown::Both));
+        stream.flush()?;
+        stream.shutdown(Shutdown::Both)?;
 
         Ok(())
     }
@@ -434,7 +434,7 @@ impl Shard {
 
         // Take a few attempts at reconnecting.
         for i in 1u64..11u64 {
-            let gateway_url = try!(rest::get_gateway()).url;
+            let gateway_url = rest::get_gateway()?.url;
 
             let shard = Shard::new(&gateway_url,
                                    &self.token,
@@ -442,7 +442,7 @@ impl Shard {
                                    self.login_type);
 
             if let Ok((shard, ready, receiver_new)) = shard {
-                try!(mem::replace(self, shard).shutdown(&mut receiver));
+                mem::replace(self, shard).shutdown(&mut receiver)?;
 
                 self.session_id = Some(ready.ready.session_id.clone());
 
@@ -459,27 +459,27 @@ impl Shard {
 
     fn resume(&mut self, session_id: String, receiver: &mut Receiver<WebSocketStream>)
         -> Result<(Event, Receiver<WebSocketStream>)> {
-        try!(receiver.get_mut().get_mut().shutdown(Shutdown::Both));
-        let url = try!(prep::build_gateway_url(&self.ws_url));
+        receiver.get_mut().get_mut().shutdown(Shutdown::Both)?;
+        let url = prep::build_gateway_url(&self.ws_url)?;
 
-        let response = try!(try!(WsClient::connect(url)).send());
-        try!(response.validate());
+        let response = WsClient::connect(url)?.send()?;
+        response.validate()?;
 
         let (mut sender, mut receiver) = response.begin().split();
 
-        try!(sender.send_json(&ObjectBuilder::new()
+        sender.send_json(&ObjectBuilder::new()
             .insert_object("d", |o| o
                 .insert("session_id", session_id)
                 .insert("seq", self.last_sequence)
                 .insert("token", &self.token)
             )
             .insert("op", OpCode::Resume.num())
-            .build()));
+            .build())?;
 
         let first_event;
 
         loop {
-            match try!(receiver.recv_json(GatewayEvent::decode)) {
+            match receiver.recv_json(GatewayEvent::decode)? {
                 GatewayEvent::Dispatch(seq, event) => {
                     if let Event::Ready(ref event) = event {
                         self.session_id = Some(event.ready.session_id.clone());
@@ -491,7 +491,7 @@ impl Shard {
                     break;
                 },
                 GatewayEvent::InvalidateSession => {
-                    try!(sender.send_json(&prep::identify(&self.token, self.shard_info)));
+                    sender.send_json(&prep::identify(&self.token, self.shard_info))?;
                 },
                 other => {
                     debug!("Unexpected event: {:?}", other);
diff --git a/src/client/mod.rs b/src/client/mod.rs
index cf67b5b..843bbfe 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -279,7 +279,7 @@ impl Client {
     ///
     /// [gateway docs]: gateway/index.html#sharding
     pub fn start_autosharded(&mut self) -> Result<()> {
-        let res = try!(rest::get_bot_gateway());
+        let res = rest::get_bot_gateway()?;
 
         self.start_connection(Some([0, res.shards as u8 - 1, res.shards as u8]))
     }
@@ -768,7 +768,7 @@ impl Client {
     //
     // Not all shards need to be initialized in this process.
     fn start_connection(&mut self, shard_data: Option<[u8; 3]>) -> Result<()> {
-        let gateway_url = try!(rest::get_gateway()).url;
+        let gateway_url = rest::get_gateway()?.url;
 
         for i in 0..shard_data.map_or(1, |x| x[1] + 1) {
             let shard = Shard::new(&gateway_url,
diff --git a/src/client/rest/mod.rs b/src/client/rest/mod.rs
index 97796fd..1ef59b8 100644
--- a/src/client/rest/mod.rs
+++ b/src/client/rest/mod.rs
@@ -102,7 +102,7 @@ pub fn set_token(token: &str) {
 pub fn accept_invite(code: &str) -> Result<Invite> {
     let response = request!(Route::InvitesCode, post, "/invites/{}", code);
 
-    Invite::decode(try!(serde_json::from_reader(response)))
+    Invite::decode(serde_json::from_reader(response)?)
 }
 
 /// Marks a [`Channel`] as being "read" up to a certain [`Message`]. Any
@@ -205,13 +205,13 @@ pub fn broadcast_typing(channel_id: u64) -> Result<()> {
 /// [docs]: https://discordapp.com/developers/docs/resources/guild#create-guild-channel
 /// [Manage Channels]: ../../model/permissions/constant.MANAGE_CHANNELS.html
 pub fn create_channel(guild_id: u64, map: Value) -> Result<Channel> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::GuildsIdChannels(guild_id),
                             post(body),
                             "/guilds/{}/channels",
                             guild_id);
 
-    Channel::decode(try!(serde_json::from_reader(response)))
+    Channel::decode(serde_json::from_reader(response)?)
 }
 
 /// Creates an emoji in the given [`Guild`] with the given data.
@@ -226,13 +226,13 @@ pub fn create_channel(guild_id: u64, map: Value) -> Result<Channel> {
 /// [Manage Emojis]: ../../model/permissions/constant.MANAGE_EMOJIS.html
 pub fn create_emoji(guild_id: u64, map: Value)
     -> Result<Emoji> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::GuildsIdEmojis(guild_id),
                             post(body),
                             "/guilds/{}/emojis",
                             guild_id);
 
-    Emoji::decode(try!(serde_json::from_reader(response)))
+    Emoji::decode(serde_json::from_reader(response)?)
 }
 
 /// Creates a guild with the data provided.
@@ -270,10 +270,10 @@ pub fn create_emoji(guild_id: u64, map: Value)
 /// [US West Region]: ../../model/enum.Region.html#variant.UsWest
 /// [whitelist]: https://discordapp.com/developers/docs/resources/guild#create-guild
 pub fn create_guild(map: Value) -> Result<PartialGuild> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::Guilds, post(body), "/guilds");
 
-    PartialGuild::decode(try!(serde_json::from_reader(response)))
+    PartialGuild::decode(serde_json::from_reader(response)?)
 }
 
 /// Creates an [`Integration`] for a [`Guild`].
@@ -288,7 +288,7 @@ pub fn create_guild(map: Value) -> Result<PartialGuild> {
 /// [docs]: https://discordapp.com/developers/docs/resources/guild#create-guild-integration
 pub fn create_guild_integration(guild_id: u64, integration_id: u64, map: Value)
     -> Result<()> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
 
     verify(204, request!(Route::GuildsIdIntegrations(guild_id),
                          post(body),
@@ -311,19 +311,19 @@ pub fn create_guild_integration(guild_id: u64, integration_id: u64, map: Value)
 /// [docs]: https://discordapp.com/developers/docs/resources/channel#create-channel-invite
 pub fn create_invite(channel_id: u64, map: Value)
     -> Result<RichInvite> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::ChannelsIdInvites(channel_id),
                             post(body),
                             "/channels/{}/invites",
                             channel_id);
 
-    RichInvite::decode(try!(serde_json::from_reader(response)))
+    RichInvite::decode(serde_json::from_reader(response)?)
 }
 
 /// Creates a permission override for a member or a role in a channel.
 pub fn create_permission(channel_id: u64, target_id: u64, map: Value)
     -> Result<()> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
 
     verify(204, request!(Route::ChannelsIdPermissionsOverwriteId(channel_id),
                          put(body),
@@ -335,12 +335,12 @@ pub fn create_permission(channel_id: u64, target_id: u64, map: Value)
 /// Creates a private channel with a user.
 pub fn create_private_channel(map: Value)
     -> Result<PrivateChannel> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::UsersMeChannels,
                             post(body),
                             "/users/@me/channels");
 
-    PrivateChannel::decode(try!(serde_json::from_reader(response)))
+    PrivateChannel::decode(serde_json::from_reader(response)?)
 }
 
 /// Reacts to a message.
@@ -364,7 +364,7 @@ pub fn create_role(guild_id: u64) -> Result<Role> {
                             "/guilds/{}/roles",
                             guild_id);
 
-    Role::decode(try!(serde_json::from_reader(response)))
+    Role::decode(serde_json::from_reader(response)?)
 }
 
 /// Creates a webhook for the given [channel][`GuildChannel`]'s Id, passing in
@@ -398,13 +398,13 @@ pub fn create_role(guild_id: u64) -> Result<Role> {
 ///
 /// [`GuildChannel`]: ../../model/struct.GuildChannel.html
 pub fn create_webhook(channel_id: u64, map: Value) -> Result<Webhook> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::ChannelsIdWebhooks(channel_id),
                             post(body),
                             "/channels/{}/webhooks",
                             channel_id);
 
-    Webhook::decode(try!(serde_json::from_reader(response)))
+    Webhook::decode(serde_json::from_reader(response)?)
 }
 
 /// Deketes a private channel or a channel in a guild.
@@ -414,7 +414,7 @@ pub fn delete_channel(channel_id: u64) -> Result<Channel> {
                             "/channels/{}",
                             channel_id);
 
-    Channel::decode(try!(serde_json::from_reader(response)))
+    Channel::decode(serde_json::from_reader(response)?)
 }
 
 /// Deletes an emoji from a server.
@@ -433,7 +433,7 @@ pub fn delete_guild(guild_id: u64) -> Result<PartialGuild> {
                             "/guilds/{}",
                             guild_id);
 
-    PartialGuild::decode(try!(serde_json::from_reader(response)))
+    PartialGuild::decode(serde_json::from_reader(response)?)
 }
 
 /// Remvoes an integration from a guild.
@@ -450,7 +450,7 @@ pub fn delete_guild_integration(guild_id: u64, integration_id: u64)
 pub fn delete_invite(code: &str) -> Result<Invite> {
     let response = request!(Route::InvitesCode, delete, "/invites/{}", code);
 
-    Invite::decode(try!(serde_json::from_reader(response)))
+    Invite::decode(serde_json::from_reader(response)?)
 }
 
 /// Deletes a message if created by us or we have
@@ -466,7 +466,7 @@ pub fn delete_message(channel_id: u64, message_id: u64)
 
 /// Deletes a bunch of messages, only works for bots.
 pub fn delete_messages(channel_id: u64, map: Value) -> Result<()> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
 
     verify(204, request!(Route::ChannelsIdMessagesBulkDelete(channel_id),
                          post(body),
@@ -582,64 +582,64 @@ pub fn delete_webhook(webhook_id: u64) -> Result<()> {
 /// [`Webhook`]: ../../model/struct.Webhook.html
 pub fn delete_webhook_with_token(webhook_id: u64, token: &str) -> Result<()> {
     let client = HyperClient::new();
-    verify(204, try!(retry(|| client
+    verify(204, retry(|| client
         .delete(&format!(api!("/webhooks/{}/{}"), webhook_id, token)))
-        .map_err(Error::Hyper)))
+        .map_err(Error::Hyper)?)
 }
 
 /// Changes channel information.
 pub fn edit_channel(channel_id: u64, map: Value)
     -> Result<GuildChannel> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::ChannelsId(channel_id),
                             patch(body),
                             "/channels/{}",
                             channel_id);
 
-    GuildChannel::decode(try!(serde_json::from_reader(response)))
+    GuildChannel::decode(serde_json::from_reader(response)?)
 }
 
 /// Changes emoji information.
 pub fn edit_emoji(guild_id: u64, emoji_id: u64, map: Value)
     -> Result<Emoji> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::GuildsIdEmojisId(guild_id),
                             patch(body),
                             "/guilds/{}/emojis/{}",
                             guild_id,
                             emoji_id);
 
-    Emoji::decode(try!(serde_json::from_reader(response)))
+    Emoji::decode(serde_json::from_reader(response)?)
 }
 
 /// Changes guild information.
 pub fn edit_guild(guild_id: u64, map: Value) -> Result<PartialGuild> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::GuildsId(guild_id),
                             patch(body),
                             "/guilds/{}",
                             guild_id);
 
-    PartialGuild::decode(try!(serde_json::from_reader(response)))
+    PartialGuild::decode(serde_json::from_reader(response)?)
 }
 
 /// Edits a [`Guild`]'s embed setting.
 ///
 /// [`Guild`]: ../../model/struct.Guild.html
 pub fn edit_guild_embed(guild_id: u64, map: Value) -> Result<GuildEmbed> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::GuildsIdEmbed(guild_id),
                             patch(body),
                             "/guilds/{}/embed",
                             guild_id);
 
-    GuildEmbed::decode(try!(serde_json::from_reader(response)))
+    GuildEmbed::decode(serde_json::from_reader(response)?)
 }
 
 /// Does specific actions to a member.
 pub fn edit_member(guild_id: u64, user_id: u64, map: Value)
     -> Result<()> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
 
     verify(204, request!(Route::GuildsIdMembersId(guild_id),
                          patch(body),
@@ -653,14 +653,14 @@ pub fn edit_message(channel_id: u64,
                     message_id: u64,
                     map: Value)
                     -> Result<Message> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::ChannelsIdMessagesId(channel_id),
                             patch(body),
                             "/channels/{}/messages/{}",
                             channel_id,
                             message_id);
 
-    Message::decode(try!(serde_json::from_reader(response)))
+    Message::decode(serde_json::from_reader(response)?)
 }
 
 /// Edits the current user's nickname for the provided [`Guild`] via its Id.
@@ -671,7 +671,7 @@ pub fn edit_message(channel_id: u64,
 pub fn edit_nickname(guild_id: u64, new_nickname: Option<&str>)
     -> Result<()> {
     let map = ObjectBuilder::new().insert("nick", new_nickname).build();
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::GuildsIdMembersMeNick(guild_id),
                             patch(body),
                             "/guilds/{}/members/@me/nick",
@@ -682,7 +682,7 @@ pub fn edit_nickname(guild_id: u64, new_nickname: Option<&str>)
 
 /// Changes a profile note.
 pub fn edit_note(user_id: u64, map: Value) -> Result<()> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
 
     verify(204, request!(Route::None,
                          put(body),
@@ -704,10 +704,10 @@ pub fn edit_note(user_id: u64, map: Value) -> Result<()> {
 /// the token may be outdated.
 ///
 pub fn edit_profile(map: Value) -> Result<CurrentUser> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::UsersMe, patch(body), "/users/@me");
 
-    let mut map: BTreeMap<String, Value> = try!(serde_json::from_reader(response));
+    let mut map: BTreeMap<String, Value> = serde_json::from_reader(response)?;
 
     if let Some(Value::String(token)) = map.remove("token") {
         set_token(&token)
@@ -719,14 +719,14 @@ pub fn edit_profile(map: Value) -> Result<CurrentUser> {
 /// Changes a role in a guild.
 pub fn edit_role(guild_id: u64, role_id: u64, map: Value)
     -> Result<Role> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::GuildsIdRolesId(guild_id),
                             patch(body),
                             "/guilds/{}/roles/{}",
                             guild_id,
                             role_id);
 
-    Role::decode(try!(serde_json::from_reader(response)))
+    Role::decode(serde_json::from_reader(response)?)
 }
 
 /// Edits a the webhook with the given data.
@@ -769,13 +769,13 @@ pub fn edit_role(guild_id: u64, role_id: u64, map: Value)
 // The tests are ignored, rather than no_run'd, due to rustdoc tests with
 // external crates being incredibly messy and misleading in the end user's view.
 pub fn edit_webhook(webhook_id: u64, map: Value) -> Result<Webhook> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::WebhooksId,
                             patch(body),
                             "/webhooks/{}",
                             webhook_id);
 
-    Webhook::decode(try!(serde_json::from_reader(response)))
+    Webhook::decode(serde_json::from_reader(response)?)
 }
 
 /// Edits the webhook with the given data.
@@ -806,14 +806,14 @@ pub fn edit_webhook(webhook_id: u64, map: Value) -> Result<Webhook> {
 /// [`edit_webhook`]: fn.edit_webhook.html
 pub fn edit_webhook_with_token(webhook_id: u64, token: &str, map: Value)
     -> Result<Webhook> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let client = HyperClient::new();
-    let response = try!(retry(|| client
+    let response = retry(|| client
         .patch(&format!(api!("/webhooks/{}/{}"), webhook_id, token))
         .body(&body))
-        .map_err(Error::Hyper));
+        .map_err(Error::Hyper)?;
 
-    Webhook::decode(try!(serde_json::from_reader(response)))
+    Webhook::decode(serde_json::from_reader(response)?)
 }
 
 /// Executes a webhook, posting a [`Message`] in the webhook's associated
@@ -868,14 +868,14 @@ pub fn edit_webhook_with_token(webhook_id: u64, token: &str, map: Value)
 /// };
 pub fn execute_webhook(webhook_id: u64, token: &str, map: Value)
     -> Result<Message> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let client = HyperClient::new();
-    let response = try!(retry(|| client
+    let response = retry(|| client
         .patch(&format!(api!("/webhooks/{}/{}"), webhook_id, token))
         .body(&body))
-        .map_err(Error::Hyper));
+        .map_err(Error::Hyper)?;
 
-    Message::decode(try!(serde_json::from_reader(response)))
+    Message::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets the active maintenances from Discord's Status API.
@@ -883,10 +883,10 @@ pub fn execute_webhook(webhook_id: u64, token: &str, map: Value)
 /// Does not require authentication.
 pub fn get_active_maintenances() -> Result<Vec<Maintenance>> {
     let client = HyperClient::new();
-    let response = try!(retry(|| client.get(
-        status!("/scheduled-maintenances/active.json"))));
+    let response = retry(|| client.get(
+        status!("/scheduled-maintenances/active.json")))?;
 
-    let mut map: BTreeMap<String, Value> = try!(serde_json::from_reader(response));
+    let mut map: BTreeMap<String, Value> = serde_json::from_reader(response)?;
 
     match map.remove("scheduled_maintenances") {
         Some(v) => decode_array(v, Maintenance::decode),
@@ -900,7 +900,7 @@ pub fn get_active_maintenances() -> Result<Vec<Maintenance>> {
 pub fn get_application_info() -> Result<CurrentApplicationInfo> {
     let response = request!(Route::None, get, "/oauth2/applications/@me");
 
-    CurrentApplicationInfo::decode(try!(serde_json::from_reader(response)))
+    CurrentApplicationInfo::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets all oauth2 applications we've made.
@@ -908,7 +908,7 @@ pub fn get_application_info() -> Result<CurrentApplicationInfo> {
 /// **Note**: Only user accounts may use this endpoint.
 pub fn get_applications() -> Result<Vec<ApplicationInfo>> {
     let response = request!(Route::None, get, "/oauth2/applications");
-    let decoded = try!(serde_json::from_reader(response));
+    let decoded = serde_json::from_reader(response)?;
 
     decode_array(decoded, ApplicationInfo::decode)
 }
@@ -920,14 +920,14 @@ pub fn get_bans(guild_id: u64) -> Result<Vec<Ban>> {
                             "/guilds/{}/bans",
                             guild_id);
 
-    decode_array(try!(serde_json::from_reader(response)), Ban::decode)
+    decode_array(serde_json::from_reader(response)?, Ban::decode)
 }
 
 /// Gets current bot gateway.
 pub fn get_bot_gateway() -> Result<BotGateway> {
     let response = request!(Route::GatewayBot, get, "/gateway/bot");
 
-    BotGateway::decode(try!(serde_json::from_reader(response)))
+    BotGateway::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets all invites for a channel.
@@ -938,7 +938,7 @@ pub fn get_channel_invites(channel_id: u64)
                             "/channels/{}/invites",
                             channel_id);
 
-    decode_array(try!(serde_json::from_reader(response)),
+    decode_array(serde_json::from_reader(response)?,
                  RichInvite::decode)
 }
 
@@ -966,7 +966,7 @@ pub fn get_channel_webhooks(channel_id: u64) -> Result<Vec<Webhook>> {
                             "/channels/{}/webhooks",
                             channel_id);
 
-    decode_array(try!(serde_json::from_reader(response)), Webhook::decode)
+    decode_array(serde_json::from_reader(response)?, Webhook::decode)
 }
 
 /// Gets channel information.
@@ -976,7 +976,7 @@ pub fn get_channel(channel_id: u64) -> Result<Channel> {
                             "/channels/{}",
                             channel_id);
 
-    Channel::decode(try!(serde_json::from_reader(response)))
+    Channel::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets all channels in a guild.
@@ -986,7 +986,7 @@ pub fn get_channels(guild_id: u64) -> Result<Vec<GuildChannel>> {
                             "/guilds/{}/channels",
                             guild_id);
 
-    decode_array(try!(serde_json::from_reader(response)),
+    decode_array(serde_json::from_reader(response)?,
                  GuildChannel::decode)
 }
 
@@ -994,14 +994,14 @@ pub fn get_channels(guild_id: u64) -> Result<Vec<GuildChannel>> {
 pub fn get_current_user() -> Result<CurrentUser> {
     let response = request!(Route::UsersMe, get, "/users/@me");
 
-    CurrentUser::decode(try!(serde_json::from_reader(response)))
+    CurrentUser::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets current gateway.
 pub fn get_gateway() -> Result<Gateway> {
     let response = request!(Route::Gateway, get, "/gateway");
 
-    Gateway::decode(try!(serde_json::from_reader(response)))
+    Gateway::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets information about an emoji.
@@ -1012,7 +1012,7 @@ pub fn get_emoji(guild_id: u64, emoji_id: u64) -> Result<Emoji> {
                             guild_id,
                             emoji_id);
 
-    Emoji::decode(try!(serde_json::from_reader(response)))
+    Emoji::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets all emojis in a guild.
@@ -1022,7 +1022,7 @@ pub fn get_emojis(guild_id: u64) -> Result<Vec<Emoji>> {
                             "/guilds/{}/emojis",
                             guild_id);
 
-    decode_array(try!(serde_json::from_reader(response)), Emoji::decode)
+    decode_array(serde_json::from_reader(response)?, Emoji::decode)
 }
 
 /// Gets guild information.
@@ -1032,7 +1032,7 @@ pub fn get_guild(guild_id: u64) -> Result<PartialGuild> {
                             "/guilds/{}",
                             guild_id);
 
-    PartialGuild::decode(try!(serde_json::from_reader(response)))
+    PartialGuild::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets a guild embed information.
@@ -1042,7 +1042,7 @@ pub fn get_guild_embed(guild_id: u64) -> Result<GuildEmbed> {
                             "/guilds/{}/embeds",
                             guild_id);
 
-    GuildEmbed::decode(try!(serde_json::from_reader(response)))
+    GuildEmbed::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets integrations that a guild has.
@@ -1052,7 +1052,7 @@ pub fn get_guild_integrations(guild_id: u64) -> Result<Vec<Integration>> {
                             "/guilds/{}/integrations",
                             guild_id);
 
-    decode_array(try!(serde_json::from_reader(response)), Integration::decode)
+    decode_array(serde_json::from_reader(response)?, Integration::decode)
 }
 
 /// Gets all invites to a guild.
@@ -1062,7 +1062,7 @@ pub fn get_guild_invites(guild_id: u64) -> Result<Vec<RichInvite>> {
                             "/guilds/{}/invites",
                             guild_id);
 
-    decode_array(try!(serde_json::from_reader(response)), RichInvite::decode)
+    decode_array(serde_json::from_reader(response)?, RichInvite::decode)
 }
 
 /// Gets the members of a guild. Optionally pass a `limit` and the Id of the
@@ -1076,19 +1076,19 @@ pub fn get_guild_members(guild_id: u64, limit: Option<u64>, after: Option<u64>)
                             limit.unwrap_or(500),
                             after.unwrap_or(0));
 
-    decode_array(try!(serde_json::from_reader(response)), Member::decode)
+    decode_array(serde_json::from_reader(response)?, Member::decode)
 }
 
 /// Gets the amount of users that can be pruned.
 pub fn get_guild_prune_count(guild_id: u64, map: Value)
     -> Result<GuildPrune> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::GuildsIdPrune(guild_id),
                             get(body),
                             "/guilds/{}/prune",
                             guild_id);
 
-    GuildPrune::decode(try!(serde_json::from_reader(response)))
+    GuildPrune::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets regions that a guild can use. If a guild has [`Feature::VipRegions`]
@@ -1101,7 +1101,7 @@ pub fn get_guild_regions(guild_id: u64) -> Result<Vec<VoiceRegion>> {
                             "/guilds/{}/regions",
                             guild_id);
 
-    decode_array(try!(serde_json::from_reader(response)), VoiceRegion::decode)
+    decode_array(serde_json::from_reader(response)?, VoiceRegion::decode)
 }
 
 /// Retrieves a list of roles in a [`Guild`].
@@ -1113,7 +1113,7 @@ pub fn get_guild_roles(guild_id: u64) -> Result<Vec<Role>> {
                             "/guilds/{}/roles",
                             guild_id);
 
-    decode_array(try!(serde_json::from_reader(response)), Role::decode)
+    decode_array(serde_json::from_reader(response)?, Role::decode)
 }
 
 /// Retrieves the webhooks for the given [guild][`Guild`]'s Id.
@@ -1140,7 +1140,7 @@ pub fn get_guild_webhooks(guild_id: u64) -> Result<Vec<Webhook>> {
                             "/guilds/{}/webhooks",
                             guild_id);
 
-    decode_array(try!(serde_json::from_reader(response)), Webhook::decode)
+    decode_array(serde_json::from_reader(response)?, Webhook::decode)
 }
 
 /// Gets a paginated list of the current user's guilds.
@@ -1168,16 +1168,16 @@ pub fn get_guilds(target: GuildPagination, limit: u64) -> Result<Vec<GuildInfo>>
 
     match target {
         GuildPagination::After(id) => {
-            try!(write!(uri, "&after={}", id));
+            write!(uri, "&after={}", id)?;
         },
         GuildPagination::Before(id) => {
-            try!(write!(uri, "&before={}", id));
+            write!(uri, "&before={}", id)?;
         },
     }
 
     let response = request!(Route::UsersMeGuilds, get, "{}", uri);
 
-    decode_array(try!(serde_json::from_reader(response)), GuildInfo::decode)
+    decode_array(serde_json::from_reader(response)?, GuildInfo::decode)
 }
 
 /// Gets information about a specific invite.
@@ -1185,7 +1185,7 @@ pub fn get_invite(code: &str) -> Result<Invite> {
     let invite = ::utils::parse_invite(code);
     let response = request!(Route::InvitesCode, get, "/invites/{}", invite);
 
-    Invite::decode(try!(serde_json::from_reader(response)))
+    Invite::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets member of a guild.
@@ -1196,7 +1196,7 @@ pub fn get_member(guild_id: u64, user_id: u64) -> Result<Member> {
                             guild_id,
                             user_id);
 
-    Member::decode(try!(serde_json::from_reader(response)))
+    Member::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets a message by an Id, bots only.
@@ -1208,7 +1208,7 @@ pub fn get_message(channel_id: u64, message_id: u64)
                             channel_id,
                             message_id);
 
-    Message::decode(try!(serde_json::from_reader(response)))
+    Message::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets X messages from a channel.
@@ -1218,10 +1218,10 @@ pub fn get_messages(channel_id: u64, query: &str)
                       channel_id,
                       query);
     let client = HyperClient::new();
-    let response = try!(request(Route::ChannelsIdMessages(channel_id),
-                                || client.get(&url)));
+    let response = request(Route::ChannelsIdMessages(channel_id),
+                                || client.get(&url))?;
 
-    decode_array(try!(serde_json::from_reader(response)), Message::decode)
+    decode_array(serde_json::from_reader(response)?, Message::decode)
 }
 
 /// Gets all pins of a channel.
@@ -1231,7 +1231,7 @@ pub fn get_pins(channel_id: u64) -> Result<Vec<Message>> {
                             "/channels/{}/pins",
                             channel_id);
 
-    decode_array(try!(serde_json::from_reader(response)), Message::decode)
+    decode_array(serde_json::from_reader(response)?, Message::decode)
 }
 
 /// Gets user Ids based on their reaction to a message. This endpoint is dumb.
@@ -1248,7 +1248,7 @@ pub fn get_reaction_users(channel_id: u64,
                       limit);
 
     if let Some(user_id) = after {
-        try!(write!(uri, "&after={}", user_id));
+        write!(uri, "&after={}", user_id)?;
     }
 
     let response = request!(Route::ChannelsIdMessagesIdReactionsUserIdType(channel_id),
@@ -1256,7 +1256,7 @@ pub fn get_reaction_users(channel_id: u64,
                             "{}",
                             uri);
 
-    decode_array(try!(serde_json::from_reader(response)), User::decode)
+    decode_array(serde_json::from_reader(response)?, User::decode)
 }
 
 /// Gets the current unresolved incidents from Discord's Status API.
@@ -1264,10 +1264,10 @@ pub fn get_reaction_users(channel_id: u64,
 /// Does not require authentication.
 pub fn get_unresolved_incidents() -> Result<Vec<Incident>> {
     let client = HyperClient::new();
-    let response = try!(retry(|| client.get(
-        status!("/incidents/unresolved.json"))));
+    let response = retry(|| client.get(
+        status!("/incidents/unresolved.json")))?;
 
-    let mut map: BTreeMap<String, Value> = try!(serde_json::from_reader(response));
+    let mut map: BTreeMap<String, Value> = serde_json::from_reader(response)?;
 
     match map.remove("incidents") {
         Some(incidents) => decode_array(incidents, Incident::decode),
@@ -1280,10 +1280,10 @@ pub fn get_unresolved_incidents() -> Result<Vec<Incident>> {
 /// Does not require authentication.
 pub fn get_upcoming_maintenances() -> Result<Vec<Maintenance>> {
     let client = HyperClient::new();
-    let response = try!(retry(|| client.get(
-        status!("/scheduled-maintenances/upcoming.json"))));
+    let response = retry(|| client.get(
+        status!("/scheduled-maintenances/upcoming.json")))?;
 
-    let mut map: BTreeMap<String, Value> = try!(serde_json::from_reader(response));
+    let mut map: BTreeMap<String, Value> = serde_json::from_reader(response)?;
 
     match map.remove("scheduled_maintenances") {
         Some(v) => decode_array(v, Maintenance::decode),
@@ -1295,7 +1295,7 @@ pub fn get_upcoming_maintenances() -> Result<Vec<Maintenance>> {
 pub fn get_user(user_id: u64) -> Result<CurrentUser> {
     let response = request!(Route::UsersId, get, "/users/{}", user_id);
 
-    CurrentUser::decode(try!(serde_json::from_reader(response)))
+    CurrentUser::decode(serde_json::from_reader(response)?)
 }
 
 /// Gets our connections.
@@ -1304,7 +1304,7 @@ pub fn get_user_connections() -> Result<Vec<UserConnection>> {
                             get,
                             "/users/@me/connections");
 
-    decode_array(try!(serde_json::from_reader(response)),
+    decode_array(serde_json::from_reader(response)?,
                       UserConnection::decode)
 }
 
@@ -1312,7 +1312,7 @@ pub fn get_user_connections() -> Result<Vec<UserConnection>> {
 pub fn get_user_dm_channels() -> Result<Vec<PrivateChannel>> {
     let response = request!(Route::UsersMeChannels, get, "/users/@me/channels");
 
-    decode_array(try!(serde_json::from_reader(response)),
+    decode_array(serde_json::from_reader(response)?,
                       PrivateChannel::decode)
 }
 
@@ -1320,7 +1320,7 @@ pub fn get_user_dm_channels() -> Result<Vec<PrivateChannel>> {
 pub fn get_voice_regions() -> Result<Vec<VoiceRegion>> {
     let response = request!(Route::VoiceRegions, get, "/voice/regions");
 
-    decode_array(try!(serde_json::from_reader(response)), VoiceRegion::decode)
+    decode_array(serde_json::from_reader(response)?, VoiceRegion::decode)
 }
 
 /// Retrieves a webhook given its Id.
@@ -1343,7 +1343,7 @@ pub fn get_voice_regions() -> Result<Vec<VoiceRegion>> {
 pub fn get_webhook(webhook_id: u64) -> Result<Webhook> {
     let response = request!(Route::WebhooksId, get, "/webhooks/{}", webhook_id);
 
-    Webhook::decode(try!(serde_json::from_reader(response)))
+    Webhook::decode(serde_json::from_reader(response)?)
 }
 
 /// Retrieves a webhook given its Id and unique token.
@@ -1365,11 +1365,11 @@ pub fn get_webhook(webhook_id: u64) -> Result<Webhook> {
 /// ```
 pub fn get_webhook_with_token(webhook_id: u64, token: &str) -> Result<Webhook> {
     let client = HyperClient::new();
-    let response = try!(retry(|| client
+    let response = retry(|| client
         .get(&format!(api!("/webhooks/{}/{}"), webhook_id, token)))
-        .map_err(Error::Hyper));
+        .map_err(Error::Hyper)?;
 
-    Webhook::decode(try!(serde_json::from_reader(response)))
+    Webhook::decode(serde_json::from_reader(response)?)
 }
 
 /// Kicks a member from a guild.
@@ -1388,7 +1388,7 @@ pub fn leave_group(guild_id: u64) -> Result<Group> {
                             "/channels/{}",
                             guild_id);
 
-    Group::decode(try!(serde_json::from_reader(response)))
+    Group::decode(serde_json::from_reader(response)?)
 }
 
 /// Leaves a guild.
@@ -1398,12 +1398,12 @@ pub fn leave_guild(guild_id: u64) -> Result<PartialGuild> {
                             "/users/@me/guilds/{}",
                             guild_id);
 
-    PartialGuild::decode(try!(serde_json::from_reader(response)))
+    PartialGuild::decode(serde_json::from_reader(response)?)
 }
 
 /// Logs out. That's supposed to disable the token but doesn't.
 pub fn logout(map: Value) -> Result<()> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
 
     verify(204, request!(Route::None, post(body), "/auth/logout"))
 }
@@ -1430,15 +1430,15 @@ pub fn send_file<R: Read>(channel_id: u64,
         Err(_why) => return Err(Error::Url(uri)),
     };
 
-    let mut request = try!(Request::new(Method::Post, url));
+    let mut request = Request::new(Method::Post, url)?;
     request.headers_mut()
         .set(header::Authorization(TOKEN.lock().unwrap().clone()));
     request.headers_mut()
         .set(header::UserAgent(constants::USER_AGENT.to_owned()));
 
-    let mut request = try!(Multipart::from_request(request));
+    let mut request = Multipart::from_request(request)?;
 
-    try!(request.write_stream("file", &mut file, Some(&filename), None));
+    request.write_stream("file", &mut file, Some(&filename), None)?;
 
     for (k, v) in map {
         let val = match v {
@@ -1448,21 +1448,21 @@ pub fn send_file<R: Read>(channel_id: u64,
             _ => continue,
         };
 
-        try!(request.write_text(&k, val));
+        request.write_text(&k, val)?;
     }
 
-    Message::decode(try!(serde_json::from_reader(try!(request.send()))))
+    Message::decode(serde_json::from_reader(request.send()?)?)
 }
 
 /// Sends a message to a channel.
 pub fn send_message(channel_id: u64, map: Value) -> Result<Message> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::ChannelsIdMessages(channel_id),
                             post(body),
                             "/channels/{}/messages",
                             channel_id);
 
-    Message::decode(try!(serde_json::from_reader(response)))
+    Message::decode(serde_json::from_reader(response)?)
 }
 
 /// Pins a message in a channel.
@@ -1504,13 +1504,13 @@ pub fn remove_member_role(guild_id: u64, user_id: u64, role_id: u64) -> Result<(
 /// Starts removing some members from a guild based on the last time they've been online.
 pub fn start_guild_prune(guild_id: u64, map: Value)
     -> Result<GuildPrune> {
-    let body = try!(serde_json::to_string(&map));
+    let body = serde_json::to_string(&map)?;
     let response = request!(Route::GuildsIdPrune(guild_id),
                             post(body),
                             "/guilds/{}/prune",
                             guild_id);
 
-    GuildPrune::decode(try!(serde_json::from_reader(response)))
+    GuildPrune::decode(serde_json::from_reader(response)?)
 }
 
 /// Starts syncing an integration with a guild.
@@ -1574,7 +1574,7 @@ fn verify(expected_status_code: u16,
     debug!("Expected {}, got {}", expected_status_code, response.status);
 
     let mut s = String::default();
-    try!(response.read_to_string(&mut s));
+    response.read_to_string(&mut s)?;
 
     debug!("Content: {}", s);
 
diff --git a/src/client/rest/ratelimiting.rs b/src/client/rest/ratelimiting.rs
index 0b3ea7e..ac085eb 100644
--- a/src/client/rest/ratelimiting.rs
+++ b/src/client/rest/ratelimiting.rs
@@ -128,7 +128,7 @@ pub fn perform<'a, F>(route: Route, f: F) -> Result<Response>
             }
         }
 
-        let response = try!(super::retry(&f));
+        let response = super::retry(&f)?;
 
         // Check if the request got ratelimited by checking for status 429,
         // and if so, sleep for the value of the header 'retry-after' -
@@ -201,21 +201,21 @@ impl RateLimit {
     }
 
     pub fn post_hook(&mut self, response: &Response) -> Result<bool> {
-        if let Some(limit) = try!(get_header(&response.headers, "x-ratelimit-limit")) {
+        if let Some(limit) = get_header(&response.headers, "x-ratelimit-limit")? {
             self.limit = limit;
         }
 
-        if let Some(remaining) = try!(get_header(&response.headers, "x-ratelimit-remaining")) {
+        if let Some(remaining) = get_header(&response.headers, "x-ratelimit-remaining")? {
             self.remaining = remaining;
         }
 
-        if let Some(reset) = try!(get_header(&response.headers, "x-ratelimit-reset")) {
+        if let Some(reset) = get_header(&response.headers, "x-ratelimit-reset")? {
             self.reset = reset;
         }
 
         Ok(if response.status != StatusCode::TooManyRequests {
             false
-        } else if let Some(retry_after) = try!(get_header(&response.headers, "retry-after")) {
+        } else if let Some(retry_after) = get_header(&response.headers, "retry-after")? {
             debug!("Ratelimited: {:?}ms", retry_after);
             thread::sleep(Duration::from_millis(retry_after as u64));
 
diff --git a/src/ext/voice/connection.rs b/src/ext/voice/connection.rs
index 58b8e1f..373f4ef 100644
--- a/src/ext/voice/connection.rs
+++ b/src/ext/voice/connection.rs
@@ -63,21 +63,19 @@ pub struct Connection {
 
 impl Connection {
     pub fn new(mut info: ConnectionInfo) -> Result<Connection> {
-        let url = try!(generate_url(&mut info.endpoint));
+        let url = generate_url(&mut info.endpoint)?;
 
-        let response = try!(try!(WsClient::connect(url)).send());
-        try!(response.validate());
+        let response = WsClient::connect(url)?.send()?;
+        response.validate()?;
         let (mut sender, mut receiver) = response.begin().split();
 
-        try!(sender.send_json(&payload::build_identify(&info)));
+        sender.send_json(&payload::build_identify(&info))?;
 
         let hello = {
             let hello;
 
             loop {
-                let k = receiver.recv_json(VoiceEvent::decode);
-
-                match try!(k) {
+                match receiver.recv_json(VoiceEvent::decode)? {
                     VoiceEvent::Hello(received_hello) => {
                         hello = received_hello;
 
@@ -100,10 +98,10 @@ impl Connection {
             return Err(Error::Voice(VoiceError::VoiceModeUnavailable));
         }
 
-        let destination = try!(try!((&info.endpoint[..], hello.port)
-            .to_socket_addrs())
+        let destination = (&info.endpoint[..], hello.port)
+            .to_socket_addrs()?
             .next()
-            .ok_or(Error::Voice(VoiceError::HostnameResolve)));
+            .ok_or(Error::Voice(VoiceError::HostnameResolve))?;
 
         // Important to note here: the length of the packet can be of either 4
         // or 70 bytes. If it is 4 bytes, then we need to send a 70-byte packet
@@ -113,37 +111,37 @@ impl Connection {
         //
         // The returned packet will be a null-terminated string of the IP, and
         // the port encoded in LE in the last two bytes of the packet.
-        let udp = try!(UdpSocket::bind("0.0.0.0:0"));
+        let udp = UdpSocket::bind("0.0.0.0:0")?;
 
         {
             let mut bytes = [0; 70];
 
-            try!((&mut bytes[..]).write_u32::<BigEndian>(hello.ssrc));
-            try!(udp.send_to(&bytes, destination));
+            (&mut bytes[..]).write_u32::<BigEndian>(hello.ssrc)?;
+            udp.send_to(&bytes, destination)?;
 
             let mut bytes = [0; 256];
-            let (len, _addr) = try!(udp.recv_from(&mut bytes));
+            let (len, _addr) = udp.recv_from(&mut bytes)?;
 
             // Find the position in the bytes that contains the first byte of 0,
             // indicating the "end of the address".
-            let index = try!(bytes.iter().skip(4).position(|&x| x == 0)
-                .ok_or(Error::Voice(VoiceError::FindingByte)));
+            let index = bytes.iter().skip(4).position(|&x| x == 0)
+                .ok_or(Error::Voice(VoiceError::FindingByte))?;
 
             let pos = 4 + index;
             let addr = String::from_utf8_lossy(&bytes[4..pos]);
             let port_pos = len - 2;
-            let port = try!((&bytes[port_pos..]).read_u16::<LittleEndian>());
+            let port = (&bytes[port_pos..]).read_u16::<LittleEndian>()?;
 
-            try!(sender.send_json(&payload::build_select_protocol(addr, port)));
+            sender.send_json(&payload::build_select_protocol(addr, port))?;
         }
 
-        let key = try!(get_encryption_key(&mut receiver));
+        let key = get_encryption_key(&mut receiver)?;
 
-        let thread_items = try!(start_threads(receiver, &udp));
+        let thread_items = start_threads(receiver, &udp)?;
 
         info!("[Voice] Connected to: {}", info.endpoint);
 
-        let encoder = try!(OpusEncoder::new(SAMPLE_RATE, Channels::Mono, CodingMode::Audio));
+        let encoder = OpusEncoder::new(SAMPLE_RATE, Channels::Mono, CodingMode::Audio)?;
 
         Ok(Connection {
             audio_timer: Timer::new(1000 * 60 * 4),
@@ -179,21 +177,21 @@ impl Connection {
                 match status {
                     ReceiverStatus::Udp(packet) => {
                         let mut handle = &packet[2..];
-                        let seq = try!(handle.read_u16::<BigEndian>());
-                        let timestamp = try!(handle.read_u32::<BigEndian>());
-                        let ssrc = try!(handle.read_u32::<BigEndian>());
+                        let seq = handle.read_u16::<BigEndian>()?;
+                        let timestamp = handle.read_u32::<BigEndian>()?;
+                        let ssrc = handle.read_u32::<BigEndian>()?;
 
                         nonce.0[..HEADER_LEN].clone_from_slice(&packet[..HEADER_LEN]);
 
                         if let Ok(decrypted) = secretbox::open(&packet[HEADER_LEN..], &nonce, &self.key) {
-                            let channels = try!(opus_packet::get_nb_channels(&decrypted));
+                            let channels = opus_packet::get_nb_channels(&decrypted)?;
 
                             let entry = self.decoder_map.entry((ssrc, channels))
                                 .or_insert_with(|| OpusDecoder::new(SAMPLE_RATE,
                                                                     channels)
                                                     .unwrap());
 
-                            let len = try!(entry.decode(&decrypted, &mut buffer, false));
+                            let len = entry.decode(&decrypted, &mut buffer, false)?;
 
                             let is_stereo = channels == Channels::Stereo;
 
@@ -227,20 +225,20 @@ impl Connection {
 
         // Send the voice websocket keepalive if it's time
         if self.keepalive_timer.check() {
-            try!(self.sender.send_json(&payload::build_keepalive()));
+            self.sender.send_json(&payload::build_keepalive())?;
         }
 
         // Send UDP keepalive if it's time
         if self.audio_timer.check() {
             let mut bytes = [0; 4];
-            try!((&mut bytes[..]).write_u32::<BigEndian>(self.ssrc));
-            try!(self.udp.send_to(&bytes, self.destination));
+            (&mut bytes[..]).write_u32::<BigEndian>(self.ssrc)?;
+            self.udp.send_to(&bytes, self.destination)?;
         }
 
-        let len = try!(self.read(source, &mut buffer));
+        let len = self.read(source, &mut buffer)?;
 
         if len == 0 {
-            try!(self.set_speaking(false));
+            self.set_speaking(false)?;
 
             if self.silence_frames > 0 {
                 self.silence_frames -= 1;
@@ -261,11 +259,11 @@ impl Connection {
             }
         }
 
-        try!(self.set_speaking(true));
-        let index = try!(self.prep_packet(&mut packet, buffer, nonce));
+        self.set_speaking(true)?;
+        let index = self.prep_packet(&mut packet, buffer, nonce)?;
 
         audio_timer.await();
-        try!(self.udp.send_to(&packet[..index], self.destination));
+        self.udp.send_to(&packet[..index], self.destination)?;
         self.audio_timer.reset();
 
         Ok(())
@@ -278,10 +276,10 @@ impl Connection {
                    -> Result<usize> {
         {
             let mut cursor = &mut packet[..HEADER_LEN];
-            try!(cursor.write_all(&[0x80, 0x78]));
-            try!(cursor.write_u16::<BigEndian>(self.sequence));
-            try!(cursor.write_u32::<BigEndian>(self.timestamp));
-            try!(cursor.write_u32::<BigEndian>(self.ssrc));
+            cursor.write_all(&[0x80, 0x78])?;
+            cursor.write_u16::<BigEndian>(self.sequence)?;
+            cursor.write_u32::<BigEndian>(self.timestamp)?;
+            cursor.write_u32::<BigEndian>(self.ssrc)?;
         }
 
         nonce.0[..HEADER_LEN].clone_from_slice(&packet[..HEADER_LEN]);
@@ -293,8 +291,8 @@ impl Connection {
             960
         };
 
-        let len = try!(self.encoder.encode(&buffer[..buffer_len],
-                                           &mut packet[HEADER_LEN..sl_index]));
+        let len = self.encoder.encode(&buffer[..buffer_len],
+                                           &mut packet[HEADER_LEN..sl_index])?;
         let crypted = {
             let slice = &packet[HEADER_LEN..HEADER_LEN + len];
             secretbox::seal(slice, &nonce, &self.key)
@@ -324,9 +322,9 @@ impl Connection {
                     } else {
                         Channels::Mono
                     };
-                    self.encoder = try!(OpusEncoder::new(SAMPLE_RATE,
+                    self.encoder = OpusEncoder::new(SAMPLE_RATE,
                                                          channels,
-                                                         CodingMode::Audio));
+                                                         CodingMode::Audio)?;
                     self.encoder_stereo = is_stereo;
                 }
 
@@ -390,7 +388,7 @@ fn generate_url(endpoint: &mut String) -> Result<WebsocketUrl> {
 fn get_encryption_key(receiver: &mut WsReceiver<WebSocketStream>)
     -> Result<Key> {
     loop {
-        match try!(receiver.recv_json(VoiceEvent::decode)) {
+        match receiver.recv_json(VoiceEvent::decode)? {
             VoiceEvent::Ready(ready) => {
                 if ready.mode != CRYPTO_MODE {
                     return Err(Error::Voice(VoiceError::VoiceModeInvalid));
@@ -425,9 +423,9 @@ fn start_threads(mut receiver: WsReceiver<WebSocketStream>, udp: &UdpSocket)
 
     let (tx, rx) = mpsc::channel();
     let tx_clone = tx.clone();
-    let udp_clone = try!(udp.try_clone());
+    let udp_clone = udp.try_clone()?;
 
-    let udp_thread = try!(ThreadBuilder::new()
+    let udp_thread = ThreadBuilder::new()
         .name(format!("{} UDP", thread_name))
         .spawn(move || {
             let _ = udp_clone.set_read_timeout(Some(Duration::from_millis(250)));
@@ -446,9 +444,9 @@ fn start_threads(mut receiver: WsReceiver<WebSocketStream>, udp: &UdpSocket)
                     return;
                 }
             }
-        }));
+        })?;
 
-    let ws_thread = try!(ThreadBuilder::new()
+    let ws_thread = ThreadBuilder::new()
         .name(format!("{} WS", thread_name))
         .spawn(move || {
             loop {
@@ -464,7 +462,7 @@ fn start_threads(mut receiver: WsReceiver<WebSocketStream>, udp: &UdpSocket)
 
                 thread::sleep(Duration::from_millis(25));
             }
-        }));
+        })?;
 
     Ok(ThreadItems {
         rx: rx,
diff --git a/src/ext/voice/streamer.rs b/src/ext/voice/streamer.rs
index ed1c620..1c08a1b 100644
--- a/src/ext/voice/streamer.rs
+++ b/src/ext/voice/streamer.rs
@@ -60,14 +60,14 @@ pub fn ffmpeg<P: AsRef<OsStr>>(path: P) -> Result<Box<AudioSource>> {
         "-",
     ];
 
-    let command = try!(Command::new("ffmpeg")
+    let command = Command::new("ffmpeg")
         .arg("-i")
         .arg(path)
         .args(&args)
         .stderr(Stdio::null())
         .stdin(Stdio::null())
         .stdout(Stdio::piped())
-        .spawn());
+        .spawn()?;
 
     Ok(pcm(is_stereo, ChildContainer(command)))
 }
@@ -87,16 +87,16 @@ pub fn ytdl(uri: &str) -> Result<Box<AudioSource>> {
         uri,
     ];
 
-    let out = try!(Command::new("youtube-dl")
+    let out = Command::new("youtube-dl")
         .args(&args)
         .stdin(Stdio::null())
-        .output());
+        .output()?;
 
     if !out.status.success() {
         return Err(Error::Voice(VoiceError::YouTubeDLRun(out)));
     }
 
-    let value = try!(serde_json::from_reader(&out.stdout[..]));
+    let value = serde_json::from_reader(&out.stdout[..])?;
     let mut obj = match value {
         Value::Object(obj) => obj,
         other => return Err(Error::Voice(VoiceError::YouTubeDLProcessing(other))),
@@ -123,18 +123,18 @@ fn is_stereo(path: &OsStr) -> Result<bool> {
         "-i",
     ];
 
-    let out = try!(Command::new("ffprobe")
+    let out = Command::new("ffprobe")
         .args(&args)
         .arg(path)
         .stdin(Stdio::null())
-        .output());
+        .output()?;
 
-    let value: Value = try!(serde_json::from_reader(&out.stdout[..]));
+    let value: Value = serde_json::from_reader(&out.stdout[..])?;
 
-    let streams = try!(value.as_object()
+    let streams = value.as_object()
         .and_then(|m| m.get("streams"))
         .and_then(|v| v.as_array())
-        .ok_or(Error::Voice(VoiceError::Streams)));
+        .ok_or(Error::Voice(VoiceError::Streams))?;
 
     let check = streams.iter()
         .any(|stream| {
diff --git a/src/internal/ws_impl.rs b/src/internal/ws_impl.rs
index 72af52c..9fd2e2d 100644
--- a/src/internal/ws_impl.rs
+++ b/src/internal/ws_impl.rs
@@ -19,7 +19,7 @@ pub trait SenderExt {
 
 impl ReceiverExt for Receiver<WebSocketStream> {
     fn recv_json<F, T>(&mut self, decode: F) -> Result<T> where F: FnOnce(Value) -> Result<T> {
-        let message: WsMessage = try!(self.recv_message());
+        let message: WsMessage = self.recv_message()?;
 
         if message.opcode == WsType::Close {
             let r = String::from_utf8_lossy(&message.payload).into_owned();
@@ -27,9 +27,9 @@ impl ReceiverExt for Receiver<WebSocketStream> {
             Err(Error::Gateway(GatewayError::Closed(message.cd_status_code, r)))
         } else if message.opcode == WsType::Binary || message.opcode == WsType::Text {
             let json: Value = if message.opcode == WsType::Binary {
-                try!(serde_json::from_reader(ZlibDecoder::new(&message.payload[..])))
+                serde_json::from_reader(ZlibDecoder::new(&message.payload[..]))?
             } else {
-                try!(serde_json::from_reader(&message.payload[..]))
+                serde_json::from_reader(&message.payload[..])?
             };
 
             match decode(json) {
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 @@
-
diff --git a/src/utils/macros.rs b/src/utils/macros.rs
index e8f74dd..2ba37e0 100644
--- a/src/utils/macros.rs
+++ b/src/utils/macros.rs
@@ -1,25 +1,25 @@
 macro_rules! request {
     ($route:expr, $method:ident($body:expr), $url:expr, $($rest:tt)*) => {{
         let client = HyperClient::new();
-        try!(request($route, || client
+        request($route, || client
             .$method(&format!(api!($url), $($rest)*))
-            .body(&$body)))
+            .body(&$body))?
     }};
     ($route:expr, $method:ident($body:expr), $url:expr) => {{
         let client = HyperClient::new();
-        try!(request($route, || client
+        request($route, || client
             .$method(api!($url))
-            .body(&$body)))
+            .body(&$body))?
     }};
     ($route:expr, $method:ident, $url:expr, $($rest:tt)*) => {{
         let client = HyperClient::new();
-        try!(request($route, || client
-            .$method(&format!(api!($url), $($rest)*))))
+        request($route, || client
+            .$method(&format!(api!($url), $($rest)*)))?
     }};
     ($route:expr, $method:ident, $url:expr) => {{
         let client = HyperClient::new();
-        try!(request($route, || client
-            .$method(api!($url))))
+        request($route, || client
+            .$method(api!($url)))?
     }};
 }
 
diff --git a/src/utils/mod.rs b/src/utils/mod.rs
index 2401a1b..a7a14a3 100644
--- a/src/utils/mod.rs
+++ b/src/utils/mod.rs
@@ -186,7 +186,7 @@ pub fn read_image<P: AsRef<Path>>(path: P) -> Result<String> {
     let path = path.as_ref();
 
     let mut v = Vec::default();
-    let mut f = try!(File::open(path));
+    let mut f = File::open(path)?;
     let _ = f.read_to_end(&mut v);
 
     let b64 = base64::encode(&v);