refactor: collapse per-shape checked kernels into one care-lane dispatch

The operand split (PrimitiveOperand) and the validity-and-demand merge
(care_lanes) both happen before the kernels run, so the three shape
dispatchers and twelve shape-specific kernel wrappers reduce to a single
checked_op generic over a lane accessor. Slices and constants are bound
outside the closures so codegen matches the old direct-slice kernels
(verified with the binary_ops divan bench).

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GhAvQmWLipNHBKjrZhxnKv

Author: joseph-isaacs

vortex-array/src/scalar_fn/fns/binary/numeric.rs

@@ -174,15 +174,24 @@ where
         (
             PrimitiveOperand::Array { values: lhs, .. },
             PrimitiveOperand::Array { values: rhs, .. },
-        ) => checked_array_array::<T, Op>(lhs, rhs, &care_lanes),
+        ) => {
+            let (lhs, rhs) = (lhs.as_slice(), rhs.as_slice());
+            checked_op::<T, Op, _>(len, &care_lanes, |idx| (lhs[idx], rhs[idx]))
+        }
         (
             PrimitiveOperand::Array { values: lhs, .. },
             PrimitiveOperand::Constant { value: rhs, .. },
-        ) => checked_array_constant::<T, Op>(lhs, *rhs, &care_lanes),
+        ) => {
+            let (lhs, rhs) = (lhs.as_slice(), *rhs);
+            checked_op::<T, Op, _>(len, &care_lanes, |idx| (lhs[idx], rhs))
+        }
         (
             PrimitiveOperand::Constant { value: lhs, .. },
             PrimitiveOperand::Array { values: rhs, .. },
-        ) => checked_constant_array::<T, Op>(*lhs, rhs, &care_lanes),
+        ) => {
+            let (lhs, rhs) = (*lhs, rhs.as_slice());
+            checked_op::<T, Op, _>(len, &care_lanes, |idx| (lhs, rhs[idx]))
+        }
         (
             PrimitiveOperand::Constant { value: lhs, .. },
             PrimitiveOperand::Constant { value: rhs, .. },
@@ -302,132 +311,48 @@ impl<T: NativePType> CheckedValues<T> {
     }
 }
 
-fn checked_array_array<T, Op>(lhs: &[T], rhs: &[T], care_lanes: &Mask) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    debug_assert_eq!(lhs.len(), rhs.len());
-
-    match care_lanes.bit_buffer() {
-        AllOr::All if Op::CHECKED_VALUE_LOOP => checked_array_array_one_pass::<T, Op>(lhs, rhs),
-        AllOr::All => checked_array_array_all_lanes::<T, Op>(lhs, rhs),
-        AllOr::None => CheckedValues::zeroed(lhs.len()),
-        AllOr::Some(valid_bits) if Op::CHECKED_VALUE_LOOP => {
-            checked_array_array_valid_lanes_one_pass::<T, Op>(lhs, rhs, valid_bits)
-        }
-        AllOr::Some(valid_bits) => checked_array_array_valid_lanes::<T, Op>(lhs, rhs, valid_bits),
-    }
-}
-
-fn checked_array_constant<T, Op>(lhs: &[T], rhs: T, care_lanes: &Mask) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    match care_lanes.bit_buffer() {
-        AllOr::All if Op::CHECKED_VALUE_LOOP => checked_array_constant_one_pass::<T, Op>(lhs, rhs),
-        AllOr::All => checked_array_constant_all_lanes::<T, Op>(lhs, rhs),
-        AllOr::None => CheckedValues::zeroed(lhs.len()),
-        AllOr::Some(valid_bits) if Op::CHECKED_VALUE_LOOP => {
-            checked_array_constant_valid_lanes_one_pass::<T, Op>(lhs, rhs, valid_bits)
-        }
-        AllOr::Some(valid_bits) => {
-            checked_array_constant_valid_lanes::<T, Op>(lhs, rhs, valid_bits)
-        }
-    }
-}
-
-fn checked_constant_array<T, Op>(lhs: T, rhs: &[T], care_lanes: &Mask) -> CheckedValues<T>
+/// Dispatch a checked op over the care lanes, reading operands via `operands_at`.
+///
+/// The one-pass strategy short-circuits on the first observable error; the default
+/// split strategy computes every lane branch-free and re-scans only care lanes for
+/// errors, so undemanded and null lanes never fail the operation.
+fn checked_op<T, Op, F>(len: usize, care_lanes: &Mask, operands_at: F) -> CheckedValues<T>
 where
     T: NativePType,
     Op: CheckedPrimitiveOp<T>,
+    F: Fn(usize) -> (T, T) + Copy,
 {
     match care_lanes.bit_buffer() {
-        AllOr::All if Op::CHECKED_VALUE_LOOP => checked_constant_array_one_pass::<T, Op>(lhs, rhs),
-        AllOr::All => checked_constant_array_all_lanes::<T, Op>(lhs, rhs),
-        AllOr::None => CheckedValues::zeroed(rhs.len()),
-        AllOr::Some(valid_bits) if Op::CHECKED_VALUE_LOOP => {
-            checked_constant_array_valid_lanes_one_pass::<T, Op>(lhs, rhs, valid_bits)
+        AllOr::All if Op::CHECKED_VALUE_LOOP => checked_all_lanes(len, |idx| {
+            let (lhs, rhs) = operands_at(idx);
+            Op::checked(lhs, rhs)
+        }),
+        AllOr::All => collect_all_lanes(len, |idx| {
+            let (lhs, rhs) = operands_at(idx);
+            Op::apply(lhs, rhs)
+        }),
+        AllOr::None => CheckedValues::zeroed(len),
+        AllOr::Some(care_bits) if Op::CHECKED_VALUE_LOOP => {
+            checked_valid_lanes(len, care_bits, |idx| {
+                let (lhs, rhs) = operands_at(idx);
+                Op::checked(lhs, rhs)
+            })
         }
-        AllOr::Some(valid_bits) => {
-            checked_constant_array_valid_lanes::<T, Op>(lhs, rhs, valid_bits)
+        AllOr::Some(care_bits) => {
+            let mut checked = collect_all_lanes(len, |idx| {
+                let (lhs, rhs) = operands_at(idx);
+                Op::apply(lhs, rhs)
+            });
+            checked.failed = checked.failed
+                && any_valid_error(len, care_bits, |idx| {
+                    let (lhs, rhs) = operands_at(idx);
+                    Op::apply(lhs, rhs).1
+                });
+            checked
         }
     }
 }
 
-fn checked_array_array_all_lanes<T, Op>(lhs: &[T], rhs: &[T]) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    collect_all_lanes(lhs.len(), |idx| Op::apply(lhs[idx], rhs[idx]))
-}
-
-fn checked_array_array_valid_lanes<T, Op>(
-    lhs: &[T],
-    rhs: &[T],
-    valid_bits: &BitBuffer,
-) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    let mut checked = collect_all_lanes(lhs.len(), |idx| Op::apply(lhs[idx], rhs[idx]));
-
-    checked.failed = checked.failed
-        && any_valid_error(lhs.len(), valid_bits, |idx| Op::apply(lhs[idx], rhs[idx]).1);
-    checked
-}
-
-fn checked_array_constant_all_lanes<T, Op>(lhs: &[T], rhs: T) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    collect_all_lanes(lhs.len(), |idx| Op::apply(lhs[idx], rhs))
-}
-
-fn checked_array_constant_valid_lanes<T, Op>(
-    lhs: &[T],
-    rhs: T,
-    valid_bits: &BitBuffer,
-) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    let mut checked = collect_all_lanes(lhs.len(), |idx| Op::apply(lhs[idx], rhs));
-
-    checked.failed =
-        checked.failed && any_valid_error(lhs.len(), valid_bits, |idx| Op::apply(lhs[idx], rhs).1);
-    checked
-}
-
-fn checked_constant_array_all_lanes<T, Op>(lhs: T, rhs: &[T]) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    collect_all_lanes(rhs.len(), |idx| Op::apply(lhs, rhs[idx]))
-}
-
-fn checked_constant_array_valid_lanes<T, Op>(
-    lhs: T,
-    rhs: &[T],
-    valid_bits: &BitBuffer,
-) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    let mut checked = collect_all_lanes(rhs.len(), |idx| Op::apply(lhs, rhs[idx]));
-
-    checked.failed =
-        checked.failed && any_valid_error(rhs.len(), valid_bits, |idx| Op::apply(lhs, rhs[idx]).1);
-    checked
-}
-
 fn collect_all_lanes<T, F>(len: usize, mut value_and_error_at: F) -> CheckedValues<T>
 where
     T: NativePType,
@@ -450,66 +375,6 @@ where
     }
 }
 
-fn checked_array_array_one_pass<T, Op>(lhs: &[T], rhs: &[T]) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    checked_all_lanes(lhs.len(), |idx| Op::checked(lhs[idx], rhs[idx]))
-}
-
-fn checked_array_array_valid_lanes_one_pass<T, Op>(
-    lhs: &[T],
-    rhs: &[T],
-    valid_bits: &BitBuffer,
-) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    checked_valid_lanes(lhs.len(), valid_bits, |idx| Op::checked(lhs[idx], rhs[idx]))
-}
-
-fn checked_array_constant_one_pass<T, Op>(lhs: &[T], rhs: T) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    checked_all_lanes(lhs.len(), |idx| Op::checked(lhs[idx], rhs))
-}
-
-fn checked_array_constant_valid_lanes_one_pass<T, Op>(
-    lhs: &[T],
-    rhs: T,
-    valid_bits: &BitBuffer,
-) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    checked_valid_lanes(lhs.len(), valid_bits, |idx| Op::checked(lhs[idx], rhs))
-}
-
-fn checked_constant_array_one_pass<T, Op>(lhs: T, rhs: &[T]) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    checked_all_lanes(rhs.len(), |idx| Op::checked(lhs, rhs[idx]))
-}
-
-fn checked_constant_array_valid_lanes_one_pass<T, Op>(
-    lhs: T,
-    rhs: &[T],
-    valid_bits: &BitBuffer,
-) -> CheckedValues<T>
-where
-    T: NativePType,
-    Op: CheckedPrimitiveOp<T>,
-{
-    checked_valid_lanes(rhs.len(), valid_bits, |idx| Op::checked(lhs, rhs[idx]))
-}
-
 // Checked one-pass ops delay early exit until the end of a small block. This
 // keeps the loop generic while avoiding a branch-driven exit decision on every
 // lane; it is deliberately independent of mask density or input length.