Simplify the RowFn public API

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>

Author: connortsui20

vortex-array/src/scalar_fn/mod.rs

@@ -19,13 +19,6 @@ use crate::scalar_fn::fns::ext_storage::ExtStorage;
 use crate::scalar_fn::fns::get_item::GetItem;
 use crate::scalar_fn::fns::literal::Literal;
 
-/// Reexports used by [`impl_row_fn_vtable!`] without downstream transitive dependencies.
-#[doc(hidden)]
-pub mod row_fn_macro_support {
-    pub use vortex_error::VortexResult;
-    pub use vortex_session::VortexSession;
-}
-
 mod vtable;
 pub use vtable::*;
 

vortex-array/src/scalar_fn/row/batch/execution.rs

@@ -19,6 +19,7 @@ use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::arrays::BoolArray;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
 use crate::arrays::MaskedArray;
 use crate::arrays::PrimitiveArray;
@@ -141,10 +142,11 @@ impl Batch {
         // Strictness: an all-null batch has no observable row work. Keep the literal-constant
         // check explicit alongside the conjoined validity invariant.
         if matches!(self.validity, Validity::AllInvalid)
-            || self
-                .inputs
-                .iter()
-                .any(|input| input.as_constant().is_some_and(|scalar| scalar.is_null()))
+            || self.inputs.iter().any(|input| {
+                input
+                    .as_opt::<Constant>()
+                    .is_some_and(|constant| constant.scalar().is_null())
+            })
         {
             return Ok(self.all_null());
         }

vortex-array/src/scalar_fn/row/batch/policy.rs

@@ -85,11 +85,11 @@ mod tests {
 
     struct SparseFallibleElement;
 
-    // SAFETY: the varying view reports length zero, so no index satisfies the unchecked-read
+    // SAFETY: the per-row view reports length zero, so no index satisfies the unchecked-read
     // precondition.
     unsafe impl InputElement for SparseFallibleElement {
         type Column = ();
-        type Varying<'a> = ();
+        type View<'a> = ();
         type Elem<'a> = ();
 
         const DENSE_SAFE: bool = false;
@@ -105,13 +105,13 @@ mod tests {
 
         fn get(_column: &Self::Column, _index: usize) -> Self::Elem<'_> {}
 
-        fn varying(_column: &Self::Column) -> Self::Varying<'_> {}
+        fn view(_column: &Self::Column) -> Self::View<'_> {}
 
-        fn varying_len(_column: &Self::Varying<'_>) -> usize {
+        fn view_len(_view: &Self::View<'_>) -> usize {
             0
         }
 
-        fn get_varying<'a>(_column: &Self::Varying<'a>, _index: usize) -> Self::Elem<'a> {}
+        fn get_from_view<'a>(_view: &Self::View<'a>, _index: usize) -> Self::Elem<'a> {}
     }
 
     #[test]

vortex-array/src/scalar_fn/row/batch/tests.rs

@@ -690,11 +690,11 @@ fn assert_invalid_kernel_output(input: ArrayRef) -> VortexResult<()> {
 
 #[rstest]
 #[case::owned_constant(PreparedVisit::Owned, true)]
-#[case::owned_varying(PreparedVisit::Owned, false)]
+#[case::owned_per_row(PreparedVisit::Owned, false)]
 #[case::sink_constant(PreparedVisit::Sink, true)]
-#[case::sink_varying(PreparedVisit::Sink, false)]
+#[case::sink_per_row(PreparedVisit::Sink, false)]
 #[case::deferred_constant(PreparedVisit::Deferred, true)]
-#[case::deferred_varying(PreparedVisit::Deferred, false)]
+#[case::deferred_per_row(PreparedVisit::Deferred, false)]
 fn test_prepared_visits(
     #[case] visit: PreparedVisit,
     #[case] constant_rhs: bool,
@@ -771,7 +771,7 @@ fn test_nullary_row_function_broadcasts() -> VortexResult<()> {
 }
 
 #[test]
-fn test_owned_execution_traverses_three_varying_inputs() -> VortexResult<()> {
+fn test_owned_execution_traverses_three_per_row_inputs() -> VortexResult<()> {
     let args = VecExecutionArgs::new(
         vec![
             PrimitiveArray::from_iter([1_i64, 2, 3]).into_array(),

vortex-array/src/scalar_fn/row/execute/mod.rs

@@ -56,11 +56,11 @@ impl From<RowExecution> for VortexResult<ArrayRef> {
 /// Ensure that every decoded input addresses the complete row loop.
 pub(super) fn ensure_decoded_lengths<Args: ElementTuple>(
     columns: &Args::Columns,
-    varying: Option<&Args::VaryingColumns<'_>>,
+    views: Option<&Args::Views<'_>>,
     row_count: usize,
 ) -> VortexResult<()> {
-    let lengths_match = match varying {
-        Some(varying) => Args::varying_len_matches(varying, row_count),
+    let lengths_match = match views {
+        Some(views) => Args::view_lens_match(views, row_count),
         None => Args::decoded_lens_match(columns, row_count),
     };
     vortex_ensure!(

vortex-array/src/scalar_fn/row/execute/owned.rs

@@ -71,25 +71,26 @@ where
     {
         let output = &mut values.spare_capacity_mut()[..row_count];
 
-        // When every input varies, the indexed source removes argument-shape dispatch from the hot
-        // loop and lets the lane kernel optimize the traversal as one operation. Keep the varying
-        // view and its length proof in this branch: hoisting them through the shared validation
-        // helper changed mixed-constant add, subtract, and multiply from 9.219, 9.229, and 18.94 us
-        // to 30.46, 31.11, and 37.73 us on a Ryzen 9 7950X with rustc 1.91.0 and LLVM 21.1.2.
+        // When every input stores one value per row, the indexed source removes argument-shape
+        // dispatch from the hot loop and lets the lane kernel optimize the traversal as one
+        // operation. Keep view construction and its length proof in this branch. Hoisting them
+        // through the shared validation helper changed mixed-constant add, subtract, and multiply
+        // from 9.219, 9.229, and 18.94 us to 30.46, 31.11, and 37.73 us on a Ryzen 9 7950X with
+        // rustc 1.91.0 and LLVM 21.1.2.
         // Restoring this placement recovered the fast code under the 16-CGU, no-LTO bench profile.
-        if let Some(varying) = Args::varying(&columns) {
+        if let Some(views) = Args::per_row_views(&columns) {
             vortex_ensure!(
-                Args::varying_len_matches(&varying, row_count),
+                Args::view_lens_match(&views, row_count),
                 "a decoded row input does not address exactly {row_count} rows",
             );
 
-            // SAFETY: `varying_len_matches` proved every column addresses exactly `row_count`
-            // rows immediately above.
-            failure = unsafe { Args::indexed_source(varying, row_count) }
+            // SAFETY: `view_lens_match` proved every view addresses exactly `row_count` rows
+            // immediately above.
+            failure = unsafe { Args::indexed_source(views, row_count) }
                 .map_checked_into(output, |elements| apply(&prepared, elements));
         } else {
             // A batch-constant input was collapsed to one row during decoding. This path reads that
-            // row repeatedly while indexing only the inputs that vary.
+            // row repeatedly while indexing only the per-row inputs.
             vortex_ensure!(
                 Args::decoded_lens_match(&columns, row_count),
                 "a decoded row input does not address exactly {row_count} rows",

vortex-array/src/scalar_fn/row/execute/sink.rs

@@ -38,8 +38,8 @@ where
     let mut sink = <Sink as OutputSink<Options>>::with_capacity(row_count, sink_dtype)?;
     let columns = Args::decode(args, ctx)?;
     let prepared = prepare(Args::constants(&columns));
-    let varying = Args::varying(&columns);
-    ensure_decoded_lengths::<Args>(&columns, varying.as_ref(), row_count)?;
+    let views = Args::per_row_views(&columns);
+    ensure_decoded_lengths::<Args>(&columns, views.as_ref(), row_count)?;
 
     {
         // Borrow the sink once so its shape and buffer descriptor remain loop invariants. This
@@ -50,13 +50,13 @@ where
             "the output sink does not address exactly {row_count} rows",
         );
 
-        // The all-varying representation removes argument-shape dispatch from the hot loop. The
+        // The all-per-row representation removes argument-shape dispatch from the hot loop. The
         // mixed path instead reads collapsed batch constants at row zero.
-        if let Some(varying) = varying {
+        if let Some(views) = views {
             for index in 0..row_count {
-                // SAFETY: `ensure_decoded_lengths` proved every varying column has `row_count`
-                // rows before the loop.
-                let elements = unsafe { Args::get_varying_unchecked(&varying, index) };
+                // SAFETY: `ensure_decoded_lengths` proved every view has `row_count` rows before
+                // the loop.
+                let elements = unsafe { Args::get_from_views_unchecked(&views, index) };
                 apply(
                     &prepared,
                     elements,
@@ -95,7 +95,7 @@ where
 {
     // Decline before input decoding or sink allocation when this sink cannot initialize rows that
     // the mask skips. The capability and the operation are the same function pointer.
-    let Some(initialize_skipped_rows) = <Sink as OutputSink<Options>>::SKIPPED_ROWS_INITIALIZER
+    let Some(initialize_skipped_rows) = <Sink as OutputSink<Options>>::skipped_rows_initializer()
     else {
         return Ok(None);
     };
@@ -125,8 +125,8 @@ where
             "the output sink does not address exactly {row_count} rows",
         );
 
-        let varying = Args::varying(&columns);
-        ensure_decoded_lengths::<Args>(&columns, varying.as_ref(), row_count)?;
+        let views = Args::per_row_views(&columns);
+        ensure_decoded_lengths::<Args>(&columns, views.as_ref(), row_count)?;
 
         // The loop writes only valid indices, but the sink still finishes a full-length output.
         // Initialize placeholders now; batch execution masks them before the result escapes.
@@ -140,12 +140,12 @@ where
                 return;
             }
 
-            let result = match &varying {
-                Some(varying) => apply(
+            let result = match &views {
+                Some(views) => apply(
                     &prepared,
-                    // SAFETY: `ensure_decoded_lengths` proved every varying column has
-                    // `row_count` rows, and mask indices are below `row_count`.
-                    unsafe { Args::get_varying_unchecked(varying, index) },
+                    // SAFETY: `ensure_decoded_lengths` proved every view has `row_count` rows, and
+                    // mask indices are below `row_count`.
+                    unsafe { Args::get_from_views_unchecked(views, index) },
                     <Sink as OutputSink<Options>>::row(&mut rows, index),
                 ),
                 None => apply(

vortex-array/src/scalar_fn/row/row_fn.rs

@@ -23,12 +23,10 @@ use crate::scalar_fn::ScalarFnId;
 /// Declare the argument names and use [`dispatch`](Self::dispatch) to choose concrete element and
 /// sink types for each accepted dtype combination.
 ///
-/// A `RowFn` does not automatically implement
-/// [`ScalarFnVTable`](crate::scalar_fn::ScalarFnVTable). Invoke
-/// [`impl_row_fn_vtable!`](crate::impl_row_fn_vtable) to adopt its standard scalar-function
-/// behavior. A function that needs custom coercion, simplification, reduction, formatting, or
-/// validity hooks implements `ScalarFnVTable` itself and can delegate its `return_dtype` and
-/// `execute` methods to [`row_fn_return_dtype`](crate::scalar_fn::row_fn_return_dtype) and
+/// Every `RowFn` receives the standard [`ScalarFnVTable`](crate::scalar_fn::ScalarFnVTable)
+/// implementation. A function that needs custom scalar-function hooks instead implements
+/// `ScalarFnVTable` on its public type and delegates row execution to a private `RowFn` kernel with
+/// [`row_fn_return_dtype`](crate::scalar_fn::row_fn_return_dtype) and
 /// [`execute_rows`](crate::scalar_fn::execute_rows). Implement only `ScalarFnVTable` when the
 /// natural kernel is columnar rather than row-oriented.
 pub trait RowFn: 'static + Sized + Clone + Send + Sync {

vortex-array/src/scalar_fn/row/types/element/bool.rs

@@ -15,10 +15,10 @@ use crate::scalar_fn::InputElement;
 use crate::scalar_fn::OutputElement;
 use crate::validity::Validity;
 
-// SAFETY: the varying view is a bit buffer, and its reported length is the buffer length.
+// SAFETY: the per-row view is a bit buffer, and its reported length is the buffer length.
 unsafe impl InputElement for bool {
     type Column = BitBuffer;
-    type Varying<'a> = &'a BitBuffer;
+    type View<'a> = &'a BitBuffer;
     type Elem<'a> = bool;
 
     // Every bit of the buffer is readable, valid or not.
@@ -41,27 +41,27 @@ unsafe impl InputElement for bool {
         column.value(index)
     }
 
-    fn varying(column: &Self::Column) -> Self::Varying<'_> {
+    fn view(column: &Self::Column) -> Self::View<'_> {
         column
     }
 
-    fn varying_len(column: &Self::Varying<'_>) -> usize {
-        column.len()
+    fn view_len(view: &Self::View<'_>) -> usize {
+        view.len()
     }
 
-    fn get_varying<'a>(column: &Self::Varying<'a>, index: usize) -> bool
+    fn get_from_view<'a>(view: &Self::View<'a>, index: usize) -> bool
     where
         Self: 'a,
     {
-        column.value(index)
+        view.value(index)
     }
 
-    unsafe fn get_varying_unchecked<'a>(column: &Self::Varying<'a>, index: usize) -> bool
+    unsafe fn get_from_view_unchecked<'a>(view: &Self::View<'a>, index: usize) -> bool
     where
         Self: 'a,
     {
         // SAFETY: forwarded from this method's contract.
-        unsafe { column.value_unchecked(index) }
+        unsafe { view.value_unchecked(index) }
     }
 }
 

vortex-array/src/scalar_fn/row/types/element/mod.rs

@@ -26,20 +26,20 @@ pub use tuple::batch_constant;
 ///
 /// # Safety
 ///
-/// For every view returned by [`varying`](Self::varying), every index below
-/// [`varying_len`](Self::varying_len) **must** satisfy the safety contract of
-/// [`get_varying_unchecked`](Self::get_varying_unchecked). Shared execution relies on this proof to
-/// perform unchecked reads after one pre-loop length check.
+/// For every view returned by [`view`](Self::view), every index below
+/// [`view_len`](Self::view_len) **must** satisfy the safety contract of
+/// [`get_from_view_unchecked`](Self::get_from_view_unchecked). Shared execution relies on this
+/// proof to perform unchecked reads after one pre-loop length check.
 pub unsafe trait InputElement: 'static {
     /// The decoded column representation supporting `O(1)` row access.
     type Column;
 
-    /// The view of a varying decoded column read by the hot row loop.
+    /// The view of a per-row decoded column read by the hot row loop.
     ///
     /// This may borrow a cheaper representation than [`Column`](Self::Column). Primitive elements,
     /// for example, expose a slice so its pointer and length are loop invariants rather than
     /// re-reading a [`Buffer`](vortex_buffer::Buffer) descriptor for every row.
-    type Varying<'a>;
+    type View<'a>;
 
     /// The borrowed element value handed to a row closure.
     type Elem<'a>;
@@ -48,8 +48,8 @@ pub unsafe trait InputElement: 'static {
     ///
     /// Arrays only guarantee payloads for valid rows. This is `false` when a null row's stored
     /// offset or pointer may not address anything, and `true` only when [`decode`](Self::decode),
-    /// [`get`](Self::get), [`varying`](Self::varying), [`varying_len`](Self::varying_len), and
-    /// [`get_varying`](Self::get_varying) remain safe and correct for null rows.
+    /// [`get`](Self::get), [`view`](Self::view), [`view_len`](Self::view_len), and
+    /// [`get_from_view`](Self::get_from_view) remain safe and correct for null rows.
     ///
     /// Dense execution requires this of every argument; otherwise the row layer executes only
     /// valid rows.
@@ -105,29 +105,29 @@ pub unsafe trait InputElement: 'static {
     ///
     /// Called once before the hot loop. Constants do not use this view because the tuple adapter
     /// keeps their one-row decoded representation separate.
-    fn varying(column: &Self::Column) -> Self::Varying<'_>;
+    fn view(column: &Self::Column) -> Self::View<'_>;
 
-    /// Number of rows addressable through a [`Varying`](Self::Varying) view.
+    /// Number of rows addressable through a [`View`](Self::View).
     ///
     /// Every index below this length must be valid for
-    /// [`get_varying_unchecked`](Self::get_varying_unchecked).
-    fn varying_len(column: &Self::Varying<'_>) -> usize;
+    /// [`get_from_view_unchecked`](Self::get_from_view_unchecked).
+    fn view_len(view: &Self::View<'_>) -> usize;
 
-    /// Read one row from a [`Varying`](Self::Varying) view.
-    fn get_varying<'a>(column: &Self::Varying<'a>, index: usize) -> Self::Elem<'a>
+    /// Read one row from a [`View`](Self::View).
+    fn get_from_view<'a>(view: &Self::View<'a>, index: usize) -> Self::Elem<'a>
     where
         Self: 'a;
 
     /// Read one row without checking that `index` is in bounds.
     ///
     /// # Safety
     ///
-    /// `index` must be less than [`varying_len`](Self::varying_len) for `column`.
-    unsafe fn get_varying_unchecked<'a>(column: &Self::Varying<'a>, index: usize) -> Self::Elem<'a>
+    /// `index` must be less than [`view_len`](Self::view_len) for `view`.
+    unsafe fn get_from_view_unchecked<'a>(view: &Self::View<'a>, index: usize) -> Self::Elem<'a>
     where
         Self: 'a,
     {
-        Self::get_varying(column, index)
+        Self::get_from_view(view, index)
     }
 }