@@ -19,6 +19,7 @@ use crate::scalar_fn::ExecutionArgs;
 use crate::scalar_fn::unstable::row::FailureEvidence;
 use crate::scalar_fn::unstable::row::IndexedElementTuple;
 use crate::scalar_fn::unstable::row::OutputElement;
+use crate::scalar_fn::unstable::row::ViewLen;
 use crate::scalar_fn::unstable::row::visitor::assert_owned_output_needs_no_drop;
 
 /// Zero-sized failure accumulator for infallible owned visits.
@@ -77,19 +78,19 @@ where
     let failure = if let Some(views) = Args::views_if_no_consts(&columns) {
         // Keep this validation beside the views so LLVM sees their common length here.
         vortex_ensure!(
-            Args::view_lens_match(&views, row_count),
+            Args::ARITY == 0 || views.len() == row_count,
             "a decoded row input does not address exactly {row_count} rows",
         );
 
-        // SAFETY: `view_lens_match` proved every view addresses exactly `row_count` rows
-        // immediately above.
+        // SAFETY: the tuple length check proved every non-nullary view addresses exactly
+        // `row_count` rows immediately above. Nullary tuples do not access an input view.
         let source = unsafe { Args::indexed_source(views, row_count) };
 
         source.map_checked_into(output, |elements| apply(&prepared, elements))
     } else {
         // Keep this proof branch-local. Shared validation prevents LLVM from specializing this
         // loop for each batch-constant arrangement, leaving it scalar under multiple CGUs without
-        // LTO. The exact pass interaction is unknown.
+        // LTO.
         vortex_ensure!(
             Args::decoded_lens_match(&columns, row_count),
             "a decoded row input does not address exactly {row_count} rows",
 
@@ -39,7 +39,6 @@ where
     ApplyResult: SinkResult<WriteToken = <Sink as OutputSink<Options>>::WriteToken>,
 {
     let columns = Args::decode(args, ctx)?;
-    let views = Args::views_if_no_consts(&columns);
 
     let row_count = args.row_count();
     let const_values = Args::const_values(&columns);
@@ -59,13 +58,15 @@ where
             "the output sink must address exactly {row_count} rows, got {sink_row_count}",
         );
 
+        let views = Args::views_if_no_consts(&columns);
         if let Some(views) = views {
-            if !Args::view_lens_match(&views, row_count) {
+            if Args::ARITY != 0 && views.len() != row_count {
                 decoded_length_error(row_count)?;
             }
 
             for index in 0..row_count {
-                // SAFETY: `view_lens_match` proved every view has `row_count` rows before the loop.
+                // SAFETY: the tuple length check proved every non-nullary view has `row_count`
+                // rows before the loop. Nullary tuples do not access an input view.
                 let elements = unsafe { Args::get_from_views_unchecked(&views, index) };
                 // SAFETY: the sink row-count check above proved every loop index is in bounds.
                 let output =
@@ -143,7 +144,7 @@ where
         );
 
         if let Some(views) = views {
-            if !Args::view_lens_match(&views, row_count) {
+            if Args::ARITY != 0 && views.len() != row_count {
                 decoded_length_error(row_count)?;
             }
 
@@ -153,8 +154,9 @@ where
                 let output =
                     unsafe { <Sink as OutputSink<Options>>::row_unchecked(&mut rows, index) };
 
-                // SAFETY: `view_lens_match` proved every view has `row_count` rows, and mask
-                // indices are below `row_count`.
+                // SAFETY: the tuple length check proved every non-nullary view has `row_count`
+                // rows, and mask indices are below `row_count`. Nullary tuples do not access an
+                // input view.
                 let elements = unsafe { Args::get_from_views_unchecked(&views, index) };
 
                 apply(&prepared, elements, output).into_result()
 
@@ -148,7 +148,7 @@ pub trait ElementTuple: 'static + private::Sealed {
     type Columns;
 
     /// Borrowed views of decoded columns with no batch constants.
-    type Views<'a>;
+    type Views<'a>: ViewLen;
 
     /// The borrowed row of element values.
     type Elems<'a>;
@@ -206,19 +206,15 @@ pub trait ElementTuple: 'static + private::Sealed {
     /// returned tuple removes batch-constant checks from the row loop.
     fn views_if_no_consts(columns: &Self::Columns) -> Option<Self::Views<'_>>;
 
-    /// Whether every view contains exactly `row_count` rows.
-    ///
-    /// The executor calls this once before the loop used when no input is batch-constant. A
-    /// successful check gives LLVM a dominating equality between the loop bound and every source
-    /// length, which lets it optimize the tuple access as one fixed-length traversal.
-    fn view_lens_match(views: &Self::Views<'_>, row_count: usize) -> bool;
-
     /// Whether every argument decoded at full batch length contains exactly `row_count` rows.
     ///
-    /// This is the equivalent of [`view_lens_match`](Self::view_lens_match) when the columns include
-    /// batch constants. It runs once before the hot loop for the same LLVM optimization. A batch
-    /// constant is exempt because its `ArgColumn` constructor already validated the one-row
-    /// representation produced by decoding.
+    /// NB: `Columns` cannot implement [`ViewLen`] because a batch-constant [`ArgColumn`] physically
+    /// contains one decoded row while logically addressing every row in the batch. By contrast,
+    /// [`views_if_no_consts`](Self::views_if_no_consts) constructs `Views` only when every argument
+    /// is non-constant, so those views have one common physical length.
+    ///
+    /// This check runs once before the hot loop. A batch constant is exempt because its
+    /// [`ArgColumn`] constructor already validated the one-row representation produced by decoding.
     fn decoded_lens_match(columns: &Self::Columns, row_count: usize) -> bool;
 
     /// Read one row from borrowed views.
@@ -285,10 +281,6 @@ impl ElementTuple for () {
         Some(())
     }
 
-    fn view_lens_match(_views: &Self::Views<'_>, _row_count: usize) -> bool {
-        true
-    }
-
     fn decoded_lens_match(_columns: &Self::Columns, _row_count: usize) -> bool {
         true
     }
@@ -369,13 +361,6 @@ macro_rules! element_tuple {
                 Some(($($t::view(columns.$idx.as_column()?),)+))
             }
 
-            fn view_lens_match(
-                views: &Self::Views<'_>,
-                row_count: usize,
-            ) -> bool {
-                $(views.$idx.len() == row_count &&)+ true
-            }
-
             fn decoded_lens_match(columns: &Self::Columns, row_count: usize) -> bool {
                 $(columns.$idx.addresses_rows(row_count) &&)+ true
             }
 
@@ -54,3 +54,51 @@ impl<T: ViewLen + ?Sized> ViewLen for &mut T {
         T::len(self)
     }
 }
+
+macro_rules! impl_tuple_view_len {
+    ($first:ident; $($rest:ident : $idx:tt),*) => {
+        impl<$first: ViewLen, $($rest: ViewLen),*> ViewLen for ($first, $($rest,)*) {
+            fn len(&self) -> usize {
+                let len = self.0.len();
+                $(assert_eq!(self.$idx.len(), len, "tuple views must have equal lengths");)*
+
+                len
+            }
+        }
+    };
+}
+
+impl_tuple_view_len!(A;);
+impl_tuple_view_len!(A; B: 1);
+impl_tuple_view_len!(A; B: 1, C: 2);
+impl_tuple_view_len!(A; B: 1, C: 2, D: 3);
+impl_tuple_view_len!(A; B: 1, C: 2, D: 3, E: 4);
+impl_tuple_view_len!(A; B: 1, C: 2, D: 3, E: 4, F: 5);
+impl_tuple_view_len!(A; B: 1, C: 2, D: 3, E: 4, F: 5, G: 6);
+impl_tuple_view_len!(A; B: 1, C: 2, D: 3, E: 4, F: 5, G: 6, H: 7);
+impl_tuple_view_len!(A; B: 1, C: 2, D: 3, E: 4, F: 5, G: 6, H: 7, I: 8);
+impl_tuple_view_len!(A; B: 1, C: 2, D: 3, E: 4, F: 5, G: 6, H: 7, I: 8, J: 9);
+impl_tuple_view_len!(A; B: 1, C: 2, D: 3, E: 4, F: 5, G: 6, H: 7, I: 8, J: 9, K: 10);
+impl_tuple_view_len!(A; B: 1, C: 2, D: 3, E: 4, F: 5, G: 6, H: 7, I: 8, J: 9, K: 10, L: 11);
+
+#[cfg(test)]
+mod tests {
+    use super::ViewLen;
+
+    #[test]
+    fn tuple_len_returns_common_len() {
+        let first: &[i64] = &[1, 2];
+        let second: &[i64] = &[3, 4];
+
+        assert_eq!((first, second).len(), 2);
+    }
+
+    #[test]
+    #[should_panic(expected = "tuple views must have equal lengths")]
+    fn tuple_len_rejects_mismatch() {
+        let first: &[i64] = &[1];
+        let second: &[i64] = &[2, 3];
+
+        let _ = (first, second).len();
+    }
+}