Refine code and docs.

src/fn_native.rs

@@ -115,8 +115,8 @@ pub struct FnPtr(ImmutableString, StaticVec<Dynamic>);
 impl FnPtr {
     /// Create a new function pointer.
     #[inline(always)]
-    pub(crate) fn new_unchecked<S: Into<ImmutableString>>(
-        name: S,
+    pub(crate) fn new_unchecked(
+        name: impl Into<ImmutableString>,
         curry: StaticVec<Dynamic>,
     ) -> Self {
         Self(name.into(), curry)
@@ -147,7 +147,6 @@ impl FnPtr {
     pub fn is_anonymous(&self) -> bool {
         self.0.starts_with(FN_ANONYMOUS)
     }
-
     /// Call the function pointer with curried arguments (if any).
     ///
     /// If this function is a script-defined function, it must not be marked private.

src/fn_register.rs

@@ -144,7 +144,7 @@ macro_rules! make_func {
 
 /// To Dynamic mapping function.
 #[inline(always)]
-pub fn map_dynamic<T: Variant + Clone>(data: T) -> Result<Dynamic, Box<EvalAltResult>> {
+pub fn map_dynamic(data: impl Variant + Clone) -> Result<Dynamic, Box<EvalAltResult>> {
     Ok(data.into_dynamic())
 }
 

src/module/resolvers/stat.rs

@@ -48,7 +48,7 @@ impl StaticModuleResolver {
     }
     /// Add a module keyed by its path.
     #[inline(always)]
-    pub fn insert<S: Into<String>>(&mut self, path: S, module: Module) {
+    pub fn insert(&mut self, path: impl Into<String>, module: Module) {
         self.0.insert(path.into(), module);
     }
     /// Remove a module given its path.

src/scope.rs

@@ -168,10 +168,10 @@ impl<'a> Scope<'a> {
     /// assert_eq!(my_scope.get_value::<i64>("x").unwrap(), 42);
     /// ```
     #[inline(always)]
-    pub fn push<K: Into<Cow<'a, str>>, T: Variant + Clone>(
+    pub fn push(
         &mut self,
-        name: K,
-        value: T,
+        name: impl Into<Cow<'a, str>>,
+        value: impl Variant + Clone,
     ) -> &mut Self {
         self.push_dynamic_value(name, EntryType::Normal, Dynamic::from(value))
     }
@@ -189,7 +189,7 @@ impl<'a> Scope<'a> {
     /// assert_eq!(my_scope.get_value::<i64>("x").unwrap(), 42);
     /// ```
     #[inline(always)]
-    pub fn push_dynamic<K: Into<Cow<'a, str>>>(&mut self, name: K, value: Dynamic) -> &mut Self {
+    pub fn push_dynamic(&mut self, name: impl Into<Cow<'a, str>>, value: Dynamic) -> &mut Self {
         self.push_dynamic_value(name, EntryType::Normal, value)
     }
 
@@ -212,10 +212,10 @@ impl<'a> Scope<'a> {
     /// assert_eq!(my_scope.get_value::<i64>("x").unwrap(), 42);
     /// ```
     #[inline(always)]
-    pub fn push_constant<K: Into<Cow<'a, str>>, T: Variant + Clone>(
+    pub fn push_constant(
         &mut self,
-        name: K,
-        value: T,
+        name: impl Into<Cow<'a, str>>,
+        value: impl Variant + Clone,
     ) -> &mut Self {
         self.push_dynamic_value(name, EntryType::Constant, Dynamic::from(value))
     }
@@ -240,9 +240,9 @@ impl<'a> Scope<'a> {
     /// assert_eq!(my_scope.get_value::<i64>("x").unwrap(), 42);
     /// ```
     #[inline(always)]
-    pub fn push_constant_dynamic<K: Into<Cow<'a, str>>>(
+    pub fn push_constant_dynamic(
         &mut self,
-        name: K,
+        name: impl Into<Cow<'a, str>>,
         value: Dynamic,
     ) -> &mut Self {
         self.push_dynamic_value(name, EntryType::Constant, value)
@@ -250,9 +250,9 @@ impl<'a> Scope<'a> {
 
     /// Add (push) a new entry with a `Dynamic` value to the Scope.
     #[inline]
-    pub(crate) fn push_dynamic_value<K: Into<Cow<'a, str>>>(
+    pub(crate) fn push_dynamic_value(
         &mut self,
-        name: K,
+        name: impl Into<Cow<'a, str>>,
         entry_type: EntryType,
         value: Dynamic,
     ) -> &mut Self {
@@ -377,7 +377,7 @@ impl<'a> Scope<'a> {
     /// assert_eq!(my_scope.get_value::<i64>("x").unwrap(), 0);
     /// ```
     #[inline(always)]
-    pub fn set_value<T: Variant + Clone>(&mut self, name: &'a str, value: T) -> &mut Self {
+    pub fn set_value(&mut self, name: &'a str, value: impl Variant + Clone) -> &mut Self {
         match self.get_index(name) {
             None => {
                 self.push(name, value);

src/serde_impl/de.rs

@@ -452,28 +452,19 @@ impl<'de> Deserializer<'de> for &mut DynamicDeserializer<'de> {
 }
 
 /// `SeqAccess` implementation for arrays.
-struct IterateArray<'a, ITER>
-where
-    ITER: Iterator<Item = &'a Dynamic>,
-{
+struct IterateArray<'a, ITER: Iterator<Item = &'a Dynamic>> {
     /// Iterator for a stream of `Dynamic` values.
     iter: ITER,
 }
 
 #[cfg(not(feature = "no_index"))]
-impl<'a, ITER> IterateArray<'a, ITER>
-where
-    ITER: Iterator<Item = &'a Dynamic>,
-{
+impl<'a, ITER: Iterator<Item = &'a Dynamic>> IterateArray<'a, ITER> {
     pub fn new(iter: ITER) -> Self {
         Self { iter }
     }
 }
 
-impl<'a: 'de, 'de, ITER> SeqAccess<'de> for IterateArray<'a, ITER>
-where
-    ITER: Iterator<Item = &'a Dynamic>,
-{
+impl<'a: 'de, 'de, ITER: Iterator<Item = &'a Dynamic>> SeqAccess<'de> for IterateArray<'a, ITER> {
     type Error = Box<EvalAltResult>;
 
     fn next_element_seed<T: DeserializeSeed<'de>>(
@@ -555,10 +546,10 @@ impl<'t, 'de> EnumAccess<'de> for EnumDeserializer<'t, 'de> {
     type Error = Box<EvalAltResult>;
     type Variant = Self;
 
-    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
-    where
-        V: DeserializeSeed<'de>,
-    {
+    fn variant_seed<V: DeserializeSeed<'de>>(
+        self,
+        seed: V,
+    ) -> Result<(V::Value, Self::Variant), Self::Error> {
         seed.deserialize(self.tag.into_deserializer())
             .map(|v| (v, self))
     }
@@ -572,28 +563,26 @@ impl<'t, 'de> VariantAccess<'de> for EnumDeserializer<'t, 'de> {
         Deserialize::deserialize(&mut self.content)
     }
 
-    fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
+    fn newtype_variant_seed<T: DeserializeSeed<'de>>(
+        mut self,
+        seed: T,
+    ) -> Result<T::Value, Self::Error> {
         seed.deserialize(&mut self.content)
     }
 
-    fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
+    fn tuple_variant<V: Visitor<'de>>(
+        mut self,
+        len: usize,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error> {
         self.content.deserialize_tuple(len, visitor)
     }
 
-    fn struct_variant<V>(
+    fn struct_variant<V: Visitor<'de>>(
         mut self,
         fields: &'static [&'static str],
         visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
+    ) -> Result<V::Value, Self::Error> {
         self.content.deserialize_struct("", fields, visitor)
     }
 }