diff --git a/src/client.rs b/src/client.rs
index d804b98..b9933c0 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -479,9 +479,8 @@
                 }
             };
 
-            match targets.targets().get(target) {
-                Some(t) => return (default_terminate, Ok(t.clone())),
-                None => (),
+            if let Some(t) = targets.targets().get(target) {
+                return (default_terminate, Ok(t.clone()));
             }
 
             let delegations = match targets.delegations() {
diff --git a/src/crypto.rs b/src/crypto.rs
index 25618ad..7227abf 100644
--- a/src/crypto.rs
+++ b/src/crypto.rs
@@ -74,10 +74,10 @@
     let mut size = 0;
     let mut hashes = HashMap::new();
     for alg in hash_algs {
-        let context = match alg {
-            &HashAlgorithm::Sha256 => digest::Context::new(&SHA256),
-            &HashAlgorithm::Sha512 => digest::Context::new(&SHA512),
-            &HashAlgorithm::Unknown(ref s) => return Err(Error::IllegalArgument(
+        let context = match *alg {
+            HashAlgorithm::Sha256 => digest::Context::new(&SHA256),
+            HashAlgorithm::Sha512 => digest::Context::new(&SHA512),
+            HashAlgorithm::Unknown(ref s) => return Err(Error::IllegalArgument(
                 format!("Unknown hash algorithm: {}", s)
             )),
         };
@@ -278,10 +278,10 @@
     }
 
     fn as_oid(&self) -> Result<&'static [u8]> {
-        match self {
-            &KeyType::Rsa => Ok(RSA_SPKI_OID),
-            &KeyType::Ed25519 => Ok(ED25519_SPKI_OID),
-            &KeyType::Unknown(ref s) => Err(Error::UnknownKeyType(s.clone())),
+        match *self {
+            KeyType::Rsa => Ok(RSA_SPKI_OID),
+            KeyType::Ed25519 => Ok(ED25519_SPKI_OID),
+            KeyType::Unknown(ref s) => Err(Error::UnknownKeyType(s.clone())),
         }
     }
 }
@@ -300,10 +300,10 @@
 
 impl ToString for KeyType {
     fn to_string(&self) -> String {
-        match self {
-            &KeyType::Ed25519 => "ed25519".to_string(),
-            &KeyType::Rsa => "rsa".to_string(),
-            &KeyType::Unknown(ref s) => s.to_string(),
+        match *self {
+            KeyType::Ed25519 => "ed25519".to_string(),
+            KeyType::Rsa => "rsa".to_string(),
+            KeyType::Unknown(ref s) => s.to_string(),
         }
     }
 }
@@ -333,9 +333,9 @@
 
 impl Debug for PrivateKeyType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let s = match self {
-            &PrivateKeyType::Ed25519(_) => "ed25519",
-            &PrivateKeyType::Rsa(_) => "rsa",
+        let s = match *self {
+            PrivateKeyType::Ed25519(_) => "ed25519",
+            PrivateKeyType::Rsa(_) => "rsa",
         };
         write!(f, "PrivateKeyType {{ \"{}\" }}", s)
     }
@@ -451,13 +451,10 @@
     }
 
     fn rsa_from_pkcs8(der_key: &[u8], scheme: SignatureScheme) -> Result<Self> {
-        match &scheme {
-            &SignatureScheme::Ed25519 => {
-                return Err(Error::IllegalArgument(
-                    "RSA keys do not support the Ed25519 signing scheme".into(),
-                ))
-            }
-            _ => (),
+        if let SignatureScheme::Ed25519 = scheme {
+            return Err(Error::IllegalArgument(
+                "RSA keys do not support the Ed25519 signing scheme".into(),
+            ));
         }
 
         let key = RSAKeyPair::from_pkcs8(Input::from(der_key)).map_err(|_| {
@@ -648,11 +645,11 @@
 
     /// Use this key to verify a message with a signature.
     pub fn verify(&self, msg: &[u8], sig: &Signature) -> Result<()> {
-        let alg: &ring::signature::VerificationAlgorithm = match &self.scheme {
-            &SignatureScheme::Ed25519 => &ED25519,
-            &SignatureScheme::RsaSsaPssSha256 => &RSA_PSS_2048_8192_SHA256,
-            &SignatureScheme::RsaSsaPssSha512 => &RSA_PSS_2048_8192_SHA512,
-            &SignatureScheme::Unknown(ref s) => return Err(Error::IllegalArgument(
+        let alg: &ring::signature::VerificationAlgorithm = match self.scheme {
+            SignatureScheme::Ed25519 => &ED25519,
+            SignatureScheme::RsaSsaPssSha256 => &RSA_PSS_2048_8192_SHA256,
+            SignatureScheme::RsaSsaPssSha512 => &RSA_PSS_2048_8192_SHA512,
+            SignatureScheme::Unknown(ref s) => return Err(Error::IllegalArgument(
                 format!("Unknown signature scheme: {}", s)
             )),
         };
diff --git a/src/interchange/cjson.rs b/src/interchange/cjson.rs
index 2071fb6..5f2d947 100644
--- a/src/interchange/cjson.rs
+++ b/src/interchange/cjson.rs
@@ -20,27 +20,37 @@
 
 impl Value {
     fn write(&self, mut buf: &mut Vec<u8>) -> Result<(), String> {
-        match self {
-            &Value::Null => Ok(buf.extend(b"null")),
-            &Value::Bool(true) => Ok(buf.extend(b"true")),
-            &Value::Bool(false) => Ok(buf.extend(b"false")),
-            &Value::Number(Number::I64(n)) => {
+        match *self {
+            Value::Null => {
+                buf.extend(b"null");
+                Ok(())
+            }
+            Value::Bool(true) => {
+                buf.extend(b"true");
+                Ok(())
+            }
+            Value::Bool(false) => {
+                buf.extend(b"false");
+                Ok(())
+            }
+            Value::Number(Number::I64(n)) => {
                 itoa::write(buf, n).map(|_| ()).map_err(|err| {
                     format!("Write error: {}", err)
                 })
             }
-            &Value::Number(Number::U64(n)) => {
+            Value::Number(Number::U64(n)) => {
                 itoa::write(buf, n).map(|_| ()).map_err(|err| {
                     format!("Write error: {}", err)
                 })
             }
-            &Value::String(ref s) => {
+            Value::String(ref s) => {
                 // this mess is abusing serde_json to get json escaping
                 let s = json::Value::String(s.clone());
                 let s = json::to_string(&s).map_err(|e| format!("{:?}", e))?;
-                Ok(buf.extend(s.as_bytes()))
+                buf.extend(s.as_bytes());
+                Ok(())
             }
-            &Value::Array(ref arr) => {
+            Value::Array(ref arr) => {
                 buf.push(b'[');
                 let mut first = true;
                 for a in arr.iter() {
@@ -50,9 +60,10 @@
                     a.write(&mut buf)?;
                     first = false;
                 }
-                Ok(buf.push(b']'))
+                buf.push(b']');
+                Ok(())
             }
-            &Value::Object(ref obj) => {
+            Value::Object(ref obj) => {
                 buf.push(b'{');
                 let mut first = true;
                 for (k, v) in obj.iter() {
@@ -69,7 +80,8 @@
                     buf.push(b':');
                     v.write(&mut buf)?;
                 }
-                Ok(buf.push(b'}'))
+                buf.push(b'}');
+                Ok(())
             }
         }
     }
@@ -81,31 +93,31 @@
 }
 
 fn convert(jsn: &json::Value) -> Result<Value, String> {
-    match jsn {
-        &json::Value::Null => Ok(Value::Null),
-        &json::Value::Bool(b) => Ok(Value::Bool(b)),
-        &json::Value::Number(ref n) => {
+    match *jsn {
+        json::Value::Null => Ok(Value::Null),
+        json::Value::Bool(b) => Ok(Value::Bool(b)),
+        json::Value::Number(ref n) => {
             n.as_i64()
                 .map(Number::I64)
-                .or(n.as_u64().map(Number::U64))
+                .or_else(|| n.as_u64().map(Number::U64))
                 .map(Value::Number)
                 .ok_or_else(|| String::from("only i64 and u64 are supported"))
         }
-        &json::Value::Array(ref arr) => {
+        json::Value::Array(ref arr) => {
             let mut out = Vec::new();
             for res in arr.iter().map(|v| convert(v)) {
                 out.push(res?)
             }
             Ok(Value::Array(out))
         }
-        &json::Value::Object(ref obj) => {
+        json::Value::Object(ref obj) => {
             let mut out = BTreeMap::new();
             for (k, v) in obj.iter() {
                 let _ = out.insert(k.clone(), convert(v)?);
             }
             Ok(Value::Object(out))
         }
-        &json::Value::String(ref s) => Ok(Value::String(s.clone())),
+        json::Value::String(ref s) => Ok(Value::String(s.clone())),
     }
 }
 
diff --git a/src/metadata.rs b/src/metadata.rs
index 9b77bac..90a1c36 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -168,12 +168,12 @@
     /// assert!(!Role::Root.fuzzy_matches_path(&MetadataPath::new("wat".into()).unwrap()));
     /// ```
     pub fn fuzzy_matches_path(&self, path: &MetadataPath) -> bool {
-        match self {
-            &Role::Root if &path.0 == "root" => true,
-            &Role::Snapshot if &path.0 == "snapshot" => true,
-            &Role::Timestamp if &path.0 == "timestamp" => true,
-            &Role::Targets if &path.0 == "targets" => true,
-            &Role::Targets if !&["root", "snapshot", "targets"].contains(&path.0.as_str()) => true,
+        match *self {
+            Role::Root if &path.0 == "root" => true,
+            Role::Snapshot if &path.0 == "snapshot" => true,
+            Role::Timestamp if &path.0 == "timestamp" => true,
+            Role::Targets if &path.0 == "targets" => true,
+            Role::Targets if !&["root", "snapshot", "targets"].contains(&path.0.as_str()) => true,
             _ => false,
         }
     }
@@ -181,11 +181,11 @@
 
 impl Display for Role {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &Role::Root => write!(f, "root"),
-            &Role::Snapshot => write!(f, "snapshot"),
-            &Role::Targets => write!(f, "targets"),
-            &Role::Timestamp => write!(f, "timestamp"),
+        match *self {
+            Role::Root => write!(f, "root"),
+            Role::Snapshot => write!(f, "snapshot"),
+            Role::Targets => write!(f, "targets"),
+            Role::Timestamp => write!(f, "timestamp"),
         }
     }
 }
@@ -204,10 +204,10 @@
 impl MetadataVersion {
     /// Converts this struct into the string used for addressing metadata.
     pub fn prefix(&self) -> String {
-        match self {
-            &MetadataVersion::None => String::new(),
-            &MetadataVersion::Number(ref x) => format!("{}.", x),
-            &MetadataVersion::Hash(ref v) => format!("{}.", v),
+        match *self {
+            MetadataVersion::None => String::new(),
+            MetadataVersion::Number(ref x) => format!("{}.", x),
+            MetadataVersion::Hash(ref v) => format!("{}.", v),
         }
     }
 }
diff --git a/src/repository.rs b/src/repository.rs
index 410d45c..e0d36a8 100644
--- a/src/repository.rs
+++ b/src/repository.rs
@@ -302,7 +302,7 @@
             let mut segments = url.path_segments_mut().map_err(|_| {
                 Error::IllegalArgument(format!("URL was 'cannot-be-a-base': {:?}", self.url))
             })?;
-            if let &Some(ref prefix) = prefix {
+            if let Some(ref prefix) = prefix {
                 segments.extend(prefix);
             }
             segments.extend(components);
diff --git a/src/tuf.rs b/src/tuf.rs
index 56dda7b..777ed5d 100644
--- a/src/tuf.rs
+++ b/src/tuf.rs
@@ -535,37 +535,37 @@
     }
 
     fn safe_snapshot_ref(&self) -> Result<&SnapshotMetadata> {
-        match &self.snapshot {
-            &Some(ref snapshot) => {
+        match self.snapshot {
+            Some(ref snapshot) => {
                 if snapshot.expires() <= &Utc::now() {
                     return Err(Error::ExpiredMetadata(Role::Snapshot));
                 }
                 Ok(snapshot)
             }
-            &None => Err(Error::MissingMetadata(Role::Snapshot)),
+            None => Err(Error::MissingMetadata(Role::Snapshot)),
         }
     }
 
     fn safe_targets_ref(&self) -> Result<&TargetsMetadata> {
-        match &self.targets {
-            &Some(ref targets) => {
+        match self.targets {
+            Some(ref targets) => {
                 if targets.expires() <= &Utc::now() {
                     return Err(Error::ExpiredMetadata(Role::Targets));
                 }
                 Ok(targets)
             }
-            &None => Err(Error::MissingMetadata(Role::Targets)),
+            None => Err(Error::MissingMetadata(Role::Targets)),
         }
     }
     fn safe_timestamp_ref(&self) -> Result<&TimestampMetadata> {
-        match &self.timestamp {
-            &Some(ref timestamp) => {
+        match self.timestamp {
+            Some(ref timestamp) => {
                 if timestamp.expires() <= &Utc::now() {
                     return Err(Error::ExpiredMetadata(Role::Timestamp));
                 }
                 Ok(timestamp)
             }
-            &None => Err(Error::MissingMetadata(Role::Timestamp)),
+            None => Err(Error::MissingMetadata(Role::Timestamp)),
         }
     }
 }
diff --git a/src/util.rs b/src/util.rs
index 0845e8e..ea0f5b2 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -41,10 +41,10 @@
     ) -> Result<Self> {
         let hasher = match hash_data {
             Some((alg, value)) => {
-                let ctx = match alg {
-                    &HashAlgorithm::Sha256 => digest::Context::new(&SHA256),
-                    &HashAlgorithm::Sha512 => digest::Context::new(&SHA512),
-                    &HashAlgorithm::Unknown(ref s) => return Err(Error::IllegalArgument(
+                let ctx = match *alg {
+                    HashAlgorithm::Sha256 => digest::Context::new(&SHA256),
+                    HashAlgorithm::Sha512 => digest::Context::new(&SHA512),
+                    HashAlgorithm::Unknown(ref s) => return Err(Error::IllegalArgument(
                         format!("Unknown hash algorithm: {}", s)
                     )),
                 };
@@ -109,9 +109,8 @@
                     }
                 }
 
-                match self.hasher {
-                    Some((ref mut context, _)) => context.update(&buf[..(read_bytes)]),
-                    None => (),
+                if let Some((ref mut context, _)) = self.hasher {
+                    context.update(&buf[..(read_bytes)]);
                 }
 
                 Ok(read_bytes)