Change iterators into by-value

Author: segeljakt

rust/src/reactive/flat_fat.rs

@@ -14,16 +14,14 @@ where
     fn with_capacity(capacity: usize) -> Self;
 
     /// Updates a non-contiguous batch of leaves
-    fn update<'a, I>(&mut self, batch: I)
+    fn update<I>(&mut self, batch: I)
     where
-        I: IntoIterator<Item = &'a (usize, Value)>,
-        Value: 'a;
+        I: IntoIterator<Item = (usize, Value)>;
 
     /// Updates a contiguous batch of leaves
-    fn update_ordered<'a, I>(&mut self, values: I)
+    fn update_ordered<I>(&mut self, values: I)
     where
-        I: IntoIterator<Item = &'a Value>,
-        Value: 'a;
+        I: IntoIterator<Item = Value>;
 
     /// Aggregates all nodes in the FAT and returns the result
     fn aggregate(&self) -> Value;
@@ -92,7 +90,7 @@ where
     fn new(values: &[Value]) -> Self {
         let capacity = values.len();
         let mut new = Self::with_capacity(capacity);
-        new.update_ordered(values);
+        new.update_ordered(values.iter().cloned());
         new
     }
 
@@ -105,16 +103,15 @@ where
         }
     }
 
-    fn update<'a, I>(&mut self, batch: I)
+    fn update<I>(&mut self, batch: I)
     where
-        I: IntoIterator<Item = &'a (usize, Value)>,
-        Value: 'a,
+        I: IntoIterator<Item = (usize, Value)>,
     {
         let mut parents: HashSet<usize> = batch
             .into_iter()
             .map(|(idx, val)| {
-                let leaf = self.leaf(*idx);
-                self.tree[leaf] = val.clone();
+                let leaf = self.leaf(idx);
+                self.tree[leaf] = val;
                 self.parent(leaf)
             })
             .collect();
@@ -136,14 +133,13 @@ where
         }
     }
 
-    fn update_ordered<'a, I>(&mut self, values: I)
+    fn update_ordered<I>(&mut self, values: I)
     where
-        I: IntoIterator<Item = &'a Value>,
-        Value: 'a,
+        I: IntoIterator<Item = Value>,
     {
         values.into_iter().enumerate().for_each(|(idx, val)| {
             let leaf = self.leaf(idx);
-            self.tree[leaf] = val.clone();
+            self.tree[leaf] = val;
         });
         (0..self.leaf(0)).into_iter().rev().for_each(|parent| {
             let left = self.left(parent);

rust/src/reactive/mod.rs

@@ -40,10 +40,11 @@ where
             fat.update_ordered(
                 leaves[self.front..]
                     .iter()
-                    .chain(leaves[..self.back].iter()),
+                    .chain(leaves[..self.back].iter())
+                    .cloned(),
             );
         } else {
-            fat.update_ordered(leaves[self.front..self.back].iter());
+            fat.update_ordered(leaves[self.front..self.back].iter().cloned());
         }
         self.fat = fat;
         self.front = 0;
@@ -65,15 +66,16 @@ where
         }
     }
     fn push(&mut self, v: Value) {
-        self.fat.update(&[(self.back, v)]);
+        self.fat.update([(self.back, v)].iter().cloned());
         self.size += 1;
         self.back += 1;
         if self.size > (3 * self.fat.capacity) / 4 {
             self.resize(self.fat.capacity * 2);
         }
     }
     fn pop(&mut self) {
-        self.fat.update(&[(self.front, Value::identity())]);
+        self.fat
+            .update([(self.front, Value::identity())].iter().cloned());
         self.size -= 1;
         self.front += 1;
         if self.size <= self.fat.capacity / 4 {