Rename Array VTables

encodings/alp/src/alp/array.rs

@@ -47,7 +47,7 @@ use crate::alp::rules::RULES;
 
 vtable!(ALP);
 
-impl VTable for ALPVTable {
+impl VTable for ALP {
     type Array = ALPArray;
 
     type Metadata = ProstMetadata<ALPMetadata>;
@@ -270,9 +270,9 @@ pub struct ALPArray {
 }
 
 #[derive(Debug)]
-pub struct ALPVTable;
+pub struct ALP;
 
-impl ALPVTable {
+impl ALP {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.alp");
 }
 
@@ -483,7 +483,7 @@ impl ALPArray {
     }
 }
 
-impl ValidityChild<ALPVTable> for ALPVTable {
+impl ValidityChild<ALP> for ALP {
     fn validity_child(array: &ALPArray) -> &ArrayRef {
         array.encoded()
     }

encodings/alp/src/alp/compute/between.rs

@@ -16,12 +16,12 @@ use vortex_array::scalar_fn::fns::between::BetweenReduce;
 use vortex_array::scalar_fn::fns::between::StrictComparison;
 use vortex_error::VortexResult;
 
+use crate::ALP;
 use crate::ALPArray;
 use crate::ALPFloat;
-use crate::ALPVTable;
 use crate::match_each_alp_float_ptype;
 
-impl BetweenReduce for ALPVTable {
+impl BetweenReduce for ALP {
     fn between(
         array: &ALPArray,
         lower: &ArrayRef,

encodings/alp/src/alp/compute/cast.rs

@@ -9,10 +9,10 @@ use vortex_array::patches::Patches;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 
+use crate::alp::ALP;
 use crate::alp::ALPArray;
-use crate::alp::ALPVTable;
 
-impl CastReduce for ALPVTable {
+impl CastReduce for ALP {
     fn cast(array: &ALPArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // Check if this is just a nullability change
         if array.dtype().eq_ignore_nullability(dtype) {

encodings/alp/src/alp/compute/compare.rs

@@ -18,14 +18,14 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
 
+use crate::ALP;
 use crate::ALPArray;
 use crate::ALPFloat;
-use crate::ALPVTable;
 use crate::match_each_alp_float_ptype;
 
 // TODO(joe): add fuzzing.
 
-impl CompareKernel for ALPVTable {
+impl CompareKernel for ALP {
     fn compare(
         lhs: &ALPArray,
         rhs: &ArrayRef,

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

@@ -8,10 +8,10 @@ use vortex_array::arrays::filter::FilterKernel;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
+use crate::ALP;
 use crate::ALPArray;
-use crate::ALPVTable;
 
-impl FilterKernel for ALPVTable {
+impl FilterKernel for ALP {
     fn filter(
         array: &ALPArray,
         mask: &Mask,

encodings/alp/src/alp/compute/mask.rs

@@ -10,10 +10,10 @@ use vortex_array::scalar_fn::fns::mask::MaskReduce;
 use vortex_array::validity::Validity;
 use vortex_error::VortexResult;
 
+use crate::ALP;
 use crate::ALPArray;
-use crate::ALPVTable;
 
-impl MaskReduce for ALPVTable {
+impl MaskReduce for ALP {
     fn mask(array: &ALPArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         // Masking sparse patches requires reading indices, fall back to kernel.
         if array.patches().is_some() {
@@ -26,7 +26,7 @@ impl MaskReduce for ALPVTable {
     }
 }
 
-impl MaskKernel for ALPVTable {
+impl MaskKernel for ALP {
     fn mask(
         array: &ALPArray,
         mask: &ArrayRef,

encodings/alp/src/alp/compute/nan_count.rs

@@ -7,10 +7,10 @@ use vortex_array::compute::nan_count;
 use vortex_array::register_kernel;
 use vortex_error::VortexResult;
 
+use crate::ALP;
 use crate::ALPArray;
-use crate::ALPVTable;
 
-impl NaNCountKernel for ALPVTable {
+impl NaNCountKernel for ALP {
     fn nan_count(&self, array: &ALPArray) -> VortexResult<usize> {
         // NANs can only be in patches
         if let Some(patches) = array.patches() {
@@ -21,4 +21,4 @@ impl NaNCountKernel for ALPVTable {
     }
 }
 
-register_kernel!(NaNCountKernelAdapter(ALPVTable).lift());
+register_kernel!(NaNCountKernelAdapter(ALP).lift());

encodings/alp/src/alp/compute/slice.rs

@@ -9,10 +9,10 @@ use vortex_array::IntoArray;
 use vortex_array::arrays::slice::SliceKernel;
 use vortex_error::VortexResult;
 
+use crate::ALP;
 use crate::ALPArray;
-use crate::ALPVTable;
 
-impl SliceKernel for ALPVTable {
+impl SliceKernel for ALP {
     fn slice(
         array: &Self::Array,
         range: Range<usize>,

encodings/alp/src/alp/compute/take.rs

@@ -8,10 +8,10 @@ use vortex_array::IntoArray;
 use vortex_array::arrays::dict::TakeExecute;
 use vortex_error::VortexResult;
 
+use crate::ALP;
 use crate::ALPArray;
-use crate::ALPVTable;
 
-impl TakeExecute for ALPVTable {
+impl TakeExecute for ALP {
     fn take(
         array: &ALPArray,
         indices: &ArrayRef,

encodings/alp/src/alp/ops.rs

@@ -6,12 +6,12 @@ use vortex_array::vtable::OperationsVTable;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
+use crate::ALP;
 use crate::ALPArray;
 use crate::ALPFloat;
-use crate::ALPVTable;
 use crate::match_each_alp_float_ptype;
 
-impl OperationsVTable<ALPVTable> for ALPVTable {
+impl OperationsVTable<ALP> for ALP {
     fn scalar_at(array: &ALPArray, index: usize) -> VortexResult<Scalar> {
         if let Some(patches) = array.patches()
             && let Some(patch) = patches.get_patched(index)?

encodings/alp/src/alp/rules.rs

@@ -12,18 +12,18 @@ use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor;
 
-use crate::ALPVTable;
+use crate::ALP;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<ALPVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(ALPVTable)),
-    ParentKernelSet::lift(&FilterExecuteAdaptor(ALPVTable)),
-    ParentKernelSet::lift(&MaskExecuteAdaptor(ALPVTable)),
-    ParentKernelSet::lift(&SliceExecuteAdaptor(ALPVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(ALPVTable)),
+pub(super) const PARENT_KERNELS: ParentKernelSet<ALP> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CompareExecuteAdaptor(ALP)),
+    ParentKernelSet::lift(&FilterExecuteAdaptor(ALP)),
+    ParentKernelSet::lift(&MaskExecuteAdaptor(ALP)),
+    ParentKernelSet::lift(&SliceExecuteAdaptor(ALP)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(ALP)),
 ]);
 
-pub(super) const RULES: ParentRuleSet<ALPVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&BetweenReduceAdaptor(ALPVTable)),
-    ParentRuleSet::lift(&CastReduceAdaptor(ALPVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(ALPVTable)),
+pub(super) const RULES: ParentRuleSet<ALP> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&BetweenReduceAdaptor(ALP)),
+    ParentRuleSet::lift(&CastReduceAdaptor(ALP)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(ALP)),
 ]);

encodings/alp/src/alp_rd/array.rs

@@ -64,7 +64,7 @@ pub struct ALPRDMetadata {
     patches: Option<PatchesMetadata>,
 }
 
-impl VTable for ALPRDVTable {
+impl VTable for ALPRD {
     type Array = ALPRDArray;
 
     type Metadata = ProstMetadata<ALPRDMetadata>;
@@ -368,9 +368,9 @@ pub struct ALPRDArray {
 }
 
 #[derive(Debug)]
-pub struct ALPRDVTable;
+pub struct ALPRD;
 
-impl ALPRDVTable {
+impl ALPRD {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.alprd");
 }
 
@@ -503,7 +503,7 @@ impl ALPRDArray {
     }
 }
 
-impl ValidityChild<ALPRDVTable> for ALPRDVTable {
+impl ValidityChild<ALPRD> for ALPRD {
     fn validity_child(array: &ALPRDArray) -> &ArrayRef {
         array.left_parts()
     }

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

@@ -8,10 +8,10 @@ use vortex_array::dtype::DType;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 
+use crate::alp_rd::ALPRD;
 use crate::alp_rd::ALPRDArray;
-use crate::alp_rd::ALPRDVTable;
 
-impl CastReduce for ALPRDVTable {
+impl CastReduce for ALPRD {
     fn cast(array: &ALPRDArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // ALPRDArray stores floating-point values, so only cast between float types
         // or if just changing nullability

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

@@ -8,10 +8,10 @@ use vortex_array::arrays::filter::FilterKernel;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
+use crate::ALPRD;
 use crate::ALPRDArray;
-use crate::ALPRDVTable;
 
-impl FilterKernel for ALPRDVTable {
+impl FilterKernel for ALPRD {
     fn filter(
         array: &ALPRDArray,
         mask: &Mask,

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

@@ -9,10 +9,10 @@ use vortex_array::scalar_fn::fns::mask::Mask as MaskExpr;
 use vortex_array::scalar_fn::fns::mask::MaskReduce;
 use vortex_error::VortexResult;
 
+use crate::ALPRD;
 use crate::ALPRDArray;
-use crate::ALPRDVTable;
 
-impl MaskReduce for ALPRDVTable {
+impl MaskReduce for ALPRD {
     fn mask(array: &ALPRDArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         let masked_left_parts = MaskExpr.try_new_array(
             array.left_parts().len(),

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

@@ -10,10 +10,10 @@ use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
+use crate::ALPRD;
 use crate::ALPRDArray;
-use crate::ALPRDVTable;
 
-impl TakeExecute for ALPRDVTable {
+impl TakeExecute for ALPRD {
     fn take(
         array: &ALPRDArray,
         indices: &ArrayRef,

encodings/alp/src/alp_rd/kernel.rs

@@ -6,10 +6,10 @@ use vortex_array::arrays::filter::FilterExecuteAdaptor;
 use vortex_array::arrays::slice::SliceExecuteAdaptor;
 use vortex_array::kernel::ParentKernelSet;
 
-use crate::alp_rd::ALPRDVTable;
+use crate::alp_rd::ALPRD;
 
-pub(crate) static PARENT_KERNELS: ParentKernelSet<ALPRDVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&SliceExecuteAdaptor(ALPRDVTable)),
-    ParentKernelSet::lift(&FilterExecuteAdaptor(ALPRDVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(ALPRDVTable)),
+pub(crate) static PARENT_KERNELS: ParentKernelSet<ALPRD> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&SliceExecuteAdaptor(ALPRD)),
+    ParentKernelSet::lift(&FilterExecuteAdaptor(ALPRD)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(ALPRD)),
 ]);

encodings/alp/src/alp_rd/ops.rs

@@ -7,10 +7,10 @@ use vortex_array::vtable::OperationsVTable;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
+use crate::ALPRD;
 use crate::ALPRDArray;
-use crate::ALPRDVTable;
 
-impl OperationsVTable<ALPRDVTable> for ALPRDVTable {
+impl OperationsVTable<ALPRD> for ALPRD {
     fn scalar_at(array: &ALPRDArray, index: usize) -> VortexResult<Scalar> {
         // The left value can either be a direct value, or an exception.
         // The exceptions array represents exception positions with non-null values.

encodings/alp/src/alp_rd/rules.rs

@@ -5,9 +5,9 @@ use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor;
 
-use crate::alp_rd::ALPRDVTable;
+use crate::alp_rd::ALPRD;
 
-pub(crate) static RULES: ParentRuleSet<ALPRDVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(ALPRDVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(ALPRDVTable)),
+pub(crate) static RULES: ParentRuleSet<ALPRD> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&CastReduceAdaptor(ALPRD)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(ALPRD)),
 ]);

encodings/alp/src/alp_rd/slice.rs

@@ -9,10 +9,10 @@ use vortex_array::IntoArray;
 use vortex_array::arrays::slice::SliceKernel;
 use vortex_error::VortexResult;
 
+use crate::alp_rd::ALPRD;
 use crate::alp_rd::ALPRDArray;
-use crate::alp_rd::ALPRDVTable;
 
-impl SliceKernel for ALPRDVTable {
+impl SliceKernel for ALPRD {
     fn slice(
         array: &Self::Array,
         range: Range<usize>,