replace match statements

Signed-off-by: Connor Tsui <[email protected]>

Author: connortsui20

vortex-vector/src/macros.rs

@@ -230,19 +230,10 @@ macro_rules! __match_vector_pair_arms {
 /// let new_bool_mut = extend_vector_owned(mut_vec, vec);
 /// assert_eq!(new_bool_mut.len(), 5);
 /// ```
-#[rustfmt::skip]
-#[macro_export]
+#[macro_export] // DO NOT ADD `#[rustfmt::skip]`!!! https://github.com/rust-lang/rust/pull/52234#issuecomment-903419099
 macro_rules! match_vector_pair {
-    ($left:expr, $right:expr, | $a:ident: Vector, $b:ident: Vector | $body:expr) => {{
-        $crate::__match_vector_pair_arms!($left, $right, Vector, Vector, $a, $b, $body)
-    }};
-    ($left:expr, $right:expr, | $a:ident: Vector, $b:ident: VectorMut | $body:expr) => {{
-        $crate::__match_vector_pair_arms!($left, $right, Vector, VectorMut, $a, $b, $body)
-    }};
-    ($left:expr, $right:expr, | $a:ident: VectorMut, $b:ident: Vector | $body:expr) => {{
-        $crate::__match_vector_pair_arms!($left, $right, VectorMut, Vector, $a, $b, $body)
-    }};
-    ($left:expr, $right:expr, | $a:ident: VectorMut, $b:ident: VectorMut | $body:expr) => {{
-        $crate::__match_vector_pair_arms!($left, $right, VectorMut, VectorMut, $a, $b, $body)
-    }};
+    ($left:expr, $right:expr, | $a:ident : Vector, $b:ident : Vector | $body:expr) => {{ $crate::__match_vector_pair_arms!($left, $right, Vector, Vector, $a, $b, $body) }};
+    ($left:expr, $right:expr, | $a:ident : Vector, $b:ident : VectorMut | $body:expr) => {{ $crate::__match_vector_pair_arms!($left, $right, Vector, VectorMut, $a, $b, $body) }};
+    ($left:expr, $right:expr, | $a:ident : VectorMut, $b:ident : Vector | $body:expr) => {{ $crate::__match_vector_pair_arms!($left, $right, VectorMut, Vector, $a, $b, $body) }};
+    ($left:expr, $right:expr, | $a:ident : VectorMut, $b:ident : VectorMut | $body:expr) => {{ $crate::__match_vector_pair_arms!($left, $right, VectorMut, VectorMut, $a, $b, $body) }};
 }

vortex-vector/src/struct_/vector_mut.rs

@@ -5,10 +5,10 @@
 
 use std::sync::Arc;
 
-use vortex_error::{VortexExpect, VortexResult, vortex_ensure, vortex_panic};
+use vortex_error::{VortexExpect, VortexResult, vortex_ensure};
 use vortex_mask::MaskMut;
 
-use crate::{StructVector, Vector, VectorMut, VectorMutOps, VectorOps};
+use crate::{StructVector, Vector, VectorMut, VectorMutOps, VectorOps, match_vector_pair};
 
 /// A mutable vector of struct values (values with named fields).
 ///
@@ -239,17 +239,9 @@ impl VectorMutOps for StructVectorMut {
         // Extend each field vector.
         let pairs = self.fields.iter_mut().zip(other.fields().as_ref());
         for (self_mut_vector, other_vec) in pairs {
-            match (self_mut_vector, other_vec) {
-                (VectorMut::Null(a), Vector::Null(b)) => a.extend_from_vector(b),
-                (VectorMut::Bool(a), Vector::Bool(b)) => a.extend_from_vector(b),
-                (VectorMut::Primitive(a), Vector::Primitive(b)) => a.extend_from_vector(b),
-                (VectorMut::String(a), Vector::String(b)) => a.extend_from_vector(b),
-                (VectorMut::Binary(a), Vector::Binary(b)) => a.extend_from_vector(b),
-                (VectorMut::Struct(a), Vector::Struct(b)) => a.extend_from_vector(b),
-                _ => {
-                    vortex_panic!("Mismatched field types in `StructVectorMut::extend_from_vector`")
-                }
-            }
+            match_vector_pair!(self_mut_vector, other_vec, |a: VectorMut, b: Vector| {
+                a.extend_from_vector(b)
+            })
         }
 
         // Extend the validity mask.
@@ -322,17 +314,11 @@ impl VectorMutOps for StructVectorMut {
         // Unsplit each field vector.
         let pairs = self.fields.iter_mut().zip(other.fields);
         for (self_mut_vector, other_mut_vec) in pairs {
-            match (self_mut_vector, other_mut_vec) {
-                (VectorMut::Null(a), VectorMut::Null(b)) => a.unsplit(b),
-                (VectorMut::Bool(a), VectorMut::Bool(b)) => a.unsplit(b),
-                (VectorMut::Primitive(a), VectorMut::Primitive(b)) => a.unsplit(b),
-                (VectorMut::String(a), VectorMut::String(b)) => a.unsplit(b),
-                (VectorMut::Binary(a), VectorMut::Binary(b)) => a.unsplit(b),
-                (VectorMut::Struct(a), VectorMut::Struct(b)) => a.unsplit(b),
-                _ => {
-                    vortex_panic!("Mismatched field types in `StructVectorMut::unsplit`")
-                }
-            }
+            match_vector_pair!(
+                self_mut_vector,
+                other_mut_vec,
+                |a: VectorMut, b: VectorMut| a.unsplit(b)
+            )
         }
 
         self.validity.unsplit(other.validity);

vortex-vector/src/vector_mut.rs

@@ -13,7 +13,7 @@ use vortex_mask::MaskMut;
 use crate::varbin::{BinaryVectorMut, StringVectorMut};
 use crate::{
     BoolVectorMut, NullVectorMut, PrimitiveVectorMut, StructVectorMut, Vector, VectorMutOps,
-    match_each_vector_mut,
+    match_each_vector_mut, match_vector_pair,
 };
 
 /// An enum over all kinds of mutable vectors, which represent fully decompressed (canonical) array
@@ -94,15 +94,9 @@ impl VectorMutOps for VectorMut {
     }
 
     fn extend_from_vector(&mut self, other: &Self::Immutable) {
-        match (self, other) {
-            (VectorMut::Null(a), Vector::Null(b)) => a.extend_from_vector(b),
-            (VectorMut::Bool(a), Vector::Bool(b)) => a.extend_from_vector(b),
-            (VectorMut::Primitive(a), Vector::Primitive(b)) => a.extend_from_vector(b),
-            (VectorMut::String(a), Vector::String(b)) => a.extend_from_vector(b),
-            (VectorMut::Binary(a), Vector::Binary(b)) => a.extend_from_vector(b),
-            (VectorMut::Struct(a), Vector::Struct(b)) => a.extend_from_vector(b),
-            _ => vortex_panic!("Mismatched vector types"),
-        }
+        match_vector_pair!(self, other, |a: VectorMut, b: Vector| {
+            a.extend_from_vector(b)
+        })
     }
 
     fn append_nulls(&mut self, n: usize) {
@@ -118,15 +112,7 @@ impl VectorMutOps for VectorMut {
     }
 
     fn unsplit(&mut self, other: Self) {
-        match (self, other) {
-            (VectorMut::Null(a), VectorMut::Null(b)) => a.unsplit(b),
-            (VectorMut::Bool(a), VectorMut::Bool(b)) => a.unsplit(b),
-            (VectorMut::Primitive(a), VectorMut::Primitive(b)) => a.unsplit(b),
-            (VectorMut::String(a), VectorMut::String(b)) => a.unsplit(b),
-            (VectorMut::Binary(a), VectorMut::Binary(b)) => a.unsplit(b),
-            (VectorMut::Struct(a), VectorMut::Struct(b)) => a.unsplit(b),
-            _ => vortex_panic!("Mismatched vector types"),
-        }
+        match_vector_pair!(self, other, |a: VectorMut, b: VectorMut| a.unsplit(b))
     }
 }