@@ -77,8 +77,8 @@ impl Compressor for VortexCompressor {
             // Columns are named "0".."num_columns-1"; project the given subset.
             let names: FieldNames = cols.iter().map(|i| i.to_string()).collect();
             let projection = select(names, root())
-                .optimize_recursive(&source_dtype)?
-                .bind(&source_dtype)?;
+                .bind(&source_dtype)?
+                .optimize_recursive()?;
             scan = scan.with_projection(projection);
         }
         let schema = Arc::new(SESSION.arrow().to_arrow_schema(&scan.dtype()?)?);
 
@@ -79,8 +79,8 @@ session.write_options()
 
 // Scanning a layout
 let filter = expr
-    .optimize_recursive(layout_reader.dtype())?
-    .bind(layout_reader.dtype())?;
+    .bind(layout_reader.dtype())?
+    .optimize_recursive()?;
 ScanBuilder::new(session.clone(), layout_reader)
     .with_filter(filter)
     .into_array_stream()?;
 
@@ -83,14 +83,14 @@ fuzz_target!(|fuzz: FuzzFileAction| -> Corpus {
         .vortex_expect("open_buffer should succeed in fuzz test");
     let projection = projection_expr
         .unwrap_or_else(root)
-        .optimize_recursive(file.dtype())
-        .and_then(|expr| expr.bind(file.dtype()))
+        .bind(file.dtype())
+        .and_then(|expr| expr.optimize_recursive())
         .vortex_expect("projection should bind in fuzz test");
     let filter = filter_expr
         .map(|filter| {
             filter
-                .optimize_recursive(file.dtype())
-                .and_then(|expr| expr.bind(file.dtype()))
+                .bind(file.dtype())
+                .and_then(|expr| expr.optimize_recursive())
         })
         .transpose()
         .vortex_expect("filter should bind in fuzz test");
 
@@ -43,7 +43,7 @@ fn build_or_chain(n: usize) -> Expression {
 
 #[divan::bench(args = [200])]
 fn optimize_or_chain(bencher: Bencher, n: usize) {
-    let expr = build_or_chain(n);
     let scope = struct_scope();
-    bencher.bench(|| expr.optimize_recursive(&scope).unwrap());
+    let expr = build_or_chain(n).bind(&scope).unwrap();
+    bencher.bench(|| expr.optimize_recursive().unwrap());
 }
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-//! Benchmarks `Expression::optimize_recursive` on lookup-style pushdown predicates:
+//! Benchmarks `BoundExpression::optimize_recursive` on lookup-style pushdown predicates:
 //! an id membership test (either `list_contains` or a balanced OR of equalities) conjoined
 //! with timestamp range bounds and kind filters.
 
@@ -207,7 +207,7 @@ fn lookup_predicate(predicate_case: PredicateCase) -> Expression {
 #[divan::bench(args = PREDICATE_CASES)]
 fn optimize_lookup_predicate(bencher: Bencher, predicate_case: &PredicateCase) {
     let scope = scope();
-    let predicate = lookup_predicate(*predicate_case);
+    let predicate = lookup_predicate(*predicate_case).bind(&scope).unwrap();
 
-    bencher.bench(|| black_box(predicate.optimize_recursive(&scope)));
+    bencher.bench(|| black_box(predicate.optimize_recursive()));
 }
@@ -1,46 +1,29 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::cell::RefCell;
-
-use itertools::Itertools;
 use vortex_error::VortexResult;
-use vortex_error::vortex_err;
-use vortex_utils::aliases::hash_map::HashMap;
 
-use crate::dtype::DType;
-use crate::expr::Expression;
+use crate::expr::BoundExpression;
 use crate::expr::transform::match_between::find_between;
 use crate::scalar_fn::ExpressionReduceNode;
-use crate::scalar_fn::SimplifyCtx;
 
-impl Expression {
+impl BoundExpression {
     /// Optimize the root expression node only, iterating to convergence.
     ///
     /// This applies optimization rules repeatedly until no more changes occur:
-    /// 1. `simplify_untyped` - type-independent simplifications
-    /// 2. `simplify` - type-aware simplifications
-    /// 3. `reduce` - abstract reduction rules via `ReduceNode`
-    pub fn optimize(&self, scope: &DType) -> VortexResult<Expression> {
-        let cache = SimplifyCache::new(scope);
-        Ok(self.try_optimize(&cache)?.unwrap_or_else(|| self.clone()))
+    /// 1. `simplify` - scalar-function simplifications over the bound node
+    /// 2. `reduce` - abstract reduction rules via `ReduceNode`
+    pub fn optimize(&self) -> VortexResult<BoundExpression> {
+        Ok(self.try_optimize()?.unwrap_or_else(|| self.clone()))
     }
 
-    /// Apply this node's own untyped simplification rule, if it has one.
+    /// Apply this node's own simplification rule, if it has one.
     ///
     /// Non-scalar nodes carry no rules, so they never simplify.
-    fn simplify_untyped_node(&self) -> VortexResult<Option<Expression>> {
+    fn simplify_node(&self) -> VortexResult<Option<BoundExpression>> {
         match self {
-            Expression::Scalar { scalar_fn, .. } => scalar_fn.simplify_untyped(self),
-            Expression::Root => Ok(None),
-        }
-    }
-
-    /// Apply this node's own type-aware simplification rule, if it has one.
-    fn simplify_node(&self, ctx: &dyn SimplifyCtx) -> VortexResult<Option<Expression>> {
-        match self {
-            Expression::Scalar { scalar_fn, .. } => scalar_fn.simplify(self, ctx),
-            Expression::Root => Ok(None),
+            BoundExpression::Scalar { scalar_fn, .. } => scalar_fn.simplify(self),
+            BoundExpression::Root { .. } => Ok(None),
         }
     }
 
@@ -50,16 +33,16 @@ impl Expression {
         node: &ExpressionReduceNode<'a>,
     ) -> VortexResult<Option<ExpressionReduceNode<'a>>> {
         match self {
-            Expression::Scalar { scalar_fn, .. } => scalar_fn.reduce_expression(node),
-            Expression::Root => Ok(None),
+            BoundExpression::Scalar { scalar_fn, .. } => scalar_fn.reduce_expression(node),
+            BoundExpression::Root { .. } => Ok(None),
         }
     }
 
     /// Try to optimize the root expression node only, returning None if no optimizations applied.
-    fn try_optimize(&self, cache: &SimplifyCache<'_>) -> VortexResult<Option<Expression>> {
+    fn try_optimize(&self) -> VortexResult<Option<BoundExpression>> {
         // Copy-on-write: `current` stays None until a rule fires, so unchanged nodes (the common
         // case) are never cloned.
-        let mut current: Option<Expression> = None;
+        let mut current: Option<BoundExpression> = None;
         let mut loop_counter = 0;
 
         loop {
@@ -73,25 +56,16 @@ impl Expression {
             let expr = current.as_ref().unwrap_or(self);
             let mut changed = false;
 
-            // Try simplify_untyped
-            if let Some(simplified) = expr.simplify_untyped_node()? {
+            if let Some(simplified) = expr.simplify_node()? {
                 current = Some(simplified);
                 changed = true;
             }
 
-            // Try simplify (typed)
-            let expr = current.as_ref().unwrap_or(self);
-            if let Some(simplified) = expr.simplify_node(cache)? {
-                current = Some(simplified);
-                changed = true;
-            }
-
-            // Try reduce via ReduceNode. The node borrows the expression and scope, so
-            // constructing it is free; the block scopes the borrows so `current` can be updated.
+            // Try reduce via ReduceNode. The node borrows the expression, so constructing it is
+            // free; the block scopes the borrow so `current` can be updated.
             let reduced = {
                 let expr = current.as_ref().unwrap_or(self);
-                let reduce_node = ExpressionReduceNode::new(expr, cache.scope);
-                expr.reduce_node(&reduce_node)?
+                expr.reduce_node(&ExpressionReduceNode::new(expr))?
                     .map(ExpressionReduceNode::into_expression)
             };
             if let Some(reduced_expr) = reduced {
@@ -110,38 +84,33 @@ impl Expression {
     /// Optimize the entire expression tree recursively.
     ///
     /// Optimizes children first (bottom-up), then optimizes the root.
-    pub fn optimize_recursive(&self, scope: &DType) -> VortexResult<Expression> {
+    pub fn optimize_recursive(&self) -> VortexResult<BoundExpression> {
         Ok(self
-            .clone()
-            .try_optimize_recursive(scope)?
+            .try_optimize_recursive()?
             .unwrap_or_else(|| self.clone()))
     }
 
     /// Try to optimize the entire expression tree recursively.
-    pub fn try_optimize_recursive(&self, scope: &DType) -> VortexResult<Option<Expression>> {
-        let cache = SimplifyCache::new(scope);
-        let result = self.try_optimize_recursive_inner(&cache)?;
+    pub fn try_optimize_recursive(&self) -> VortexResult<Option<BoundExpression>> {
+        let result = self.try_optimize_recursive_inner()?;
 
         // Apply the between optimization once at the top level only.
         // TODO(ngates): remove the "between" optimization, or rewrite it to not always convert
         //  to CNF?
         Ok(Some(find_between(result.unwrap_or_else(|| self.clone()))))
     }
 
-    fn try_optimize_recursive_inner(
-        &self,
-        cache: &SimplifyCache<'_>,
-    ) -> VortexResult<Option<Expression>> {
+    fn try_optimize_recursive_inner(&self) -> VortexResult<Option<BoundExpression>> {
         // First optimize the root
-        let mut current = self.try_optimize(cache)?;
+        let mut current = self.try_optimize()?;
 
         // Then recursively optimize children. The new children vector is only allocated once a
         // child actually changes, so fully-optimized subtrees cost no allocations.
         let expr = current.as_ref().unwrap_or(self);
         let children = expr.children();
-        let mut new_children: Option<Vec<Expression>> = None;
+        let mut new_children: Option<Vec<BoundExpression>> = None;
         for (idx, child) in children.iter().enumerate() {
-            if let Some(optimized) = child.try_optimize_recursive_inner(cache)? {
+            if let Some(optimized) = child.try_optimize_recursive_inner()? {
                 new_children
                     .get_or_insert_with(|| children[..idx].to_vec())
                     .push(optimized);
@@ -154,56 +123,13 @@ impl Expression {
             let updated = expr.clone().with_children(new_children)?;
 
             // After updating children, try to optimize root again
-            current = Some(updated.try_optimize(cache)?.unwrap_or(updated));
+            current = Some(updated.try_optimize()?.unwrap_or(updated));
         }
 
         Ok(current)
     }
 }
 
-struct SimplifyCache<'a> {
-    scope: &'a DType,
-    dtype_cache: RefCell<HashMap<Expression, DType>>,
-}
-
-impl<'a> SimplifyCache<'a> {
-    fn new(scope: &'a DType) -> Self {
-        Self {
-            scope,
-            dtype_cache: RefCell::new(HashMap::new()),
-        }
-    }
-}
-
-impl SimplifyCtx for SimplifyCache<'_> {
-    fn return_dtype(&self, expr: &Expression) -> VortexResult<DType> {
-        // If the expression is "root", return the scope dtype
-        if expr.is_root() {
-            return Ok(self.scope.clone());
-        }
-
-        if let Some(dtype) = self.dtype_cache.borrow().get(expr) {
-            return Ok(dtype.clone());
-        }
-
-        // Otherwise, compute dtype from children
-        let input_dtypes: Vec<_> = expr
-            .children()
-            .iter()
-            .map(|c| self.return_dtype(c))
-            .try_collect()?;
-        let dtype = expr
-            .as_scalar()
-            .ok_or_else(|| vortex_err!("cannot type a non-scalar expression: {expr}"))?
-            .return_dtype(&input_dtypes)?;
-        self.dtype_cache
-            .borrow_mut()
-            .insert(expr.clone(), dtype.clone());
-
-        Ok(dtype)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use vortex_error::VortexResult;
@@ -236,7 +162,7 @@ mod tests {
             ),
             Nullability::NonNullable,
         );
-        let optimized = expr.optimize_recursive(&scope)?;
+        let optimized = expr.bind(&scope)?.optimize_recursive()?;
 
         let s = optimized.to_string();
         assert!(s.contains("$.x"), "expected $.x in {s}");
@@ -261,7 +187,7 @@ mod tests {
             ),
             Nullability::NonNullable,
         );
-        let optimized = expr.optimize_recursive(&scope)?;
+        let optimized = expr.bind(&scope)?.optimize_recursive()?;
 
         // Prune rules pattern-match a bare Literal on the comparison RHS; a cast wrapper
         // silently disables pruning.
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ fn build_or_chain(n: usize) -> Expression {`
`43`	`43`
`44`	`44`	`#[divan::bench(args = [200])]`
`45`	`45`	`fn optimize_or_chain(bencher: Bencher, n: usize) {`
`46`		`- let expr = build_or_chain(n);`
`47`	`46`	`let scope = struct_scope();`
`48`		`- bencher.bench(\|\| expr.optimize_recursive(&scope).unwrap());`
	`47`	`+ let expr = build_or_chain(n).bind(&scope).unwrap();`
	`48`	`+ bencher.bench(\|\| expr.optimize_recursive().unwrap());`
`49`	`49`	`}`