Reduce nesting in plugin sub-modules.

src/packages/fn_basic.rs

@@ -15,20 +15,16 @@ mod fn_ptr_functions {
     }
 
     #[cfg(not(feature = "no_function"))]
-    pub mod functions {
-        #[rhai_fn(name = "is_anonymous", get = "is_anonymous", pure)]
-        pub fn is_anonymous(fn_ptr: &mut FnPtr) -> bool {
-            fn_ptr.is_anonymous()
-        }
+    #[rhai_fn(name = "is_anonymous", get = "is_anonymous", pure)]
+    pub fn is_anonymous(fn_ptr: &mut FnPtr) -> bool {
+        fn_ptr.is_anonymous()
     }
 
     #[cfg(not(feature = "no_function"))]
     #[cfg(not(feature = "no_index"))]
     #[cfg(not(feature = "no_object"))]
-    pub mod functions_and_maps {
-        pub fn get_fn_metadata_list(ctx: NativeCallContext) -> crate::Array {
-            collect_fn_metadata(ctx)
-        }
+    pub fn get_fn_metadata_list(ctx: NativeCallContext) -> crate::Array {
+        collect_fn_metadata(ctx)
     }
 }
 

src/packages/map_basic.rs

@@ -108,22 +108,21 @@ mod map_functions {
     }
 
     #[cfg(not(feature = "no_index"))]
-    pub mod indexing {
-        #[rhai_fn(pure)]
-        pub fn keys(map: &mut Map) -> Array {
-            if map.is_empty() {
-                Array::new()
-            } else {
-                map.keys().cloned().map(Into::<Dynamic>::into).collect()
-            }
+    #[rhai_fn(pure)]
+    pub fn keys(map: &mut Map) -> Array {
+        if map.is_empty() {
+            Array::new()
+        } else {
+            map.keys().cloned().map(Into::<Dynamic>::into).collect()
         }
-        #[rhai_fn(pure)]
-        pub fn values(map: &mut Map) -> Array {
-            if map.is_empty() {
-                Array::new()
-            } else {
-                map.values().cloned().collect()
-            }
+    }
+    #[cfg(not(feature = "no_index"))]
+    #[rhai_fn(pure)]
+    pub fn values(map: &mut Map) -> Array {
+        if map.is_empty() {
+            Array::new()
+        } else {
+            map.values().cloned().collect()
         }
     }
 }

src/packages/math_basic.rs

@@ -293,11 +293,9 @@ mod float_functions {
         })
     }
     #[cfg(not(feature = "f32_float"))]
-    pub mod f32_f64 {
-        #[rhai_fn(name = "to_float")]
-        pub fn f32_to_f64(x: f32) -> f64 {
-            x as f64
-        }
+    #[rhai_fn(name = "to_float")]
+    pub fn f32_to_f64(x: f32) -> f64 {
+        x as f64
     }
 }
 
@@ -308,21 +306,23 @@ mod decimal_functions {
         prelude::{FromStr, RoundingStrategy},
         Decimal, MathematicalOps,
     };
+    #[cfg(not(feature = "no_float"))]
+    use std::convert::TryFrom;
 
     #[cfg(feature = "no_float")]
-    pub mod float_polyfills {
-        #[rhai_fn(name = "PI")]
-        pub fn pi() -> Decimal {
-            Decimal::PI
-        }
-        #[rhai_fn(name = "E")]
-        pub fn e() -> Decimal {
-            Decimal::E
-        }
-        #[rhai_fn(return_raw)]
-        pub fn parse_float(s: &str) -> Result<Decimal, Box<EvalAltResult>> {
-            super::parse_decimal(s)
-        }
+    #[rhai_fn(name = "PI")]
+    pub fn pi() -> Decimal {
+        Decimal::PI
+    }
+    #[cfg(feature = "no_float")]
+    #[rhai_fn(name = "E")]
+    pub fn e() -> Decimal {
+        Decimal::E
+    }
+    #[cfg(feature = "no_float")]
+    #[rhai_fn(return_raw)]
+    pub fn parse_float(s: &str) -> Result<Decimal, Box<EvalAltResult>> {
+        super::parse_decimal(s)
     }
 
     pub fn sin(x: Decimal) -> Decimal {
@@ -480,39 +480,37 @@ mod decimal_functions {
     }
 
     #[cfg(not(feature = "no_float"))]
-    pub mod float {
-        use std::convert::TryFrom;
-
-        #[rhai_fn(name = "to_decimal", return_raw)]
-        pub fn f32_to_decimal(x: f32) -> Result<Decimal, Box<EvalAltResult>> {
-            Decimal::try_from(x).map_err(|_| {
-                EvalAltResult::ErrorArithmetic(
-                    format!("Cannot convert to Decimal: to_decimal({})", x),
-                    Position::NONE,
-                )
-                .into()
-            })
-        }
-        #[rhai_fn(name = "to_decimal", return_raw)]
-        pub fn f64_to_decimal(x: f64) -> Result<Decimal, Box<EvalAltResult>> {
-            Decimal::try_from(x).map_err(|_| {
-                EvalAltResult::ErrorArithmetic(
-                    format!("Cannot convert to Decimal: to_decimal({})", x),
-                    Position::NONE,
-                )
-                .into()
-            })
-        }
-        #[rhai_fn(return_raw)]
-        pub fn to_float(x: Decimal) -> Result<FLOAT, Box<EvalAltResult>> {
-            FLOAT::try_from(x).map_err(|_| {
-                EvalAltResult::ErrorArithmetic(
-                    format!("Cannot convert to floating-point: to_float({})", x),
-                    Position::NONE,
-                )
-                .into()
-            })
-        }
+    #[rhai_fn(name = "to_decimal", return_raw)]
+    pub fn f32_to_decimal(x: f32) -> Result<Decimal, Box<EvalAltResult>> {
+        Decimal::try_from(x).map_err(|_| {
+            EvalAltResult::ErrorArithmetic(
+                format!("Cannot convert to Decimal: to_decimal({})", x),
+                Position::NONE,
+            )
+            .into()
+        })
+    }
+    #[cfg(not(feature = "no_float"))]
+    #[rhai_fn(name = "to_decimal", return_raw)]
+    pub fn f64_to_decimal(x: f64) -> Result<Decimal, Box<EvalAltResult>> {
+        Decimal::try_from(x).map_err(|_| {
+            EvalAltResult::ErrorArithmetic(
+                format!("Cannot convert to Decimal: to_decimal({})", x),
+                Position::NONE,
+            )
+            .into()
+        })
+    }
+    #[cfg(not(feature = "no_float"))]
+    #[rhai_fn(return_raw)]
+    pub fn to_float(x: Decimal) -> Result<FLOAT, Box<EvalAltResult>> {
+        FLOAT::try_from(x).map_err(|_| {
+            EvalAltResult::ErrorArithmetic(
+                format!("Cannot convert to floating-point: to_float({})", x),
+                Position::NONE,
+            )
+            .into()
+        })
     }
 }
 

src/packages/string_basic.rs

@@ -71,82 +71,73 @@ mod print_debug_functions {
     }
 
     #[cfg(not(feature = "no_float"))]
-    pub mod float_functions {
-        use crate::ast::FloatWrapper;
-
-        #[rhai_fn(name = "print", name = "to_string")]
-        pub fn print_f64(number: f64) -> ImmutableString {
-            FloatWrapper::new(number).to_string().into()
-        }
-        #[rhai_fn(name = "print", name = "to_string")]
-        pub fn print_f32(number: f32) -> ImmutableString {
-            FloatWrapper::new(number).to_string().into()
-        }
-        #[rhai_fn(name = "debug", name = "to_debug")]
-        pub fn debug_f64(number: f64) -> ImmutableString {
-            format!("{:?}", FloatWrapper::new(number)).into()
-        }
-        #[rhai_fn(name = "debug", name = "to_debug")]
-        pub fn debug_f32(number: f32) -> ImmutableString {
-            format!("{:?}", FloatWrapper::new(number)).into()
-        }
+    #[rhai_fn(name = "print", name = "to_string")]
+    pub fn print_f64(number: f64) -> ImmutableString {
+        crate::ast::FloatWrapper::new(number).to_string().into()
+    }
+    #[cfg(not(feature = "no_float"))]
+    #[rhai_fn(name = "print", name = "to_string")]
+    pub fn print_f32(number: f32) -> ImmutableString {
+        crate::ast::FloatWrapper::new(number).to_string().into()
+    }
+    #[cfg(not(feature = "no_float"))]
+    #[rhai_fn(name = "debug", name = "to_debug")]
+    pub fn debug_f64(number: f64) -> ImmutableString {
+        format!("{:?}", crate::ast::FloatWrapper::new(number)).into()
+    }
+    #[cfg(not(feature = "no_float"))]
+    #[rhai_fn(name = "debug", name = "to_debug")]
+    pub fn debug_f32(number: f32) -> ImmutableString {
+        format!("{:?}", crate::ast::FloatWrapper::new(number)).into()
     }
 
     #[cfg(not(feature = "no_index"))]
-    pub mod array_functions {
-        use super::*;
+    #[rhai_fn(
+        name = "print",
+        name = "to_string",
+        name = "debug",
+        name = "to_debug",
+        pure
+    )]
+    pub fn format_array(ctx: NativeCallContext, array: &mut Array) -> ImmutableString {
+        let len = array.len();
+        let mut result = String::with_capacity(len * 5 + 2);
+        result.push('[');
 
-        #[rhai_fn(
-            name = "print",
-            name = "to_string",
-            name = "debug",
-            name = "to_debug",
-            pure
-        )]
-        pub fn format_array(ctx: NativeCallContext, array: &mut Array) -> ImmutableString {
-            let len = array.len();
-            let mut result = String::with_capacity(len * 5 + 2);
-            result.push('[');
+        array.iter_mut().enumerate().for_each(|(i, x)| {
+            result.push_str(&print_with_func(FUNC_TO_DEBUG, &ctx, x));
+            if i < len - 1 {
+                result.push_str(", ");
+            }
+        });
 
-            array.iter_mut().enumerate().for_each(|(i, x)| {
-                result.push_str(&print_with_func(FUNC_TO_DEBUG, &ctx, x));
-                if i < len - 1 {
-                    result.push_str(", ");
-                }
-            });
-
-            result.push(']');
-            result.into()
-        }
+        result.push(']');
+        result.into()
     }
     #[cfg(not(feature = "no_object"))]
-    pub mod map_functions {
-        use super::*;
+    #[rhai_fn(
+        name = "print",
+        name = "to_string",
+        name = "debug",
+        name = "to_debug",
+        pure
+    )]
+    pub fn format_map(ctx: NativeCallContext, map: &mut Map) -> ImmutableString {
+        let len = map.len();
+        let mut result = String::with_capacity(len * 5 + 3);
+        result.push_str("#{");
 
-        #[rhai_fn(
-            name = "print",
-            name = "to_string",
-            name = "debug",
-            name = "to_debug",
-            pure
-        )]
-        pub fn format_map(ctx: NativeCallContext, map: &mut Map) -> ImmutableString {
-            let len = map.len();
-            let mut result = String::with_capacity(len * 5 + 3);
-            result.push_str("#{");
+        map.iter_mut().enumerate().for_each(|(i, (k, v))| {
+            result.push_str(&format!(
+                "{:?}: {}{}",
+                k,
+                &print_with_func(FUNC_TO_DEBUG, &ctx, v),
+                if i < len - 1 { ", " } else { "" }
+            ));
+        });
 
-            map.iter_mut().enumerate().for_each(|(i, (k, v))| {
-                result.push_str(&format!(
-                    "{:?}: {}{}",
-                    k,
-                    &print_with_func(FUNC_TO_DEBUG, &ctx, v),
-                    if i < len - 1 { ", " } else { "" }
-                ));
-            });
-
-            result.push('}');
-            result.into()
-        }
+        result.push('}');
+        result.into()
     }
 }