diff --git a/optd-core/src/expression.rs b/optd-core/src/expression.rs
index 961bee9..bdd89c0 100644
--- a/optd-core/src/expression.rs
+++ b/optd-core/src/expression.rs
@@ -3,22 +3,15 @@
 use crate::memo::GroupId;
 use crate::operator::relational::logical::LogicalOperator;
 use crate::operator::relational::physical::PhysicalOperator;
-use crate::operator::scalar::ScalarOperator;
 
 /// A logical expression in the memo table.
 ///
 /// References children using [`GroupId`]s for expression sharing
 /// and memoization.
-pub enum LogicalExpression {
-    Relational(LogicalOperator<GroupId, GroupId>),
-    Scalar(ScalarOperator<GroupId>),
-}
+pub type LogicalExpression = LogicalOperator<GroupId, GroupId>;
 
 /// A physical expression in the memo table.
 ///
 /// Like [`LogicalExpression`] but with specific implementation
 /// strategies.
-pub enum PhysicalExpression {
-    Relational(PhysicalOperator<GroupId, GroupId>),
-    Scalar(ScalarOperator<GroupId>),
-}
+pub type PhysicalExpression = PhysicalOperator<GroupId, GroupId>;
diff --git a/optd-core/src/rules/implementation/hash_join.rs b/optd-core/src/rules/implementation/hash_join.rs
index 3e060a5..fb747fc 100644
--- a/optd-core/src/rules/implementation/hash_join.rs
+++ b/optd-core/src/rules/implementation/hash_join.rs
@@ -11,15 +11,13 @@ pub struct HashJoinRule;
 // https://github.com/cmu-db/optd/issues/15
 impl ImplementationRule for HashJoinRule {
     fn check_and_apply(&self, expr: LogicalExpression) -> Option<PhysicalExpression> {
-        if let LogicalExpression::Relational(LogicalOperator::Join(join)) = expr {
-            return Some(PhysicalExpression::Relational(PhysicalOperator::HashJoin(
-                HashJoin {
-                    join_type: join.join_type,
-                    probe_side: join.left,
-                    build_side: join.right,
-                    condition: join.condition,
-                },
-            )));
+        if let LogicalOperator::Join(join) = expr {
+            return Some(PhysicalOperator::HashJoin(HashJoin {
+                join_type: join.join_type,
+                probe_side: join.left,
+                build_side: join.right,
+                condition: join.condition,
+            }));
         }
         None
     }
diff --git a/optd-core/src/rules/implementation/physical_filter.rs b/optd-core/src/rules/implementation/physical_filter.rs
index cd8f6f3..8c06072 100644
--- a/optd-core/src/rules/implementation/physical_filter.rs
+++ b/optd-core/src/rules/implementation/physical_filter.rs
@@ -9,13 +9,11 @@ pub struct PhysicalFilterRule;
 
 impl ImplementationRule for PhysicalFilterRule {
     fn check_and_apply(&self, expr: LogicalExpression) -> Option<PhysicalExpression> {
-        if let LogicalExpression::Relational(LogicalOperator::Filter(filter)) = expr {
-            return Some(PhysicalExpression::Relational(PhysicalOperator::Filter(
-                Filter {
-                    child: filter.child,
-                    predicate: filter.predicate,
-                },
-            )));
+        if let LogicalOperator::Filter(filter) = expr {
+            return Some(PhysicalOperator::Filter(Filter {
+                child: filter.child,
+                predicate: filter.predicate,
+            }));
         }
 
         None
diff --git a/optd-core/src/rules/implementation/table_scan.rs b/optd-core/src/rules/implementation/table_scan.rs
index 91c5cce..375d9ae 100644
--- a/optd-core/src/rules/implementation/table_scan.rs
+++ b/optd-core/src/rules/implementation/table_scan.rs
@@ -10,13 +10,11 @@ pub struct TableScanRule;
 
 impl ImplementationRule for TableScanRule {
     fn check_and_apply(&self, expr: LogicalExpression) -> Option<PhysicalExpression> {
-        if let LogicalExpression::Relational(LogicalOperator::Scan(scan)) = expr {
-            return Some(PhysicalExpression::Relational(PhysicalOperator::TableScan(
-                TableScan {
-                    table_name: scan.table_name,
-                    predicate: scan.predicate,
-                },
-            )));
+        if let LogicalOperator::Scan(scan) = expr {
+            return Some(PhysicalOperator::TableScan(TableScan {
+                table_name: scan.table_name,
+                predicate: scan.predicate,
+            }));
         }
 
         None