rename to iter_gen

fastfield_codecs/src/column.rs

@@ -124,8 +124,7 @@ impl<'a, T: Copy + PartialOrd + Send + Sync> Column<T> for VecColumn<'a, T> {
 }
 
 impl<'a, T: Copy + Ord + Default, V> From<&'a V> for VecColumn<'a, T>
-where
-    V: AsRef<[T]> + ?Sized,
+where V: AsRef<[T]> + ?Sized
 {
     fn from(values: &'a V) -> Self {
         let values = values.as_ref();
@@ -217,8 +216,7 @@ where
 pub struct IterColumn<T>(T);
 
 impl<T> From<T> for IterColumn<T>
-where
-    T: Iterator + Clone + ExactSizeIterator,
+where T: Iterator + Clone + ExactSizeIterator
 {
     fn from(iter: T) -> Self {
         IterColumn(iter)

src/fastfield/multivalued/writer.rs

@@ -361,8 +361,8 @@ impl MultiValueU128FastFieldWriter {
         {
             let field_write = serializer.get_field_writer(self.field, 1);
 
-            let iter = || self.get_ordered_values(doc_id_map).flatten().cloned();
-            serialize_u128(iter, self.vals.len() as u64, field_write)?;
+            let iter_gen = || self.get_ordered_values(doc_id_map).flatten().cloned();
+            serialize_u128(iter_gen, self.vals.len() as u64, field_write)?;
         }
         Ok(())
     }

src/fastfield/writer.rs

@@ -350,15 +350,15 @@ impl U128FastFieldWriter {
         let field_write = serializer.get_field_writer(self.field, 0);
 
         if let Some(doc_id_map) = doc_id_map {
-            let iter = || {
+            let iter_gen = || {
                 doc_id_map
                     .iter_old_doc_ids()
                     .map(|idx| self.vals[idx as usize])
             };
-            serialize_u128(iter, self.val_count as u64, field_write)?;
+            serialize_u128(iter_gen, self.val_count as u64, field_write)?;
         } else {
-            let iter = || (0..self.val_count).map(|idx| self.vals[idx as usize]);
-            serialize_u128(iter, self.val_count as u64, field_write)?;
+            let iter_gen = || (0..self.val_count).map(|idx| self.vals[idx as usize]);
+            serialize_u128(iter_gen, self.val_count as u64, field_write)?;
         }
 
         Ok(())

src/indexer/merger.rs

@@ -330,18 +330,18 @@ impl IndexMerger {
         fast_field_serializer: &mut CompositeFastFieldSerializer,
         doc_id_mapping: &SegmentDocIdMapping,
     ) -> crate::Result<()> {
-        let segment_and_ff_readers = self
-            .readers
-            .iter()
-            .map(|segment_reader| {
-                let ff_reader: MultiValuedU128FastFieldReader<u128> =
-                    segment_reader.fast_fields().u128s(field).expect(
-                        "Failed to find index for multivalued field. This is a bug in tantivy, \
-                         please report.",
-                    );
-                (segment_reader, ff_reader)
-            })
-            .collect::<Vec<_>>();
+        let segment_and_ff_readers: Vec<(&SegmentReader, MultiValuedU128FastFieldReader<u128>)> =
+            self.readers
+                .iter()
+                .map(|segment_reader| {
+                    let ff_reader: MultiValuedU128FastFieldReader<u128> =
+                        segment_reader.fast_fields().u128s(field).expect(
+                            "Failed to find index for multivalued field. This is a bug in \
+                             tantivy, please report.",
+                        );
+                    (segment_reader, ff_reader)
+                })
+                .collect::<Vec<_>>();
 
         Self::write_1_n_fast_field_idx_generic(
             field,
@@ -355,7 +355,7 @@ impl IndexMerger {
             .map(|(_, ff_reader)| ff_reader)
             .collect::<Vec<_>>();
 
-        let iter = || {
+        let iter_gen = || {
             doc_id_mapping.iter_old_doc_addrs().flat_map(|doc_addr| {
                 let fast_field_reader = &fast_field_readers[doc_addr.segment_ord as usize];
                 let mut out = vec![];
@@ -364,7 +364,7 @@ impl IndexMerger {
             })
         };
         let field_write = fast_field_serializer.get_field_writer(field, 1);
-        serialize_u128(iter, doc_id_mapping.len() as u64, field_write)?;
+        serialize_u128(iter_gen, doc_id_mapping.len() as u64, field_write)?;
 
         Ok(())
     }
@@ -389,13 +389,13 @@ impl IndexMerger {
             .collect::<Vec<_>>();
 
         let field_write = fast_field_serializer.get_field_writer(field, 0);
-        let iter = || {
+        let iter_gen = || {
             doc_id_mapping.iter_old_doc_addrs().map(|doc_addr| {
                 let fast_field_reader = &fast_field_readers[doc_addr.segment_ord as usize];
                 fast_field_reader.get_val(doc_addr.doc_id as u64)
             })
         };
-        fastfield_codecs::serialize_u128(iter, doc_id_mapping.len() as u64, field_write)?;
+        fastfield_codecs::serialize_u128(iter_gen, doc_id_mapping.len() as u64, field_write)?;
         Ok(())
     }
 

src/schema/document.rs

@@ -76,9 +76,7 @@ impl Document {
 
     /// Adding a facet to the document.
     pub fn add_facet<F>(&mut self, field: Field, path: F)
-    where
-        Facet: From<F>,
-    {
+    where Facet: From<F> {
         let facet = Facet::from(path);
         let value = Value::Facet(facet);
         self.add_field_value(field, value);