Use fluent style.

src/api/call_fn.rs

@@ -171,7 +171,7 @@ impl Engine {
         let mut arg_values = StaticVec::new_const();
         args.parse(&mut arg_values);
 
-        let result = self._call_fn(
+        self._call_fn(
             options,
             scope,
             &mut GlobalRuntimeState::new(self),
@@ -179,8 +179,8 @@ impl Engine {
             ast,
             name.as_ref(),
             arg_values.as_mut(),
-        )?;
+        )
-
+        .and_then(|result| {
             // Bail out early if the return type needs no cast
             if TypeId::of::<T>() == TypeId::of::<Dynamic>() {
                 return Ok(reify!(result => T));
@@ -193,6 +193,7 @@ impl Engine {
                 let t = self.map_type_name(type_name::<T>()).into();
                 ERR::ErrorMismatchOutputType(t, typ.into(), Position::NONE).into()
             })
+        })
     }
     /// Call a script function defined in an [`AST`] with multiple [`Dynamic`] arguments.
     ///

src/api/eval.rs

@@ -233,34 +233,29 @@ impl Engine {
             ast.resolver().cloned(),
         );
 
-        let statements = ast.statements();
+        auto_restore!(global => move |g| {
-
+            #[cfg(not(feature = "no_module"))]
-        if statements.is_empty() {
+            {
-            return Ok(Dynamic::UNIT);
+                g.embedded_module_resolver = orig_embedded_module_resolver;
             }
 
-        let result = self.eval_global_statements(global, caches, scope, statements);
+            #[cfg(not(feature = "no_function"))]
+            g.lib.truncate(orig_lib_len);
 
+            g.source = orig_source;
+        });
+
+        self.eval_global_statements(global, caches, scope, ast.statements())
+            .and_then(|r| {
                 #[cfg(feature = "debugging")]
                 if self.is_debugger_registered() {
                     global.debugger_mut().status = crate::eval::DebuggerStatus::Terminate;
                     let mut this = Dynamic::NULL;
                     let node = &crate::ast::Stmt::Noop(Position::NONE);
-
                     self.run_debugger(global, caches, scope, &mut this, node)?;
                 }
-
+                Ok(r)
-        #[cfg(not(feature = "no_module"))]
+            })
-        {
-            global.embedded_module_resolver = orig_embedded_module_resolver;
-        }
-
-        #[cfg(not(feature = "no_function"))]
-        global.lib.truncate(orig_lib_len);
-
-        global.source = orig_source;
-
-        result
     }
 }
 

src/api/run.rs

@@ -126,15 +126,8 @@ impl Engine {
             global.embedded_module_resolver = ast.resolver().cloned();
         }
 
-        let statements = ast.statements();
+        self.eval_global_statements(global, caches, scope, ast.statements())
-
+            .and_then(|_| {
-        let result = if !statements.is_empty() {
-            self.eval_global_statements(global, caches, scope, statements)
-                .map(|_| ())
-        } else {
-            Ok(())
-        };
-
                 #[cfg(feature = "debugging")]
                 if self.is_debugger_registered() {
                     global.debugger_mut().status = crate::eval::DebuggerStatus::Terminate;
@@ -142,8 +135,8 @@ impl Engine {
                     let node = &crate::ast::Stmt::Noop(crate::Position::NONE);
                     self.run_debugger(global, caches, scope, &mut this, node)?;
                 }
-
+                Ok(())
-        result
+            })
     }
 }
 

src/func/native.rs

@@ -303,8 +303,8 @@ impl<'a> NativeCallContext<'a> {
 
         let mut args: StaticVec<_> = arg_values.iter_mut().collect();
 
-        let result = self._call_fn_raw(fn_name, &mut args, false, false, false)?;
+        self._call_fn_raw(fn_name, &mut args, false, false, false)
-
+            .and_then(|result| {
                 // Bail out early if the return type needs no cast
                 if TypeId::of::<T>() == TypeId::of::<Dynamic>() {
                     return Ok(reify!(result => T));
@@ -316,6 +316,7 @@ impl<'a> NativeCallContext<'a> {
                     let t = self.engine().map_type_name(type_name::<T>()).into();
                     ERR::ErrorMismatchOutputType(t, typ.into(), Position::NONE).into()
                 })
+            })
     }
     /// Call a registered native Rust function inside the call context with the provided arguments.
     ///
@@ -333,8 +334,8 @@ impl<'a> NativeCallContext<'a> {
 
         let mut args: StaticVec<_> = arg_values.iter_mut().collect();
 
-        let result = self._call_fn_raw(fn_name, &mut args, true, false, false)?;
+        self._call_fn_raw(fn_name, &mut args, true, false, false)
-
+            .and_then(|result| {
                 // Bail out early if the return type needs no cast
                 if TypeId::of::<T>() == TypeId::of::<Dynamic>() {
                     return Ok(reify!(result => T));
@@ -346,6 +347,7 @@ impl<'a> NativeCallContext<'a> {
                     let t = self.engine().map_type_name(type_name::<T>()).into();
                     ERR::ErrorMismatchOutputType(t, typ.into(), Position::NONE).into()
                 })
+            })
     }
     /// Call a function (native Rust or scripted) inside the call context.
     ///

src/func/script.rs

@@ -205,12 +205,12 @@ impl Engine {
         }
 
         // First check script-defined functions
-        let result = global.lib.iter().any(|m| m.contains_fn(hash_script))
+        let r = global.lib.iter().any(|m| m.contains_fn(hash_script))
             // Then check the global namespace and packages
             || self.global_modules.iter().any(|m| m.contains_fn(hash_script));
 
         #[cfg(not(feature = "no_module"))]
-        let result = result ||
+        let r = r ||
             // Then check imported modules
             global.contains_qualified_fn(hash_script)
             // Then check sub-modules
@@ -218,11 +218,11 @@ impl Engine {
                 m.values().any(|m| m.contains_qualified_fn(hash_script))
             });
 
-        if !result && !cache.filter.is_absent_and_set(hash_script) {
+        if !r && !cache.filter.is_absent_and_set(hash_script) {
             // Do not cache "one-hit wonders"
             cache.map.insert(hash_script, None);
         }
 
-        result
+        r
     }
 }

src/types/fn_ptr.rs

@@ -158,8 +158,7 @@ impl FnPtr {
 
         let ctx = (engine, self.fn_name(), None, &*global, Position::NONE).into();
 
-        let result = self.call_raw(&ctx, None, arg_values)?;
+        self.call_raw(&ctx, None, arg_values).and_then(|result| {
-
             // Bail out early if the return type needs no cast
             if TypeId::of::<T>() == TypeId::of::<Dynamic>() {
                 return Ok(reify!(result => T));
@@ -171,6 +170,7 @@ impl FnPtr {
                 let t = engine.map_type_name(type_name::<T>()).into();
                 ERR::ErrorMismatchOutputType(t, typ.into(), Position::NONE).into()
             })
+        })
     }
     /// Call the function pointer with curried arguments (if any).
     /// The function may be script-defined (not available under `no_function`) or native Rust.
@@ -187,8 +187,7 @@ impl FnPtr {
         let mut arg_values = crate::StaticVec::new_const();
         args.parse(&mut arg_values);
 
-        let result = self.call_raw(context, None, arg_values)?;
+        self.call_raw(context, None, arg_values).and_then(|result| {
-
             // Bail out early if the return type needs no cast
             if TypeId::of::<T>() == TypeId::of::<Dynamic>() {
                 return Ok(reify!(result => T));
@@ -200,6 +199,7 @@ impl FnPtr {
                 let t = context.engine().map_type_name(type_name::<T>()).into();
                 ERR::ErrorMismatchOutputType(t, typ.into(), Position::NONE).into()
             })
+        })
     }
     /// Call the function pointer with curried arguments (if any).
     /// The function may be script-defined (not available under `no_function`) or native Rust.