Chore: Replace filter(array) with array.filter() in most places

encodings/alp/src/alp/compute/filter.rs

@@ -4,7 +4,6 @@
 use vortex_array::ArrayRef;
 use vortex_array::compute::FilterKernel;
 use vortex_array::compute::FilterKernelAdapter;
-use vortex_array::compute::filter;
 use vortex_array::register_kernel;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
@@ -23,7 +22,7 @@ impl FilterKernel for ALPVTable {
         // SAFETY: filtering the values does not change correctness
         unsafe {
             Ok(ALPArray::new_unchecked(
-                filter(array.encoded(), mask)?,
+                array.encoded().filter(mask.clone())?,
                 array.exponents(),
                 patches,
                 array.dtype().clone(),

encodings/alp/src/alp_rd/compute/filter.rs

@@ -5,7 +5,6 @@ use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::compute::FilterKernel;
 use vortex_array::compute::FilterKernelAdapter;
-use vortex_array::compute::filter;
 use vortex_array::register_kernel;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
@@ -23,9 +22,9 @@ impl FilterKernel for ALPRDVTable {
 
         Ok(ALPRDArray::try_new(
             array.dtype().clone(),
-            filter(array.left_parts(), mask)?,
+            array.left_parts().filter(mask.clone())?,
             array.left_parts_dictionary().clone(),
-            filter(array.right_parts(), mask)?,
+            array.right_parts().filter(mask.clone())?,
             array.right_bit_width(),
             left_parts_exceptions,
         )?
@@ -42,7 +41,6 @@ mod test {
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::conformance::filter::test_filter_conformance;
-    use vortex_array::compute::filter;
     use vortex_array::validity::Validity;
     use vortex_buffer::buffer;
     use vortex_mask::Mask;
@@ -61,7 +59,9 @@ mod test {
         assert!(encoded.left_parts_patches().is_some());
 
         // The first two values need no patching
-        let filtered = filter(encoded.as_ref(), &Mask::from_iter([true, false, true])).unwrap();
+        let filtered = encoded
+            .filter(Mask::from_iter([true, false, true]))
+            .unwrap();
         assert_arrays_eq!(filtered, PrimitiveArray::from_iter([a, outlier]));
     }
 

encodings/datetime-parts/src/compute/filter.rs

@@ -5,7 +5,6 @@ use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::compute::FilterKernel;
 use vortex_array::compute::FilterKernelAdapter;
-use vortex_array::compute::filter;
 use vortex_array::register_kernel;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
@@ -17,9 +16,9 @@ impl FilterKernel for DateTimePartsVTable {
     fn filter(&self, array: &DateTimePartsArray, mask: &Mask) -> VortexResult<ArrayRef> {
         Ok(DateTimePartsArray::try_new(
             array.dtype().clone(),
-            filter(array.days().as_ref(), mask)?,
-            filter(array.seconds().as_ref(), mask)?,
-            filter(array.subseconds().as_ref(), mask)?,
+            array.days().filter(mask.clone())?,
+            array.seconds().filter(mask.clone())?,
+            array.subseconds().filter(mask.clone())?,
         )?
         .into_array())
     }

encodings/decimal-byte-parts/src/decimal_byte_parts/compute/filter.rs

@@ -4,7 +4,6 @@
 use vortex_array::ArrayRef;
 use vortex_array::compute::FilterKernel;
 use vortex_array::compute::FilterKernelAdapter;
-use vortex_array::compute::filter;
 use vortex_array::register_kernel;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
@@ -14,7 +13,7 @@ use crate::DecimalBytePartsVTable;
 
 impl FilterKernel for DecimalBytePartsVTable {
     fn filter(&self, array: &Self::Array, mask: &Mask) -> VortexResult<ArrayRef> {
-        DecimalBytePartsArray::try_new(filter(&array.msp, mask)?, *array.decimal_dtype())
+        DecimalBytePartsArray::try_new(array.msp.filter(mask.clone())?, *array.decimal_dtype())
             .map(|d| d.to_array())
     }
 }

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

@@ -11,7 +11,6 @@ use vortex_array::ToCanonical;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::compute::FilterKernel;
 use vortex_array::compute::FilterKernelAdapter;
-use vortex_array::compute::filter;
 use vortex_array::register_kernel;
 use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::Buffer;
@@ -71,7 +70,7 @@ fn filter_primitive<T: NativePType + BitPacking>(
     };
     if mask.density() >= full_decompression_threshold {
         let decompressed_array = array.to_primitive();
-        Ok(filter(decompressed_array.as_ref(), mask)?.to_primitive())
+        Ok(decompressed_array.filter(mask.clone())?.to_primitive())
     } else {
         filter_primitive_no_decompression::<T>(array, mask)
     }
@@ -170,7 +169,6 @@ mod test {
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::conformance::filter::test_filter_conformance;
-    use vortex_array::compute::filter;
     use vortex_array::validity::Validity;
     use vortex_buffer::Buffer;
     use vortex_buffer::buffer;
@@ -186,7 +184,7 @@ mod test {
 
         let mask = Mask::from_indices(bitpacked.len(), vec![0, 125, 2047, 2049, 2151, 2790]);
 
-        let primitive_result = filter(bitpacked.as_ref(), &mask).unwrap();
+        let primitive_result = bitpacked.filter(mask).unwrap();
         assert_arrays_eq!(
             primitive_result,
             PrimitiveArray::from_iter([0u8, 62, 31, 33, 9, 18])
@@ -202,19 +200,17 @@ mod test {
 
         let mask = Mask::from_indices(sliced.len(), vec![1919, 1921]);
 
-        let primitive_result = filter(&sliced, &mask).unwrap();
+        let primitive_result = sliced.filter(mask).unwrap();
         assert_arrays_eq!(primitive_result, PrimitiveArray::from_iter([31u8, 33]));
     }
 
     #[test]
     fn filter_bitpacked() {
         let unpacked = PrimitiveArray::from_iter((0..4096).map(|i| (i % 63) as u8));
         let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 6).unwrap();
-        let filtered = filter(
-            bitpacked.as_ref(),
-            &Mask::from_indices(4096, (0..1024).collect()),
-        )
-        .unwrap();
+        let filtered = bitpacked
+            .filter(Mask::from_indices(4096, (0..1024).collect()))
+            .unwrap();
         assert_arrays_eq!(
             filtered.to_primitive(),
             PrimitiveArray::from_iter((0..1024).map(|i| (i % 63) as u8))
@@ -226,12 +222,10 @@ mod test {
         let values: Buffer<i64> = (0..500).collect();
         let unpacked = PrimitiveArray::new(values.clone(), Validity::NonNullable);
         let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 9).unwrap();
-        let filtered = filter(
-            bitpacked.as_ref(),
-            &Mask::from_indices(values.len(), (0..250).collect()),
-        )
-        .unwrap()
-        .to_primitive();
+        let filtered = bitpacked
+            .filter(Mask::from_indices(values.len(), (0..250).collect()))
+            .unwrap()
+            .to_primitive();
 
         assert_arrays_eq!(
             filtered,
@@ -275,12 +269,10 @@ mod test {
         );
 
         // Filter to include some patched and some non-patched values.
-        let filtered = filter(
-            bitpacked.as_ref(),
-            &Mask::from_indices(values.len(), vec![0, 2, 5, 9]),
-        )
-        .unwrap()
-        .to_primitive();
+        let filtered = bitpacked
+            .filter(Mask::from_indices(values.len(), vec![0, 2, 5, 9]))
+            .unwrap()
+            .to_primitive();
 
         assert_arrays_eq!(filtered, PrimitiveArray::from_iter([0i32, 1000, 2000, 70]));
     }
@@ -310,12 +302,10 @@ mod test {
 
         // Use low selectivity (only select 2% of values) to avoid full decompression.
         let indices: Vec<usize> = (0..20).collect();
-        let filtered = filter(
-            bitpacked.as_ref(),
-            &Mask::from_indices(values.len(), indices),
-        )
-        .unwrap()
-        .to_primitive();
+        let filtered = bitpacked
+            .filter(Mask::from_indices(values.len(), indices))
+            .unwrap()
+            .to_primitive();
 
         let expected: Vec<i32> = values[0..20].to_vec();
         assert_arrays_eq!(filtered, PrimitiveArray::from_iter(expected));

encodings/fastlanes/src/for/compute/mod.rs

@@ -13,7 +13,6 @@ use vortex_array::compute::FilterKernel;
 use vortex_array::compute::FilterKernelAdapter;
 use vortex_array::compute::TakeKernel;
 use vortex_array::compute::TakeKernelAdapter;
-use vortex_array::compute::filter;
 use vortex_array::compute::take;
 use vortex_array::register_kernel;
 use vortex_error::VortexResult;
@@ -37,7 +36,7 @@ register_kernel!(TakeKernelAdapter(FoRVTable).lift());
 impl FilterKernel for FoRVTable {
     fn filter(&self, array: &FoRArray, mask: &Mask) -> VortexResult<ArrayRef> {
         FoRArray::try_new(
-            filter(array.encoded(), mask)?,
+            array.encoded().filter(mask.clone())?,
             array.reference_scalar().clone(),
         )
         .map(|a| a.into_array())

encodings/fsst/src/compute/filter.rs

@@ -6,7 +6,6 @@ use vortex_array::IntoArray;
 use vortex_array::arrays::VarBinVTable;
 use vortex_array::compute::FilterKernel;
 use vortex_array::compute::FilterKernelAdapter;
-use vortex_array::compute::filter;
 use vortex_array::register_kernel;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
@@ -21,10 +20,12 @@ impl FilterKernel for FSSTVTable {
             array.dtype().clone(),
             array.symbols().clone(),
             array.symbol_lengths().clone(),
-            filter(array.codes().as_ref(), mask)?
+            array
+                .codes()
+                .filter(mask.clone())?
                 .as_::<VarBinVTable>()
                 .clone(),
-            filter(array.uncompressed_lengths(), mask)?,
+            array.uncompressed_lengths().filter(mask.clone())?,
         )?
         .into_array())
     }

encodings/fsst/src/kernel.rs

@@ -202,7 +202,6 @@ mod tests {
     use vortex_array::arrays::FilterArray;
     use vortex_array::arrays::builder::VarBinBuilder;
     use vortex_array::assert_arrays_eq;
-    use vortex_array::compute::filter;
     use vortex_array::session::ArraySession;
     use vortex_dtype::DType;
     use vortex_dtype::Nullability;
@@ -251,8 +250,8 @@ mod tests {
         let mut ctx = SESSION.create_execution_ctx();
         let result = filter_array.execute::<Canonical>(&mut ctx)?;
 
-        // Compare with filtering the canonical VarBinView
-        let expected = filter(&fsst_array, &mask)?;
+        // Compare with filtering the canonical VarBinView.
+        let expected = fsst_array.filter(mask)?;
 
         assert_eq!(result.len(), 2);
         assert_arrays_eq!(result.into_array(), expected);
@@ -272,7 +271,7 @@ mod tests {
         let mut ctx = SESSION.create_execution_ctx();
         let result = filter_array.execute::<Canonical>(&mut ctx)?;
 
-        let expected = filter(&fsst_array, &mask)?;
+        let expected = fsst_array.filter(mask)?;
 
         assert_eq!(result.len(), 5);
         assert_arrays_eq!(result.into_array(), expected);
@@ -316,7 +315,7 @@ mod tests {
         let mut ctx = SESSION.create_execution_ctx();
         let result = filter_array.execute::<Canonical>(&mut ctx)?;
 
-        let expected = filter(input.as_ref(), &mask)?;
+        let expected = input.filter(mask)?;
 
         assert_eq!(result.len(), 1);
         assert_arrays_eq!(result.into_array(), expected);
@@ -341,7 +340,7 @@ mod tests {
         let mut ctx = SESSION.create_execution_ctx();
         let result = filter_array.execute::<Canonical>(&mut ctx)?;
 
-        let expected = filter(input.as_ref(), &mask)?;
+        let expected = input.filter(mask)?;
 
         assert_eq!(result.len(), 2);
         assert_arrays_eq!(result.into_array(), expected);

encodings/fsst/src/tests.rs

@@ -8,7 +8,6 @@ use vortex_array::ToCanonical;
 use vortex_array::arrays::builder::VarBinBuilder;
 use vortex_array::assert_arrays_eq;
 use vortex_array::assert_nth_scalar;
-use vortex_array::compute::filter;
 use vortex_array::compute::take;
 use vortex_buffer::buffer;
 use vortex_dtype::DType;
@@ -87,7 +86,7 @@ fn test_fsst_array_ops() {
     // test filter
     let mask = Mask::from_iter([false, true, true]);
 
-    let fsst_filtered = filter(&fsst_array, &mask).unwrap();
+    let fsst_filtered = fsst_array.filter(mask).unwrap();
 
     assert_eq!(fsst_filtered.len(), 2);
     assert_nth_scalar!(

encodings/runend/src/compute/filter.rs

@@ -13,7 +13,6 @@ use vortex_array::ToCanonical;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::compute::FilterKernel;
 use vortex_array::compute::FilterKernelAdapter;
-use vortex_array::compute::filter;
 use vortex_array::register_kernel;
 use vortex_array::validity::Validity;
 use vortex_buffer::BitBuffer;
@@ -54,7 +53,7 @@ impl FilterKernel for RunEndVTable {
                                 mask_values.bit_buffer(),
                             )?
                         });
-                    let values = filter(array.values(), &values_mask)?;
+                    let values = array.values().filter(values_mask)?;
 
                     // SAFETY: guaranteed by implementation of filter_run_end_primitive
                     unsafe {
@@ -88,7 +87,7 @@ pub fn filter_run_end(array: &RunEndArray, mask: &Mask) -> VortexResult<ArrayRef
                     .bit_buffer(),
             )?
         });
-    let values = filter(array.values(), &values_mask)?;
+    let values = array.values().filter(values_mask)?;
 
     // SAFETY: enforced by filter_run_end_primitive
     unsafe {

encodings/sparse/src/compute/mod.rs

@@ -48,7 +48,6 @@ mod test {
     use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array;
     use vortex_array::compute::conformance::filter::test_filter_conformance;
     use vortex_array::compute::conformance::mask::test_mask_conformance;
-    use vortex_array::compute::filter;
     use vortex_array::validity::Validity;
     use vortex_buffer::buffer;
     use vortex_dtype::DType;
@@ -77,7 +76,7 @@ mod test {
         predicate.extend_from_slice(&[false; 17]);
         let mask = Mask::from_iter(predicate);
 
-        let filtered_array = filter(&array, &mask).unwrap();
+        let filtered_array = array.filter(mask).unwrap();
 
         // Construct expected SparseArray: index 2 was kept, which had value 33.
         // The new index is 0 (since it's the only element).
@@ -104,7 +103,7 @@ mod test {
         .unwrap()
         .into_array();
 
-        let filtered_array = filter(&array, &mask).unwrap();
+        let filtered_array = array.filter(mask).unwrap();
 
         // Original indices 0, 3, 6 with values 33, 44, 55.
         // Mask keeps indices 1, 3, 5, 6 -> new indices 0, 1, 2, 3.

encodings/zigzag/src/compute/mod.rs

@@ -12,7 +12,6 @@ use vortex_array::compute::MaskKernel;
 use vortex_array::compute::MaskKernelAdapter;
 use vortex_array::compute::TakeKernel;
 use vortex_array::compute::TakeKernelAdapter;
-use vortex_array::compute::filter;
 use vortex_array::compute::mask;
 use vortex_array::compute::take;
 use vortex_array::register_kernel;
@@ -24,7 +23,7 @@ use crate::ZigZagVTable;
 
 impl FilterKernel for ZigZagVTable {
     fn filter(&self, array: &ZigZagArray, mask: &Mask) -> VortexResult<ArrayRef> {
-        let encoded = filter(array.encoded(), mask)?;
+        let encoded = array.encoded().filter(mask.clone())?;
         Ok(ZigZagArray::try_new(encoded)?.into_array())
     }
 }
@@ -80,7 +79,6 @@ mod tests {
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
-    use vortex_array::compute::filter;
     use vortex_array::compute::take;
     use vortex_array::validity::Validity;
     use vortex_buffer::BitBuffer;
@@ -127,7 +125,7 @@ mod tests {
         ))?;
 
         let filter_mask = BitBuffer::from(vec![true, false, true]).into();
-        let actual = filter(zigzag.as_ref(), &filter_mask).unwrap();
+        let actual = zigzag.filter(filter_mask).unwrap();
         let expected =
             zigzag_encode(PrimitiveArray::new(buffer![-189, 1], Validity::AllValid))?.into_array();
         assert_arrays_eq!(actual, expected);