Eliminate a few clone()s

src/bin/bin.rs

@@ -63,9 +63,9 @@ pub fn interpret(args: Args, compiled_data: CompiledData) {
 fn main() {
     let args: Args = Args::parse();
 
-    let geom = std::fs::read_to_string(args.geom.clone()).unwrap();
+    let geom = std::fs::read_to_string(&args.geom).unwrap();
 
-    let (tokens, mut errs) = lexer::lexer().parse_recovery(geom.clone());
+    let (tokens, mut errs) = lexer::lexer().parse_recovery(&*geom);
 
     let parse_errs = if let Some(tokens) = &tokens {
         let (ast, parse_errs) = parser().parse_recovery(Stream::from_iter(

src/geometry/compile/mod.rs

@@ -81,7 +81,7 @@ pub fn compile(expr: Expr) -> Result<CompiledData, Error> {
             .collect::<Vec<_>>();
 
         if let Some((transformation, map)) = compiled_transformation {
-            let transformation = label_transformation(transformation, numbered_labels);
+            let transformation = label_transformation(transformation, &numbered_labels);
 
             let geometry = standardize_geometry(&mut map.clone(), geometry);
 

src/geometry/compile/reads.rs

@@ -8,25 +8,20 @@ use std::{collections::HashMap, ops::Deref};
 use crate::parser::{Expr, Function, IntervalShape, Spanned};
 
 pub fn validate_geometry(
-    map: HashMap<String, GeometryMeta>,
-    geom: Vec<(Interval, usize)>,
+    map: &HashMap<String, GeometryMeta>,
+    geom: &[(Interval, usize)],
 ) -> Result<(), Error> {
     let mut expect_next = vec![
         ReturnType::FixedLen,
         ReturnType::FixedSeq,
         ReturnType::Unbounded,
         ReturnType::Ranged,
     ];
-    let mut iter = geom.iter();
 
-    loop {
-        let Some(next) = iter.next() else {
-            break;
-        };
-
-        let gm = match next {
-            (Interval::Named(l), _) => map.get(l).unwrap(),
-            (Interval::Temporary(gp_), _) => gp_,
+    for (interval, _) in geom {
+        let gm = match interval {
+            Interval::Named(l) => map.get(l).unwrap(),
+            Interval::Temporary(gp_) => gp_,
         };
 
         let (gp, span) = gm.expr.clone();
@@ -239,7 +234,7 @@ pub fn compile_reads(
             }
         }
 
-        if let Err(e) = validate_geometry(map.clone(), read_geom.clone()) {
+        if let Err(e) = validate_geometry(map, &read_geom) {
             err = Some(e);
             break 'outer_outer;
         }

src/geometry/compile/transformation.rs

@@ -124,8 +124,8 @@ fn compile(
     Ok((transformation, map))
 }
 
-fn find_num(l: &str, list: Vec<(Interval, usize)>) -> String {
-    for (interval, n) in &list {
+fn find_num(l: &str, list: &[(Interval, usize)]) -> String {
+    for (interval, n) in list {
         if let Interval::Named(name) = interval {
             if name == l {
                 return n.to_string();
@@ -138,15 +138,15 @@ fn find_num(l: &str, list: Vec<(Interval, usize)>) -> String {
 
 pub fn label_transformation(
     transformation: Transformation,
-    numbered_labels: Vec<(Interval, usize)>,
+    numbered_labels: &[(Interval, usize)],
 ) -> Transformation {
     let mut numbered_transformation: Transformation = Vec::new();
 
     for t in transformation {
         let mut inner_transformation: Vec<String> = Vec::new();
 
         for l in t {
-            let num = find_num(&l, numbered_labels.clone());
+            let num = find_num(&l, numbered_labels);
 
             inner_transformation.push(format!("seq{num}.{}", l));
         }

src/geometry/interpret.rs

@@ -43,7 +43,7 @@ impl CompiledData {
 
         for (i, read_geometry) in geometry.iter().enumerate() {
             read = interpret_geometry(
-                read_geometry.to_vec(),
+                read_geometry,
                 read,
                 &format!("seq{}.", i + 1),
                 "r",
@@ -79,14 +79,14 @@ impl CompiledData {
 }
 
 fn interpret_geometry(
-    geometry: Vec<GeometryMeta>,
+    geometry: &[GeometryMeta],
     read: BoxedReads,
     init_label: &str,
     right: &str,
     left: &str,
     additional_args: &[String],
 ) -> BoxedReads {
-    let mut geometry_iter = geometry.into_iter();
+    let mut geometry_iter = geometry.iter();
 
     let mut read = read;
 
@@ -308,7 +308,7 @@ impl GeometryMeta {
 
     fn interpret_dual(
         &self,
-        prev: Self,
+        prev: &Self,
         read: BoxedReads,
         label: &[String],
         right: &str,