From a64b01692bc802cfb6a3b6694767a63988fd354d Mon Sep 17 00:00:00 2001
From: Stephen Chung <Stephen.Chung@intexact.com>
Date: Sun, 1 Mar 2020 19:26:57 +0800
Subject: [PATCH] Use impl Fn style.

---
 src/builtin.rs |  3 +--
 src/engine.rs  | 40 ++++++++++++++++++----------------------
 2 files changed, 19 insertions(+), 24 deletions(-)

diff --git a/src/builtin.rs b/src/builtin.rs
index 5157eaca..0a6f0cfd 100644
--- a/src/builtin.rs
+++ b/src/builtin.rs
@@ -1,6 +1,6 @@
 use crate::{any::Any, Array, Dynamic, Engine, RegisterDynamicFn, RegisterFn};
 use std::fmt::{Debug, Display};
-use std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Rem, Shl, Shr, Sub};
+use std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Range, Rem, Shl, Shr, Sub};
 
 macro_rules! reg_op {
     ($self:expr, $x:expr, $op:expr, $( $y:ty ),*) => (
@@ -297,7 +297,6 @@ impl Engine {
         });
 
         // Register range function
-        use std::ops::Range;
         self.register_iterator::<Range<i64>, _>(|a| {
             Box::new(
                 a.downcast_ref::<Range<i64>>()
diff --git a/src/engine.rs b/src/engine.rs
index 38849e7e..108553ee 100644
--- a/src/engine.rs
+++ b/src/engine.rs
@@ -307,39 +307,38 @@ impl Engine {
     /// Register an iterator adapter for a type.
     pub fn register_iterator<T: Any, F>(&mut self, f: F)
     where
-        F: 'static + Fn(&Dynamic) -> Box<dyn Iterator<Item = Dynamic>>,
+        F: Fn(&Dynamic) -> Box<dyn Iterator<Item = Dynamic>> + 'static,
     {
         self.type_iterators.insert(TypeId::of::<T>(), Arc::new(f));
     }
 
     /// Register a get function for a member of a registered type
-    pub fn register_get<T: Any + Clone, U: Any + Clone, F>(&mut self, name: &str, get_fn: F)
-    where
-        F: 'static + Fn(&mut T) -> U,
-    {
+    pub fn register_get<T: Any + Clone, U: Any + Clone>(
+        &mut self,
+        name: &str,
+        get_fn: impl Fn(&mut T) -> U + 'static,
+    ) {
         let get_name = "get$".to_string() + name;
         self.register_fn(&get_name, get_fn);
     }
 
     /// Register a set function for a member of a registered type
-    pub fn register_set<T: Any + Clone, U: Any + Clone, F>(&mut self, name: &str, set_fn: F)
-    where
-        F: 'static + Fn(&mut T, U) -> (),
-    {
+    pub fn register_set<T: Any + Clone, U: Any + Clone>(
+        &mut self,
+        name: &str,
+        set_fn: impl Fn(&mut T, U) -> () + 'static,
+    ) {
         let set_name = "set$".to_string() + name;
         self.register_fn(&set_name, set_fn);
     }
 
     /// Shorthand for registering both getters and setters
-    pub fn register_get_set<T: Any + Clone, U: Any + Clone, F, G>(
+    pub fn register_get_set<T: Any + Clone, U: Any + Clone>(
         &mut self,
         name: &str,
-        get_fn: F,
-        set_fn: G,
-    ) where
-        F: 'static + Fn(&mut T) -> U,
-        G: 'static + Fn(&mut T, U) -> (),
-    {
+        get_fn: impl Fn(&mut T) -> U + 'static,
+        set_fn: impl Fn(&mut T, U) -> () + 'static,
+    ) {
         self.register_get(name, get_fn);
         self.register_set(name, set_fn);
     }
@@ -432,14 +431,11 @@ impl Engine {
         }
     }
 
-    fn search_scope<'a, F, T>(
+    fn search_scope<'a, T>(
         scope: &'a mut Scope,
         id: &str,
-        map: F,
-    ) -> Result<(usize, T), EvalAltResult>
-    where
-        F: FnOnce(&'a mut Variant) -> Result<T, EvalAltResult>,
-    {
+        map: impl FnOnce(&'a mut Variant) -> Result<T, EvalAltResult>,
+    ) -> Result<(usize, T), EvalAltResult> {
         scope
             .iter_mut()
             .enumerate()