diff --git a/src/lib.rs b/src/lib.rs
index 7f7511ad..d5369e6d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -367,6 +367,12 @@ pub trait MatchEngineFactory {
     }
 }
 
+impl MatchEngineFactory for Box<dyn MatchEngineFactory> {
+    fn create_engine_with_case(&self, query: &str, case: CaseMatching) -> Box<dyn MatchEngine> {
+        (**self).create_engine_with_case(query, case)
+    }
+}
+
 //------------------------------------------------------------------------------
 // Preselection
 
diff --git a/src/matcher.rs b/src/matcher.rs
index c754c2a8..b3dfa41f 100644
--- a/src/matcher.rs
+++ b/src/matcher.rs
@@ -139,21 +139,22 @@ impl Matcher {
                 .rank_builder(rank_builder.clone())
                 .build();
 
+            let mut factory: Box<dyn MatchEngineFactory> = Box::new(fuzzy_engine_factory);
+
             // If split_match is enabled, wrap the fuzzy factory with SplitMatchEngineFactory
-            // Then wrap with AndOrEngineFactory so that queries like "foo:bar baz:qux" work
-            let andor_factory = if let Some(delimiter) = options.split_match {
-                let split_factory = SplitMatchEngineFactory::new(fuzzy_engine_factory, delimiter);
-                AndOrEngineFactory::new(split_factory)
-            } else {
-                AndOrEngineFactory::new(fuzzy_engine_factory)
-            };
+            if let Some(delimiter) = options.split_match {
+                factory = Box::new(SplitMatchEngineFactory::new(factory, delimiter));
+            }
+
+            // Wrap with AndOrEngineFactory so that queries like "foo:bar baz:qux" work
+            factory = Box::new(AndOrEngineFactory::new(factory));
 
             // Wrap with NormalizedEngineFactory if normalization is requested
-            let factory: Rc<dyn MatchEngineFactory> = if options.normalize {
-                Rc::new(NormalizedEngineFactory::new(andor_factory))
-            } else {
-                Rc::new(andor_factory)
-            };
+            if options.normalize {
+                factory = Box::new(NormalizedEngineFactory::new(factory));
+            }
+
+            let factory: Rc<dyn MatchEngineFactory> = Rc::new(factory);
             (factory, rank_builder)
         }
     }