diff --git a/zokrates_analysis/src/flatten_complex_types.rs b/zokrates_analysis/src/flatten_complex_types.rs
index 37b01c4b..3aa597cb 100644
--- a/zokrates_analysis/src/flatten_complex_types.rs
+++ b/zokrates_analysis/src/flatten_complex_types.rs
@@ -652,7 +652,7 @@ fn fold_statement<'ast, T: Field>(
             let e = f.fold_expression(statements_buffer, e);
             assert_eq!(a.len(), e.len());
             a.into_iter()
-                .zip(e.into_iter())
+                .zip(e)
                 .map(|(a, e)| zir::ZirStatement::definition(a, e))
                 .collect()
         }
@@ -1023,7 +1023,7 @@ fn fold_conditional_expression<'ast, T: Field, E: Flatten<'ast, T>>(
 
     consequence
         .into_iter()
-        .zip(alternative.into_iter())
+        .zip(alternative)
         .map(|(c, a)| match (c, a) {
             (zir::ZirExpression::FieldElement(c), zir::ZirExpression::FieldElement(a)) => {
                 zir::FieldElementExpression::conditional(condition.clone(), c, a)
diff --git a/zokrates_ast/src/typed/integer.rs b/zokrates_ast/src/typed/integer.rs
index d5ba9ad5..b2d1f037 100644
--- a/zokrates_ast/src/typed/integer.rs
+++ b/zokrates_ast/src/typed/integer.rs
@@ -107,7 +107,7 @@ impl<'ast, T: Clone> IntegerInference for StructType<'ast, T> {
             members: self
                 .members
                 .into_iter()
-                .zip(other.members.into_iter())
+                .zip(other.members)
                 .map(|(m_t, m_u)| match m_t.ty.get_common_pattern(*m_u.ty) {
                     Ok(ty) => DeclarationStructMember {
                         ty: Box::new(ty),
diff --git a/zokrates_ast/src/typed/types.rs b/zokrates_ast/src/typed/types.rs
index 614880c1..8a0614a0 100644
--- a/zokrates_ast/src/typed/types.rs
+++ b/zokrates_ast/src/typed/types.rs
@@ -1377,7 +1377,7 @@ pub mod signature {
 
             constants.0.extend(
                 decl_generics
-                    .zip(values.into_iter())
+                    .zip(values)
                     .filter_map(|(g, v)| v.map(|v| (g, v))),
             );
 
diff --git a/zokrates_codegen/src/lib.rs b/zokrates_codegen/src/lib.rs
index 46faf587..685c78d3 100644
--- a/zokrates_codegen/src/lib.rs
+++ b/zokrates_codegen/src/lib.rs
@@ -1314,7 +1314,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
 
         let xor: Vec<FlatExpression<T>> = left_bits
             .into_iter()
-            .zip(right_bits.into_iter())
+            .zip(right_bits)
             .map(|(x, y)| match (x, y) {
                 (FlatExpression::Value(n), e) | (e, FlatExpression::Value(n)) => {
                     if n.value == T::from(0) {
@@ -1686,8 +1686,8 @@ impl<'ast, T: Field> Flattener<'ast, T> {
 
                             let res: Vec<FlatExpression<T>> = a_bits
                                 .into_iter()
-                                .zip(b_bits.into_iter())
-                                .zip(c_bits.into_iter())
+                                .zip(b_bits)
+                                .zip(c_bits)
                                 .map(|((a, b), c)| {
                                     // a(b - c) = ch - c
 
@@ -1753,8 +1753,8 @@ impl<'ast, T: Field> Flattener<'ast, T> {
 
                                     let res: Vec<FlatExpression<T>> = a_bits
                                         .into_iter()
-                                        .zip(b_bits.into_iter())
-                                        .zip(c_bits.into_iter())
+                                        .zip(b_bits)
+                                        .zip(c_bits)
                                         .map(|((a, b), c)| {
                                             // (b) * (c) = (bc)
                                             // (2bc - b - c) * (a) = bc - maj
@@ -1856,7 +1856,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
 
                 let and: Vec<_> = left_bits
                     .into_iter()
-                    .zip(right_bits.into_iter())
+                    .zip(right_bits)
                     .map(|(x, y)| match (x, y) {
                         (FlatExpression::Value(n), e) | (e, FlatExpression::Value(n)) => {
                             if n.value == T::from(0) {
@@ -1890,7 +1890,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
 
                 let or: Vec<FlatExpression<T>> = left_bits
                     .into_iter()
-                    .zip(right_bits.into_iter())
+                    .zip(right_bits)
                     .map(|(x, y)| match (x, y) {
                         (FlatExpression::Value(n), e) | (e, FlatExpression::Value(n)) => {
                             if n.value == T::from(0) {
diff --git a/zokrates_embed/src/ark.rs b/zokrates_embed/src/ark.rs
index fa854496..4097e34a 100644
--- a/zokrates_embed/src/ark.rs
+++ b/zokrates_embed/src/ark.rs
@@ -163,8 +163,8 @@ pub fn generate_verify_constraints(
     let constraints: Vec<Constraint<_>> = matrices
         .a
         .into_iter()
-        .zip(matrices.b.into_iter())
-        .zip(matrices.c.into_iter())
+        .zip(matrices.b)
+        .zip(matrices.c)
         .map(|((a, b), c)| Constraint { a, b, c })
         .collect();
 
diff --git a/zokrates_interpreter/src/lib.rs b/zokrates_interpreter/src/lib.rs
index 733b453c..9e9bff77 100644
--- a/zokrates_interpreter/src/lib.rs
+++ b/zokrates_interpreter/src/lib.rs
@@ -434,7 +434,7 @@ mod tests {
         #[test]
         fn execute() {
             let cond_eq = Solver::ConditionEq;
-            let inputs = vec![0];
+            let inputs = [0];
             let r = Interpreter::execute_solver(
                 &cond_eq,
                 &inputs
@@ -444,14 +444,14 @@ mod tests {
                 &[],
             )
             .unwrap();
-            let res: Vec<Bn128Field> = vec![0, 1].iter().map(|&i| Bn128Field::from(i)).collect();
+            let res: Vec<Bn128Field> = [0, 1].iter().map(|&i| Bn128Field::from(i)).collect();
             assert_eq!(r, &res[..]);
         }
 
         #[test]
         fn execute_non_eq() {
             let cond_eq = Solver::ConditionEq;
-            let inputs = vec![1];
+            let inputs = [1];
             let r = Interpreter::execute_solver(
                 &cond_eq,
                 &inputs
@@ -461,7 +461,7 @@ mod tests {
                 &[],
             )
             .unwrap();
-            let res: Vec<Bn128Field> = vec![1, 1].iter().map(|&i| Bn128Field::from(i)).collect();
+            let res: Vec<Bn128Field> = [1, 1].iter().map(|&i| Bn128Field::from(i)).collect();
             assert_eq!(r, &res[..]);
         }
     }
diff --git a/zokrates_proof_systems/src/scheme/gm17.rs b/zokrates_proof_systems/src/scheme/gm17.rs
index 97d1099c..1b55e82b 100644
--- a/zokrates_proof_systems/src/scheme/gm17.rs
+++ b/zokrates_proof_systems/src/scheme/gm17.rs
@@ -136,7 +136,7 @@ impl<T: SolidityCompatibleField> SolidityCompatibleScheme<T> for GM17 {
     }
 }
 
-const CONTRACT_TEMPLATE: &str = r#"
+const CONTRACT_TEMPLATE: &str = r"
 contract Verifier {
     using Pairing for *;
     struct VerifyingKey {
@@ -196,4 +196,4 @@ contract Verifier {
         }
     }
 }
-"#;
+";