Add higher-order function expressions

Signed-off-by: Matt Katz <mhkatz97@gmail.com>

Author: mhk197

vortex-array/src/expr/analysis/immediate_access.rs

@@ -42,7 +42,7 @@ pub fn make_free_field_annotator(
 ) -> impl AnnotationFn<Expression, Annotation = FieldName> {
     move |expr: &Expression| match expr {
         Expression::Root => scope.names().iter().cloned().collect(),
-        Expression::Lambda(_) | Expression::Variable(_) => vec![],
+        Expression::HigherOrder { .. } | Expression::Lambda(_) | Expression::Variable(_) => vec![],
         Expression::Scalar {
             scalar_fn,
             children,
@@ -72,7 +72,9 @@ pub fn make_bound_free_field_annotator(
 ) -> impl AnnotationFn<BoundExpression, Annotation = FieldName> {
     move |expr: &BoundExpression| match expr {
         BoundExpression::Root { .. } => scope.names().iter().cloned().collect(),
-        BoundExpression::Lambda(_) | BoundExpression::Variable(_) => vec![],
+        BoundExpression::HigherOrder { .. }
+        | BoundExpression::Lambda(_)
+        | BoundExpression::Variable(_) => vec![],
         BoundExpression::Scalar {
             scalar_fn,
             children,

vortex-array/src/expr/analysis/infallible.rs

@@ -15,6 +15,8 @@ pub fn label_infallible(expr: &Expression) -> BooleanLabels<'_> {
         expr,
         |expr| match expr {
             Expression::Scalar { scalar_fn, .. } => scalar_fn.signature().is_infallible(),
+            // Lambda fallibility is function-defined, so an unbound HOF is conservative.
+            Expression::HigherOrder { .. } => false,
             // The scope itself cannot fail.
             Expression::Root => true,
             // Fallibility is determined by the enclosing HOF.

vortex-array/src/expr/analysis/strict.rs

@@ -14,6 +14,8 @@ pub fn label_strict(expr: &Expression) -> BooleanLabels<'_> {
         expr,
         |expr| match expr {
             Expression::Scalar { scalar_fn, .. } => scalar_fn.signature().is_strict(),
+            // Strictness across lambda invocation domains is function-defined.
+            Expression::HigherOrder { .. } => false,
             Expression::Root => true,
             // Strictness is determined by the enclosing HOF.
             Expression::Variable(_) | Expression::Lambda(_) => true,