Chore: Vectors even more cleanup

vortex-vector/src/bool/from_iter.rs

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! [`FromIterator`] and related implementations for [`BoolVectorMut`].
+
+use vortex_buffer::BitBufferMut;
+use vortex_mask::MaskMut;
+
+use crate::BoolVectorMut;
+
+impl FromIterator<Option<bool>> for BoolVectorMut {
+    /// Creates a new [`BoolVectorMut`] from an iterator of `Option<bool>` values.
+    ///
+    /// `None` values will be marked as invalid in the validity mask.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use vortex_vector::{BoolVectorMut, VectorMutOps};
+    ///
+    /// let mut vec = BoolVectorMut::from_iter([Some(true), None, Some(false)]);
+    /// assert_eq!(vec.len(), 3);
+    /// ```
+    fn from_iter<I>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = Option<bool>>,
+    {
+        let iter = iter.into_iter();
+        let (lower_bound, _) = iter.size_hint();
+
+        let mut bits = Vec::with_capacity(lower_bound);
+        let mut validity = MaskMut::with_capacity(lower_bound);
+
+        for opt_val in iter {
+            match opt_val {
+                Some(val) => {
+                    bits.push(val);
+                    validity.append_n(true, 1);
+                }
+                None => {
+                    bits.push(false); // Value doesn't matter for invalid entries.
+                    validity.append_n(false, 1);
+                }
+            }
+        }
+
+        BoolVectorMut {
+            bits: BitBufferMut::from_iter(bits),
+            validity,
+        }
+    }
+}
+
+impl FromIterator<bool> for BoolVectorMut {
+    /// Creates a new [`BoolVectorMut`] from an iterator of `bool` values.
+    ///
+    /// All values will be treated as non-null.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use vortex_vector::{BoolVectorMut, VectorMutOps};
+    ///
+    /// let mut vec = BoolVectorMut::from_iter([true, false, false, true]);
+    /// assert_eq!(vec.len(), 4);
+    /// ```
+    fn from_iter<I>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = bool>,
+    {
+        let buffer = BitBufferMut::from_iter(iter);
+        let validity = MaskMut::new_true(buffer.len());
+
+        BoolVectorMut {
+            bits: buffer,
+            validity,
+        }
+    }
+}

vortex-vector/src/bool/mod.rs

@@ -9,6 +9,8 @@ pub use vector::BoolVector;
 mod vector_mut;
 pub use vector_mut::BoolVectorMut;
 
+mod from_iter;
+
 use crate::{Vector, VectorMut};
 
 impl From<BoolVector> for Vector {

vortex-vector/src/bool/vector.rs

@@ -6,8 +6,7 @@
 use vortex_buffer::BitBuffer;
 use vortex_mask::Mask;
 
-use super::BoolVectorMut;
-use crate::VectorOps;
+use crate::{BoolVectorMut, VectorOps};
 
 /// An immutable vector of boolean values.
 ///

vortex-vector/src/bool/vector_mut.rs

@@ -6,8 +6,7 @@
 use vortex_buffer::BitBufferMut;
 use vortex_mask::MaskMut;
 
-use super::BoolVector;
-use crate::{VectorMutOps, VectorOps};
+use crate::{BoolVector, VectorMutOps, VectorOps};
 
 /// A mutable vector of boolean values.
 ///
@@ -80,76 +79,6 @@ impl BoolVectorMut {
     }
 }
 
-impl FromIterator<Option<bool>> for BoolVectorMut {
-    /// Creates a new [`BoolVectorMut`] from an iterator of `Option<bool>` values.
-    ///
-    /// `None` values will be marked as invalid in the validity mask.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use vortex_vector::{BoolVectorMut, VectorMutOps};
-    ///
-    /// let mut vec = BoolVectorMut::from_iter([Some(true), None, Some(false)]);
-    /// assert_eq!(vec.len(), 3);
-    /// ```
-    fn from_iter<I>(iter: I) -> Self
-    where
-        I: IntoIterator<Item = Option<bool>>,
-    {
-        let iter = iter.into_iter();
-        let (lower_bound, _) = iter.size_hint();
-
-        let mut bits = Vec::with_capacity(lower_bound);
-        let mut validity = MaskMut::with_capacity(lower_bound);
-
-        for opt_val in iter {
-            match opt_val {
-                Some(val) => {
-                    bits.push(val);
-                    validity.append_n(true, 1);
-                }
-                None => {
-                    bits.push(false); // Value doesn't matter for invalid entries.
-                    validity.append_n(false, 1);
-                }
-            }
-        }
-
-        BoolVectorMut {
-            bits: BitBufferMut::from_iter(bits),
-            validity,
-        }
-    }
-}
-
-impl FromIterator<bool> for BoolVectorMut {
-    /// Creates a new [`BoolVectorMut`] from an iterator of `bool` values.
-    ///
-    /// All values will be treated as non-null.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use vortex_vector::{BoolVectorMut, VectorMutOps};
-    ///
-    /// let mut vec = BoolVectorMut::from_iter([true, false, false, true]);
-    /// assert_eq!(vec.len(), 4);
-    /// ```
-    fn from_iter<I>(iter: I) -> Self
-    where
-        I: IntoIterator<Item = bool>,
-    {
-        let buffer = BitBufferMut::from_iter(iter);
-        let validity = MaskMut::new_true(buffer.len());
-
-        BoolVectorMut {
-            bits: buffer,
-            validity,
-        }
-    }
-}
-
 impl VectorMutOps for BoolVectorMut {
     type Immutable = BoolVector;
 

vortex-vector/src/macros.rs

@@ -3,8 +3,6 @@
 
 //! Helper macros for working with the different variants of [`Vector`](crate::Vector) and
 //! [`VectorMut`](crate::VectorMut).
-//!
-//! All macros are exported at the crate level with `#[macro_export]`.
 
 /// Matches on all variants of [`Vector`] and executes the same code for each variant branch.
 ///
@@ -13,8 +11,8 @@
 ///
 /// # Examples
 ///
-/// ```
-/// use vortex_vector::{Vector, BoolVectorMut, NullVector, VectorOps, VectorMutOps, match_each_vector};
+/// ```ignore
+/// use vortex_vector::{Vector, BoolVectorMut, NullVector, VectorOps, VectorMutOps};
 ///
 /// fn get_vector_length(vector: &Vector) -> usize {
 ///     match_each_vector!(vector, |v| { v.len() })
@@ -35,7 +33,6 @@
 ///
 /// [`Vector`]: crate::Vector
 /// [`VectorOps`]: crate::VectorOps
-#[macro_export]
 macro_rules! match_each_vector {
     ($self:expr, | $vec:ident | $body:block) => {{
         match $self {
@@ -55,15 +52,17 @@ macro_rules! match_each_vector {
     }};
 }
 
+pub(crate) use match_each_vector;
+
 /// Matches on all variants of [`VectorMut`] and executes the same code for each variant branch.
 ///
 /// This macro eliminates repetitive match statements when implementing operations that need to work
 /// uniformly across all mutable vector type variants.
 ///
 /// # Examples
 ///
-/// ```
-/// use vortex_vector::{VectorMut, BoolVectorMut, NullVectorMut, VectorMutOps, match_each_vector_mut};
+/// ```ignore
+/// use vortex_vector::{VectorMut, BoolVectorMut, NullVectorMut, VectorMutOps};
 ///
 /// fn reserve_space(vector: &mut VectorMut, additional: usize) {
 ///     match_each_vector_mut!(vector, |v| { v.reserve(additional) })
@@ -84,7 +83,6 @@ macro_rules! match_each_vector {
 ///
 /// [`VectorMut`]: crate::VectorMut
 /// [`VectorMutOps`]: crate::VectorMutOps
-#[macro_export]
 macro_rules! match_each_vector_mut {
     ($self:expr, | $vec:ident | $body:block) => {{
         match $self {
@@ -103,3 +101,5 @@ macro_rules! match_each_vector_mut {
         }
     }};
 }
+
+pub(crate) use match_each_vector_mut;

vortex-vector/src/null/vector_mut.rs

@@ -3,8 +3,7 @@
 
 //! Definition and implementation of [`NullVectorMut`].
 
-use super::NullVector;
-use crate::VectorMutOps;
+use crate::{NullVector, VectorMutOps};
 
 /// A mutable vector of null values.
 ///

vortex-vector/src/primitive/from_iter.rs

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! [`FromIterator`] and related implementations for [`PVectorMut<T>`].
+
+use vortex_buffer::BufferMut;
+use vortex_dtype::NativePType;
+use vortex_mask::MaskMut;
+
+use crate::PVectorMut;
+
+impl<T: NativePType> FromIterator<Option<T>> for PVectorMut<T> {
+    /// Creates a new [`PVectorMut<T>`] from an iterator of `Option<T>` values.
+    ///
+    /// `None` values will be marked as invalid in the validity mask.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use vortex_vector::{PVectorMut, VectorMutOps};
+    ///
+    /// let mut vec = PVectorMut::<i32>::from_iter([Some(1), None, Some(3)]);
+    /// assert_eq!(vec.len(), 3);
+    /// ```
+    fn from_iter<I>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = Option<T>>,
+    {
+        let iter = iter.into_iter();
+        let (lower_bound, _) = iter.size_hint();
+
+        let mut elements = Vec::with_capacity(lower_bound);
+        let mut validity = MaskMut::with_capacity(lower_bound);
+
+        for opt_val in iter {
+            match opt_val {
+                Some(val) => {
+                    elements.push(val);
+                    validity.append_n(true, 1);
+                }
+                None => {
+                    elements.push(T::default()); // Use default for invalid entries.
+                    validity.append_n(false, 1);
+                }
+            }
+        }
+
+        PVectorMut {
+            elements: BufferMut::from_iter(elements),
+            validity,
+        }
+    }
+}
+
+impl<T: NativePType> FromIterator<T> for PVectorMut<T> {
+    /// Creates a new [`PVectorMut<T>`] from an iterator of `T` values.
+    ///
+    /// All values will be treated as non-null.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use vortex_vector::{PVectorMut, VectorMutOps};
+    ///
+    /// let mut vec = PVectorMut::<i32>::from_iter([1, 2, 3, 4]);
+    /// assert_eq!(vec.len(), 4);
+    /// ```
+    fn from_iter<I>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        let buffer = BufferMut::from_iter(iter);
+        let validity = MaskMut::new_true(buffer.len());
+
+        PVectorMut {
+            elements: buffer,
+            validity,
+        }
+    }
+}