Properly drop on binds

Instead of binding to `_why`, bind to `_`, dropping the value.

This is pretty much just leftover from when the library was being
rapidly developed before being released.

6 files changed, 22 insertions, 25 deletions

diff --git a/src/client/rest/mod.rs b/src/client/rest/mod.rs
index e219fc2..ff49809 100644
--- a/src/client/rest/mod.rs
+++ b/src/client/rest/mod.rs
@@ -1470,7 +1470,7 @@ pub fn send_file<R: Read>(channel_id: u64,
     let uri = format!(api!("/channels/{}/messages"), channel_id);
     let url = match Url::parse(&uri) {
         Ok(url) => url,
-        Err(_why) => return Err(Error::Url(uri)),
+        Err(_) => return Err(Error::Url(uri)),
     };
 
     let mut request = Request::new(Method::Post, url)?;
diff --git a/src/client/rest/ratelimiting.rs b/src/client/rest/ratelimiting.rs
index 9a7ba8e..e915fb7 100644
--- a/src/client/rest/ratelimiting.rs
+++ b/src/client/rest/ratelimiting.rs
@@ -233,9 +233,9 @@ fn get_header(headers: &Headers, header: &str) -> Result<Option<i64>> {
         Some(header) => match str::from_utf8(&header[0]) {
             Ok(v) => match v.parse::<i64>() {
                 Ok(v) => Ok(Some(v)),
-                Err(_why) => Err(Error::Client(ClientError::RateLimitI64)),
+                Err(_) => Err(Error::Client(ClientError::RateLimitI64)),
             },
-            Err(_why) => Err(Error::Client(ClientError::RateLimitUtf8)),
+            Err(_) => Err(Error::Client(ClientError::RateLimitUtf8)),
         },
         None => Ok(None),
     }
diff --git a/src/ext/voice/connection.rs b/src/ext/voice/connection.rs
index 3f40d85..1b2569d 100644
--- a/src/ext/voice/connection.rs
+++ b/src/ext/voice/connection.rs
@@ -83,7 +83,7 @@ impl Connection {
 
                         break;
                     },
-                    VoiceEvent::Heartbeat(_heartbeat) => continue,
+                    VoiceEvent::Heartbeat(_) => continue,
                     other => {
                         debug!("[Voice] Expected hello/heartbeat; got: {:?}",
                                other);
@@ -220,7 +220,7 @@ impl Connection {
             }
         } else {
             loop {
-                if let Err(_why) = self.thread_items.rx.try_recv() {
+                if let Err(_) = self.thread_items.rx.try_recv() {
                     break;
                 }
             }
@@ -440,10 +440,10 @@ fn start_threads(mut receiver: WsReceiver<WebSocketStream>, udp: &UdpSocket)
                     let piece = buffer[..len].iter().cloned().collect();
                     let send = tx.send(ReceiverStatus::Udp(piece));
 
-                    if let Err(_why) = send {
+                    if let Err(_) = send {
                         return;
                     }
-                } else if let Ok(_v) = udp_close_reader.try_recv() {
+                } else if let Ok(_) = udp_close_reader.try_recv() {
                     return;
                 }
             }
@@ -454,12 +454,12 @@ fn start_threads(mut receiver: WsReceiver<WebSocketStream>, udp: &UdpSocket)
         .spawn(move || {
             loop {
                 while let Ok(msg) = receiver.recv_json(VoiceEvent::decode) {
-                    if let Err(_why) = tx_clone.send(ReceiverStatus::Websocket(msg)) {
+                    if let Err(_) = tx_clone.send(ReceiverStatus::Websocket(msg)) {
                         return;
                     }
                 }
 
-                if let Ok(_v) = ws_close_reader.try_recv() {
+                if let Ok(_) = ws_close_reader.try_recv() {
                     return;
                 }
 
diff --git a/src/ext/voice/handler.rs b/src/ext/voice/handler.rs
index f954d22..949e725 100644
--- a/src/ext/voice/handler.rs
+++ b/src/ext/voice/handler.rs
@@ -161,13 +161,10 @@ impl Handler {
     /// This does _not_ forget settings, like whether to be self-deafened or
     /// self-muted.
     pub fn leave(&mut self) {
-        match self.channel_id {
-            None => return,
-            Some(_channel_id) => {
-                self.channel_id = None;
+        if let Some(_) = self.channel_id {
+            self.channel_id = None;
 
-                self.update();
-            },
+            self.update();
         }
     }
 
@@ -231,7 +228,7 @@ impl Handler {
                 // If already connected to the given channel, do nothing.
                 return;
             },
-            Some(_current_id) => {
+            Some(_) => {
                 self.channel_id = Some(channel_id);
 
                 self.update();
diff --git a/src/model/guild.rs b/src/model/guild.rs
index e133646..0955ce6 100644
--- a/src/model/guild.rs
+++ b/src/model/guild.rs
@@ -758,8 +758,8 @@ impl Guild {
         };
 
         self.members
-            .iter()
-            .find(|&(_member_id, member)| {
+            .values()
+            .find(|member| {
                 let name_matches = member.user.name == name;
                 let discrim_matches = match discrim {
                     Some(discrim) => member.user.discriminator == discrim,
@@ -767,9 +767,9 @@ impl Guild {
                 };
 
                 name_matches && discrim_matches
-            }).or_else(|| self.members.iter().find(|&(_member_id, member)| {
+            }).or_else(|| self.members.values().find(|member| {
                 member.nick.as_ref().map_or(false, |nick| nick == name)
-            })).map(|(_member_id, member)| member)
+            }))
     }
 
     /// Retrieves the count of the number of [`Member`]s that would be pruned
@@ -1777,8 +1777,8 @@ impl Member {
             .values()
             .find(|guild| {
                 guild.members
-                    .iter()
-                    .any(|(_member_id, member)| {
+                    .values()
+                    .any(|member| {
                         let joined_at = member.joined_at == self.joined_at;
                         let user_id = member.user.id == self.user.id;
 
diff --git a/src/model/utils.rs b/src/model/utils.rs
index dee9a08..58701bb 100644
--- a/src/model/utils.rs
+++ b/src/model/utils.rs
@@ -259,7 +259,7 @@ pub fn into_u64(value: Value) -> Result<u64> {
         Value::I64(v) => Ok(v as u64),
         Value::String(v) => match v.parse::<u64>() {
             Ok(v) => Ok(v),
-            Err(_why) => Err(Error::Decode("Expected valid u64", Value::String(v))),
+            Err(_) => Err(Error::Decode("Expected valid u64", Value::String(v))),
         },
         Value::U64(v) => Ok(v),
         value => Err(Error::Decode("Expected u64", value)),
@@ -280,8 +280,8 @@ pub fn decode_discriminator(value: Value) -> Result<u16> {
         Value::U64(v) => Ok(v as u16),
         Value::String(s) => match s.parse::<u16>() {
             Ok(v) => Ok(v),
-            Err(_why) => Err(Error::Decode("Error parsing discriminator as u16",
-                                           Value::String(s))),
+            Err(_) => Err(Error::Decode("Error parsing discriminator as u16",
+                                        Value::String(s))),
         },
         value => Err(Error::Decode("Expected string or u64", value)),
     }