diff --git a/src/dev.rs b/src/dev.rs
index 19c05b86..9e6235b7 100644
--- a/src/dev.rs
+++ b/src/dev.rs
@@ -489,7 +489,7 @@ impl<F: FieldExt> MockProver<F> {
                     // every selector is explicitly enabled or disabled on every row? But that
                     // seems messy and confusing.
                     .enumerate()
-                    .filter(move |(_, g)| g.queried_selectors().contains(&selector))
+                    .filter(move |(_, g)| g.queried_selectors().contains(selector))
                     .flat_map(move |(gate_index, gate)| {
                         at.iter().flat_map(move |selector_row| {
                             // Selectors are queried with no rotation.
diff --git a/src/plonk/lookup/prover.rs b/src/plonk/lookup/prover.rs
index a2528bf2..522e2a4a 100644
--- a/src/plonk/lookup/prover.rs
+++ b/src/plonk/lookup/prover.rs
@@ -173,7 +173,7 @@ impl<F: FieldExt> Argument<F> {
         let commit_values = |values: &Polynomial<C::Scalar, LagrangeCoeff>| {
             let poly = pk.vk.domain.lagrange_to_coeff(values.clone());
             let blind = Blind(C::Scalar::rand());
-            let commitment = params.commit_lagrange(&values, blind).to_affine();
+            let commitment = params.commit_lagrange(values, blind).to_affine();
             (poly, blind, commitment)
         };
 
@@ -604,7 +604,7 @@ fn permute_expression_pair<C: CurveAffine>(
             if row == 0 || *input_value != permuted_input_expression[row - 1] {
                 *table_value = *input_value;
                 // Remove one instance of input_value from leftover_table_map
-                if let Some(count) = leftover_table_map.get_mut(&input_value) {
+                if let Some(count) = leftover_table_map.get_mut(input_value) {
                     assert!(*count > 0);
                     *count -= 1;
                     None
diff --git a/src/plonk/prover.rs b/src/plonk/prover.rs
index b64d3bc5..91724c5b 100644
--- a/src/plonk/prover.rs
+++ b/src/plonk/prover.rs
@@ -276,13 +276,13 @@ pub fn create_proof<
                 .iter()
                 .map(|lookup| {
                     lookup.commit_permuted(
-                        &pk,
-                        &params,
-                        &domain,
+                        pk,
+                        params,
+                        domain,
                         theta,
                         &advice.advice_values,
                         &pk.fixed_values,
-                        &instance.instance_values,
+                        instance.instance_values,
                         &advice.advice_cosets,
                         &pk.fixed_cosets,
                         &instance.instance_cosets,
@@ -316,7 +316,7 @@ pub fn create_proof<
                         pkey,
                         &advice.advice_values,
                         &pk.fixed_values,
-                        &instance.instance_values,
+                        instance.instance_values,
                         beta,
                         gamma,
                         transcript,
@@ -332,7 +332,7 @@ pub fn create_proof<
             // Construct and commit to products for each lookup
             lookups
                 .into_iter()
-                .map(|lookup| lookup.commit_product(&pk, &params, theta, beta, gamma, transcript))
+                .map(|lookup| lookup.commit_product(pk, params, theta, beta, gamma, transcript))
                 .collect::<Result<Vec<_>, _>>()
         })
         .collect::<Result<Vec<_>, _>>()?;
diff --git a/src/plonk/vanishing/prover.rs b/src/plonk/vanishing/prover.rs
index f4e8070f..406b4d56 100644
--- a/src/plonk/vanishing/prover.rs
+++ b/src/plonk/vanishing/prover.rs
@@ -51,7 +51,7 @@ impl<C: CurveAffine> Argument<C> {
         let h_commitments_projective: Vec<_> = h_pieces
             .iter()
             .zip(h_blinds.iter())
-            .map(|(h_piece, blind)| params.commit(&h_piece, *blind))
+            .map(|(h_piece, blind)| params.commit(h_piece, *blind))
             .collect();
         let mut h_commitments = vec![C::identity(); h_commitments_projective.len()];
         C::Curve::batch_normalize(&h_commitments_projective, &mut h_commitments);
diff --git a/src/plonk/verifier.rs b/src/plonk/verifier.rs
index c3255b41..7e328ae3 100644
--- a/src/plonk/verifier.rs
+++ b/src/plonk/verifier.rs
@@ -187,9 +187,9 @@ pub fn verify_proof<'a, C: CurveAffine, E: EncodedChallenge<C>, T: TranscriptRea
                                     p.expressions(
                                         vk,
                                         argument,
-                                        &advice_evals,
+                                        advice_evals,
                                         &fixed_evals_copy,
-                                        &instance_evals,
+                                        instance_evals,
                                         l_0,
                                         beta,
                                         gamma,
@@ -209,9 +209,9 @@ pub fn verify_proof<'a, C: CurveAffine, E: EncodedChallenge<C>, T: TranscriptRea
                                         theta,
                                         beta,
                                         gamma,
-                                        &advice_evals,
+                                        advice_evals,
                                         &fixed_evals_copy_copy,
-                                        &instance_evals,
+                                        instance_evals,
                                     )
                                 })
                                 .into_iter(),
diff --git a/src/poly/commitment/msm.rs b/src/poly/commitment/msm.rs
index 8de63845..7bfe3e47 100644
--- a/src/poly/commitment/msm.rs
+++ b/src/poly/commitment/msm.rs
@@ -39,7 +39,7 @@ impl<'a, C: CurveAffine> MSM<'a, C> {
         self.other_bases.extend(other.other_bases.iter());
 
         if let Some(g_scalars) = &other.g_scalars {
-            self.add_to_g_scalars(&g_scalars);
+            self.add_to_g_scalars(g_scalars);
         }
 
         if let Some(h_scalar) = &other.h_scalar {
diff --git a/src/poly/commitment/verifier.rs b/src/poly/commitment/verifier.rs
index a8bbe5d2..134df346 100644
--- a/src/poly/commitment/verifier.rs
+++ b/src/poly/commitment/verifier.rs
@@ -173,7 +173,7 @@ fn compute_s<F: Field>(challenges: &[F], init: F) -> Vec<F> {
     {
         let (left, right) = v.split_at_mut(len);
         let right = &mut right[0..len];
-        right.copy_from_slice(&left);
+        right.copy_from_slice(left);
         for v in right {
             *v *= challenge;
         }
diff --git a/src/poly/multiopen/prover.rs b/src/poly/multiopen/prover.rs
index 77e315df..ba5df952 100644
--- a/src/poly/multiopen/prover.rs
+++ b/src/poly/multiopen/prover.rs
@@ -114,7 +114,7 @@ where
         },
     );
 
-    commitment::create_proof(&params, transcript, &f_poly, f_blind_try, *x_3)
+    commitment::create_proof(params, transcript, &f_poly, f_blind_try, *x_3)
 }
 
 #[doc(hidden)]