@@ -32,7 +32,7 @@ input: &[UInt8],
         r: &Self::RandomnessGadget,
     ) -> Result<Self::OutputGadget, SynthesisError> {
         let mut input_bits = Vec::with_capacity(512);
-        for byte in input.into_iter().chain(r.0.iter()) {
+        for byte in input.iter().chain(r.0.iter()) {
             input_bits.extend_from_slice(&byte.into_bits_le());
         }
         let mut result = Vec::new();
@@ -141,13 +141,13 @@ let parameters = ();
         let primitive_result = Blake2sCommitment::commit(&parameters, &input, &randomness).unwrap();
 
         let mut input_bytes = vec![];
-        for (byte_i, input_byte) in input.into_iter().enumerate() {
+        for (byte_i, input_byte) in input.iter().enumerate() {
             let cs = cs.ns(|| format!("input_byte_gadget_{}", byte_i));
             input_bytes.push(UInt8::alloc(cs, || Ok(*input_byte)).unwrap());
         }
 
         let mut randomness_bytes = vec![];
-        for (byte_i, random_byte) in randomness.into_iter().enumerate() {
+        for (byte_i, random_byte) in randomness.iter().enumerate() {
             let cs = cs.ns(|| format!("randomness_byte_gadget_{}", byte_i));
             randomness_bytes.push(UInt8::alloc(cs, || Ok(*random_byte)).unwrap());
         }

@@ -218,7 +218,7 @@ let primitive_result =
             PedersenCommitment::<JubJub, Window>::commit(&parameters, &input, &randomness).unwrap();
 
         let mut input_bytes = vec![];
-        for (byte_i, input_byte) in input.into_iter().enumerate() {
+        for (byte_i, input_byte) in input.iter().enumerate() {
             let cs = cs.ns(|| format!("input_byte_gadget_{}", byte_i));
             input_bytes.push(UInt8::alloc(cs, || Ok(*input_byte)).unwrap());
         }

@@ -72,7 +72,7 @@
         // Allocate new variable for the result.
         let input_in_bits = input_in_bits
             .chunks(W::WINDOW_SIZE * CHUNK_SIZE)
-            .map(|x| x.chunks(CHUNK_SIZE).into_iter().collect::<Vec<_>>())
+            .map(|x| x.chunks(CHUNK_SIZE).collect::<Vec<_>>())
             .collect::<Vec<_>>();
         let result = GG::precomputed_base_3_bit_signed_digit_scalar_mul(
             cs,
@@ -159,7 +159,7 @@ let mut input = [1u8; 270];
         rng.fill_bytes(&mut input);
 
         let mut input_bytes = vec![];
-        for (byte_i, input_byte) in input.into_iter().enumerate() {
+        for (byte_i, input_byte) in input.iter().enumerate() {
             let cs = cs.ns(|| format!("input_byte_gadget_{}", byte_i));
             input_bytes.push(UInt8::alloc(cs, || Ok(*input_byte)).unwrap());
         }

@@ -147,7 +147,7 @@ let mut input = [1u8; 128];
         rng.fill_bytes(&mut input);
 
         let mut input_bytes = vec![];
-        for (byte_i, input_byte) in input.into_iter().enumerate() {
+        for (byte_i, input_byte) in input.iter().enumerate() {
             let cs = cs.ns(|| format!("input_byte_gadget_{}", byte_i));
             input_bytes.push(UInt8::alloc(cs, || Ok(*input_byte)).unwrap());
         }

@@ -482,7 +482,7 @@ ) -> Result<Self::OutputGadget, SynthesisError> {
         assert_eq!(seed.len(), 32);
         // assert_eq!(input.len(), 32);
         let mut gadget_input = Vec::with_capacity(512);
-        for byte in seed.into_iter().chain(input) {
+        for byte in seed.iter().chain(input) {
             gadget_input.extend_from_slice(&byte.into_bits_le());
         }
         let mut result = Vec::new();

@@ -371,7 +371,7 @@ cs: &mut CS,
         values: &[u8],
     ) -> Vec<Self> {
         let mut input_bits = vec![];
-        for (byte_i, input_byte) in values.into_iter().enumerate() {
+        for (byte_i, input_byte) in values.iter().enumerate() {
             for bit_i in (0..8).rev() {
                 let cs = cs.ns(|| format!("input_bit_gadget {} {}", byte_i, bit_i));
                 input_bits.push(

@@ -291,7 +291,7 @@ ],
             None => [None, None, None, None],
         };
         let mut bytes = Vec::new();
-        for (i, chunk8) in self.to_bits_le().chunks(8).into_iter().enumerate() {
+        for (i, chunk8) in self.to_bits_le().chunks(8).enumerate() {
             let byte = UInt8 {
                 bits:  chunk8.to_vec(),
                 value: value_chunks[i],

@@ -60,7 +60,7 @@ CS: ConstraintSystem<ConstraintF>,
         T: Into<Option<u8>> + Copy,
     {
         let mut output_vec = Vec::with_capacity(values.len());
-        for (i, value) in values.into_iter().enumerate() {
+        for (i, value) in values.iter().enumerate() {
             let byte: Option<u8> = Into::into(*value);
             let alloc_byte = Self::alloc(&mut cs.ns(|| format!("byte_{}", i)), || byte.get())?;
             output_vec.push(alloc_byte);
@@ -115,7 +115,7 @@ /// Turns this `UInt8` into its little-endian byte order representation.
     /// LSB-first means that we can easily get the corresponding field element
     /// via double and add.
     pub fn into_bits_le(&self) -> Vec<Boolean> {
-        self.bits.iter().cloned().collect()
+        self.bits.to_vec()
     }
 
     /// Converts a little-endian byte order representation of bits into a
@@ -317,7 +317,7 @@
     #[test]
     fn test_uint8_alloc_input_vec() {
         let mut cs = TestConstraintSystem::<Fr>::new();
-        let byte_vals = (64u8..128u8).into_iter().collect::<Vec<_>>();
+        let byte_vals = (64u8..128u8).collect::<Vec<_>>();
         let bytes = UInt8::alloc_input_vec(cs.ns(|| "alloc value"), &byte_vals).unwrap();
         for (native_byte, gadget_byte) in byte_vals.into_iter().zip(bytes) {
             let bits = gadget_byte.into_bits_le();

@@ -217,7 +217,7 @@ mut cs: CS,
         bits: &[Boolean],
     ) -> Result<Self, SynthesisError> {
         let mut res = Self::one(cs.ns(|| "Alloc result"))?;
-        for (i, bit) in bits.into_iter().enumerate() {
+        for (i, bit) in bits.iter().enumerate() {
             res = res.square(cs.ns(|| format!("Double {}", i)))?;
             let tmp = res.mul(cs.ns(|| format!("Add {}-th base power", i)), self)?;
             res = Self::conditionally_select(

@@ -983,11 +983,11 @@ };
 
             // Compute ∏(h_i^{m_i}) for all i.
             for (segment_i, (segment_bits_chunks, segment_powers)) in
-                scalars.into_iter().zip(bases.iter()).enumerate()
+                scalars.iter().zip(bases.iter()).enumerate()
             {
                 for (i, (bits, base_power)) in segment_bits_chunks
                     .borrow()
-                    .into_iter()
+                    .iter()
                     .zip(segment_powers.borrow().iter())
                     .enumerate()
                 {

@@ -102,7 +102,7 @@ ps: &[Self::G1PreparedGadget],
         qs: &[Self::G2PreparedGadget],
     ) -> Result<Self::GTGadget, SynthesisError> {
         let mut pairs = vec![];
-        for (p, q) in ps.into_iter().zip(qs.into_iter()) {
+        for (p, q) in ps.iter().zip(qs.iter()) {
             pairs.push((p, q.ell_coeffs.iter()));
         }
         let mut f = Self::GTGadget::one(cs.ns(|| "one"))?;