Try zip over zip_eq

Signed-off-by: Adam Gutglick <[email protected]>

Author: AdamGS

encodings/alp/src/alp/compress.rs

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use itertools::Itertools;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::arrays::PrimitiveArray;
@@ -88,7 +87,7 @@ where
             Mask::Values(is_valid) => {
                 let (pos, vals): (BufferMut<u64>, BufferMut<T>) = exceptional_positions
                     .into_iter()
-                    .zip_eq(exceptional_values)
+                    .zip(exceptional_values)
                     .filter(|(index, _)| {
                         let is_valid = is_valid.value(*index as usize);
                         if !is_valid {

encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs

@@ -2,7 +2,6 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use fastlanes::BitPacking;
-use itertools::Itertools;
 use num_traits::PrimInt;
 use vortex_array::IntoArray;
 use vortex_array::arrays::PrimitiveArray;
@@ -313,7 +312,7 @@ fn bit_width_histogram_typed<T: NativePType + PrimInt>(
         }
         AllOr::Some(buffer) => {
             // Some values are valid
-            for (is_valid, v) in buffer.iter().zip_eq(array.as_slice::<T>()) {
+            for (is_valid, v) in buffer.iter().zip(array.as_slice::<T>()) {
                 if is_valid {
                     bit_widths[bit_width(*v)] += 1;
                 } else {

encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs

@@ -2,7 +2,6 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use fastlanes::BitPacking;
-use itertools::Itertools;
 use vortex_array::ToCanonical;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::builders::ArrayBuilder;
@@ -151,7 +150,7 @@ fn insert_values_and_validity_at_indices_to_uninit_range<
         vortex_panic!("BitPackedArray somehow had nullable patch values");
     };
 
-    for (index, &value) in indices.iter().zip_eq(values) {
+    for (index, &value) in indices.iter().zip(values) {
         dst.set_value(index.as_() - indices_offset, f(value));
     }
 }

encodings/fastlanes/src/bitpacking/compute/is_constant.rs

@@ -3,7 +3,6 @@
 
 use std::ops::Range;
 
-use itertools::Itertools;
 use lending_iterator::LendingIterator;
 use vortex_array::ToCanonical;
 use vortex_array::arrays::IS_CONST_LANE_WIDTH;
@@ -159,7 +158,7 @@ fn apply_patches_idx_typed<T: BitPacked, I: IntegerPType>(
     for (i, &v) in patch_indices
         .iter()
         .map(|i| i.as_() - indices_offset)
-        .zip_eq(patch_values)
+        .zip(patch_values)
         .skip_while(|(i, _)| i < &values_range.start)
         .take_while(|(i, _)| i < &values_range.end)
     {

encodings/runend/src/compress.rs

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use itertools::Itertools;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
@@ -203,7 +202,7 @@ pub fn runend_decode_typed_primitive<T: NativePType>(
     match values_validity {
         Mask::AllTrue(_) => {
             let mut decoded: BufferMut<T> = BufferMut::with_capacity(length);
-            for (end, value) in run_ends.zip_eq(values) {
+            for (end, value) in run_ends.zip(values) {
                 assert!(end <= length, "Runend end must be less than overall length");
                 // SAFETY:
                 // We preallocate enough capacity because we know the total length
@@ -215,7 +214,7 @@ pub fn runend_decode_typed_primitive<T: NativePType>(
         Mask::Values(mask) => {
             let mut decoded = BufferMut::with_capacity(length);
             let mut decoded_validity = BitBufferMut::with_capacity(length);
-            for (end, value) in run_ends.zip_eq(
+            for (end, value) in run_ends.zip(
                 values
                     .iter()
                     .zip(mask.bit_buffer().iter())
@@ -252,7 +251,7 @@ pub fn runend_decode_typed_bool(
     match values_validity {
         Mask::AllTrue(_) => {
             let mut decoded = BitBufferMut::with_capacity(length);
-            for (end, value) in run_ends.zip_eq(values.iter()) {
+            for (end, value) in run_ends.zip(values.iter()) {
                 decoded.append_n(value, end - decoded.len());
             }
             BoolArray::from_bit_buffer(decoded.freeze(), values_nullability.into())
@@ -263,7 +262,7 @@ pub fn runend_decode_typed_bool(
         Mask::Values(mask) => {
             let mut decoded = BitBufferMut::with_capacity(length);
             let mut decoded_validity = BitBufferMut::with_capacity(length);
-            for (end, value) in run_ends.zip_eq(
+            for (end, value) in run_ends.zip(
                 values
                     .iter()
                     .zip(mask.bit_buffer().iter())

encodings/sparse/src/canonical.rs

@@ -3,7 +3,6 @@
 
 use std::sync::Arc;
 
-use itertools::Itertools;
 use num_traits::NumCast;
 use vortex_array::Array;
 use vortex_array::Canonical;
@@ -410,21 +409,19 @@ fn canonicalize_sparse_struct(
     };
 
     StructArray::try_from_iter_with_validity(
-        names.iter().zip_eq(
-            columns_patch_values
-                .iter()
-                .cloned()
-                .zip_eq(fill_values)
-                .map(|(patch_values, fill_value)| unsafe {
+        names
+            .iter()
+            .zip(columns_patch_values.iter().cloned().zip(fill_values).map(
+                |(patch_values, fill_value)| unsafe {
                     SparseArray::new_unchecked(
                         unresolved_patches
                             .clone()
                             .map_values(|_| Ok(patch_values))
                             .vortex_expect("Replacing patch values"),
                         fill_value,
                     )
-                }),
-        ),
+                },
+            )),
         validity,
     )
     .map(Canonical::Struct)
@@ -500,7 +497,7 @@ fn canonicalize_varbin_inner<I: IntegerPType>(
     };
 
     let mut views = buffer_mut![fill; len];
-    for (patch_index, &patch) in indices.into_iter().zip_eq(values.views().iter()) {
+    for (patch_index, &patch) in indices.into_iter().zip(values.views().iter()) {
         let patch_index_usize = <usize as NumCast>::from(patch_index)
             .vortex_expect("var bin view indices must fit in usize");
         views[patch_index_usize] = patch;

encodings/sparse/src/lib.rs

@@ -438,7 +438,7 @@ fn patch_validity<I: NativePType + AsPrimitive<usize>>(
         }
         Mask::Values(mask_values) => {
             let is_valid = mask_values.bit_buffer().iter();
-            for (index, is_valid) in indices.zip_eq(is_valid) {
+            for (index, is_valid) in indices.zip(is_valid) {
                 is_valid_buffer.set_to(index, is_valid);
             }
         }

encodings/zstd/src/array.rs

@@ -621,7 +621,7 @@ impl ZstdArray {
                         );
 
                         let mut views = BufferMut::<BinaryView>::zeroed(slice_n_rows);
-                        for (view, index) in valid_views.into_iter().zip_eq(valid_indices) {
+                        for (view, index) in valid_views.into_iter().zip(valid_indices) {
                             views[*index] = view
                         }
 

vortex-array/src/arrays/bool/patch.rs

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use itertools::Itertools;
 use vortex_dtype::match_each_unsigned_integer_ptype;
 
 use crate::ToCanonical;
@@ -26,7 +25,7 @@ impl BoolArray {
             for (idx, value) in indices
                 .as_slice::<I>()
                 .iter()
-                .zip_eq(values.bit_buffer().iter())
+                .zip(values.bit_buffer().iter())
             {
                 #[allow(clippy::cast_possible_truncation)]
                 own_values.set_to(*idx as usize - offset, value);

vortex-array/src/arrays/chunked/compute/mask.rs

@@ -105,7 +105,7 @@ fn mask_slices(
     array
         .chunks()
         .iter()
-        .zip_eq(chunked_filters)
+        .zip(chunked_filters)
         .map(|(chunk, chunk_filter)| -> VortexResult<ArrayRef> {
             match chunk_filter {
                 ChunkFilter::All => {