Expressions

Signed-off-by: Nicholas Gates <[email protected]>

Author: gatesn

vortex-array/src/expr/bound.rs

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::any::Any;
+use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::hash::Hash;
+use std::hash::Hasher;
+
+use vortex_dtype::DType;
+use vortex_error::VortexResult;
+use vortex_utils::debug_with::DebugWith;
+
+use crate::expr::options::ExpressionOptions;
+use crate::expr::signature::ExpressionSignature;
+use crate::expr::ExprId;
+use crate::expr::ExprVTable;
+use crate::expr::VTable;
+
+/// An instance of an expression bound to some invocation options.
+pub struct BoundExpression {
+    vtable: ExprVTable,
+    options: Box<dyn Any + Send + Sync>,
+}
+
+impl BoundExpression {
+    /// Create a new bound expression from raw vtable and options.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the provided options are compatible with the provided vtable.
+    pub(super) unsafe fn new_unchecked(
+        vtable: ExprVTable,
+        options: Box<dyn Any + Send + Sync>,
+    ) -> Self {
+        Self { vtable, options }
+    }
+
+    /// Create a new bound expression from a vtable.
+    pub fn new<V: VTable>(vtable: V, options: V::Options) -> Self {
+        let vtable = ExprVTable::new::<V>(vtable);
+        let options = Box::new(options);
+        Self { vtable, options }
+    }
+
+    /// Create a new expression from a static vtable.
+    pub fn new_static<V: VTable>(vtable: &'static V, options: V::Options) -> Self {
+        let vtable = ExprVTable::new_static::<V>(vtable);
+        let options = Box::new(options);
+        Self { vtable, options }
+    }
+
+    /// The vtable for this expression.
+    pub fn vtable(&self) -> &ExprVTable {
+        &self.vtable
+    }
+
+    /// Returns the ID of this expression.
+    pub fn id(&self) -> ExprId {
+        self.vtable.id()
+    }
+
+    /// The type-erased options for this expression.
+    pub fn options(&self) -> ExpressionOptions<'_> {
+        ExpressionOptions {
+            vtable: &self.vtable,
+            options: self.options.as_ref(),
+        }
+    }
+
+    /// Signature information for this expression.
+    pub fn signature(&self) -> ExpressionSignature<'_> {
+        ExpressionSignature {
+            vtable: &self.vtable,
+            options: self.options.as_ref(),
+        }
+    }
+
+    /// Compute the return [`DType`] of this expression given the input argument types.
+    pub fn return_dtype(&self, arg_types: &[DType]) -> VortexResult<DType> {
+        self.vtable
+            .as_dyn()
+            .return_dtype(self.options.as_ref(), arg_types)
+    }
+}
+
+impl Clone for BoundExpression {
+    fn clone(&self) -> Self {
+        BoundExpression {
+            vtable: self.vtable.clone(),
+            options: self.vtable.as_dyn().options_clone(self.options.as_ref()),
+        }
+    }
+}
+
+impl Debug for BoundExpression {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("BoundExpression")
+            .field("vtable", &self.vtable)
+            .field(
+                "options",
+                &DebugWith(|fmt| {
+                    self.vtable
+                        .as_dyn()
+                        .options_debug(self.options.as_ref(), fmt)
+                }),
+            )
+            .finish()
+    }
+}
+
+impl Display for BoundExpression {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}(", self.vtable.id())?;
+        self.vtable
+            .as_dyn()
+            .options_display(self.options.as_ref(), f)?;
+        write!(f, ")")
+    }
+}
+
+impl PartialEq for BoundExpression {
+    fn eq(&self, other: &Self) -> bool {
+        self.vtable == other.vtable
+            && self
+                .vtable
+                .as_dyn()
+                .options_eq(self.options.as_ref(), other.options.as_ref())
+    }
+}
+impl Eq for BoundExpression {}
+
+impl Hash for BoundExpression {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.vtable.hash(state);
+        self.vtable
+            .as_dyn()
+            .options_hash(self.options.as_ref(), state);
+    }
+}

vortex-array/src/expr/display.rs

@@ -17,10 +17,10 @@ impl Display for DisplayTreeExpr<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         pub use termtree::Tree;
         fn make_tree(expr: &Expression) -> Result<Tree<String>, std::fmt::Error> {
-            let node_name = format!("{}", ExpressionDebug(expr));
+            let node_name = format!("{}", expr);
 
             // Get child names for display purposes
-            let child_names = (0..expr.children().len()).map(|i| expr.child_name(i));
+            let child_names = (0..expr.children().len()).map(|i| expr.signature().child_name(i));
             let children = expr.children();
 
             let child_trees: Result<Vec<Tree<String>>, _> = children
@@ -40,18 +40,6 @@ impl Display for DisplayTreeExpr<'_> {
     }
 }
 
-struct ExpressionDebug<'a>(&'a Expression);
-impl Display for ExpressionDebug<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        // Special-case when expression has no data to avoid trailing space.
-        if self.0.data().is::<()>() {
-            return write!(f, "{}", self.0.id().as_ref());
-        }
-        write!(f, "{} ", self.0.id().as_ref())?;
-        self.0.vtable().as_dyn().fmt_data(self.0.data().as_ref(), f)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use vortex_dtype::DType;