feat[array]: use owned matchers at call sites

Replace borrow-then-clone patterns with owned matchers:
- filter/masked vtable: use into_::<AnyCanonical>() instead of
  Canonical::from(child.as_::<AnyCanonical>())
- canonical/columnar Executable: use try_into_matched instead of
  as_opt + Canonical::from
- dict take_canonical: accept owned Canonical directly

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: joseph-isaacs

vortex-array/src/arrays/dict/execute.rs

@@ -7,7 +7,6 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
 use crate::Canonical;
-use crate::CanonicalView;
 use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::arrays::Bool;
@@ -37,11 +36,10 @@ use crate::arrays::variant::VariantArrayExt;
 /// This is the core operation for dictionary decoding - it expands the dictionary
 /// by looking up each code in the values array.
 pub(crate) fn take_canonical(
-    values: CanonicalView,
+    values: Canonical,
     codes: &PrimitiveArray,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<Canonical> {
-    let values = Canonical::from(values);
     Ok(match values {
         Canonical::Null(a) => Canonical::Null(take_null(&a, codes)),
         Canonical::Bool(a) => Canonical::Bool(take_bool(&a, codes, ctx)?),

vortex-array/src/arrays/dict/vtable/mod.rs

@@ -190,11 +190,10 @@ impl VTable for Dict {
 
         let DictParts { values, codes, .. } = array.into_parts();
 
-        Ok(ExecutionResult::done(take_canonical(
-            values.as_::<AnyCanonical>(),
-            &codes.downcast::<Primitive>(),
-            ctx,
-        )?))
+        let codes = codes.downcast::<Primitive>();
+        let values = values.into_::<AnyCanonical>();
+
+        Ok(ExecutionResult::done(take_canonical(values, &codes, ctx)?))
     }
 
     fn reduce_parent(

vortex-array/src/arrays/filter/vtable.rs

@@ -17,7 +17,6 @@ use crate::AnyCanonical;
 use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
-use crate::Canonical;
 use crate::IntoArray;
 use crate::Precision;
 use crate::array::Array;
@@ -155,8 +154,7 @@ impl VTable for Filter {
 
         // We rely on the optimization pass that runs prior to this execution for filter pushdown,
         // so now we can just execute the filter without worrying.
-        // TODO(joe): fix the ownership of AnyCanonical
-        let child = Canonical::from(array.child().as_::<AnyCanonical>());
+        let child = array.child().clone().into_::<AnyCanonical>();
         Ok(ExecutionResult::done(
             execute_filter(child, &mask_values).into_array(),
         ))

vortex-array/src/arrays/masked/vtable/mod.rs

@@ -19,7 +19,6 @@ use crate::AnyCanonical;
 use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
-use crate::Canonical;
 use crate::IntoArray;
 use crate::LEGACY_SESSION;
 use crate::Precision;
@@ -178,7 +177,7 @@ impl VTable for Masked {
         // While we could manually convert the dtype, `mask_validity_canonical` is already O(1) for
         // `AllTrue` masks (no data copying), so there's no benefit.
 
-        let child = Canonical::from(array.child().as_::<AnyCanonical>());
+        let child = array.child().clone().into_::<AnyCanonical>();
         Ok(ExecutionResult::done(
             mask_validity_canonical(child, validity, ctx)?.into_array(),
         ))

vortex-array/src/canonical.rs

@@ -543,8 +543,7 @@ impl Executable for Canonical {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
         let result = array.execute_until::<AnyCanonical>(ctx)?;
         Ok(result
-            .as_opt::<AnyCanonical>()
-            .map(Canonical::from)
+            .try_into_matched::<AnyCanonical>()
             .vortex_expect("execute_until::<AnyCanonical> must return a canonical array"))
     }
 }

vortex-array/src/columnar.rs

@@ -72,16 +72,9 @@ impl IntoArray for Columnar {
 impl Executable for Columnar {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
         let result = array.execute_until::<AnyColumnar>(ctx)?;
-        if let Some(constant) = result.as_opt::<Constant>() {
-            Ok(Columnar::Constant(constant.into_owned()))
-        } else {
-            Ok(Columnar::Canonical(
-                result
-                    .as_opt::<AnyCanonical>()
-                    .map(Canonical::from)
-                    .vortex_expect("execute_until::<AnyColumnar> must return a columnar array"),
-            ))
-        }
+        Ok(result
+            .try_into_matched::<AnyColumnar>()
+            .vortex_expect("execute_until::<AnyColumnar> must return a columnar array"))
     }
 }