Allow closures in parse expressions.

CHANGELOG.md

@@ -9,6 +9,7 @@ Bug fixes
 
 * Integer numbers that are too large to deserialize into `INT` now fall back to `Decimal` or `FLOAT` instead of silently truncating.
 * Parsing deeply-nested closures (e.g. `||{||{||{||{||{||{||{...}}}}}}}`) no longer panics but will be confined to the nesting limit.
+* Closures containing a single expression are now allowed in `Engine::eval_expression` etc.
 
 Breaking API changes
 --------------------

src/parser.rs

@@ -3845,8 +3845,6 @@ impl Engine {
         let mut functions = StraightHashMap::default();
 
         let options = self.options & !LangOptions::STMT_EXPR & !LangOptions::LOOP_EXPR;
-        #[cfg(not(feature = "no_function"))]
-        let options = options & !LangOptions::ANON_FN;
 
         let mut settings = ParseSettings {
             level: 0,
@@ -3861,6 +3859,7 @@ impl Engine {
 
         let expr = self.parse_expr(&mut input, state, &mut functions, settings)?;
 
+        #[cfg(feature = "no_function")]
         assert!(functions.is_empty());
 
         match input.peek().expect(NEVER_ENDS) {
@@ -3877,7 +3876,7 @@ impl Engine {
             state.scope,
             statements,
             #[cfg(not(feature = "no_function"))]
-            StaticVec::new_const(),
+            functions.into_iter().map(|(.., v)| v).collect(),
             _optimization_level,
         ));
 
@@ -3885,7 +3884,7 @@ impl Engine {
         return Ok(AST::new(
             statements,
             #[cfg(not(feature = "no_function"))]
-            crate::Module::new(),
+            functions.into_iter().map(|(.., v)| v).collect(),
         ));
     }
 

tests/expressions.rs

@@ -16,6 +16,24 @@ fn test_expressions() -> Result<(), Box<EvalAltResult>> {
         engine.eval_expression_with_scope::<INT>(&mut scope, "if x > 0 { 42 } else { 123 }")?,
         42
     );
+    #[cfg(not(feature = "no_index"))]
+    #[cfg(not(feature = "no_object"))]
+    #[cfg(not(feature = "no_function"))]
+    {
+        assert_eq!(
+            engine.eval_expression_with_scope::<INT>(
+                &mut scope,
+                "[1, 2, 3, 4].map(|x| x * x).reduce(|a, v| a + v, 0)"
+            )?,
+            30
+        );
+        assert!(engine
+            .eval_expression_with_scope::<INT>(
+                &mut scope,
+                "[1, 2, 3, 4].map(|x| { let r = 2; x * r }).reduce(|a, v| a + v, 0)"
+            )
+            .is_err());
+    }
     assert!(engine
         .eval_expression_with_scope::<INT>(&mut scope, "if x > 0 { let y = 42; y } else { 123 }")
         .is_err());