Add From<Vec<T>> and From<HashMap<String, T>> for Dynamic.

README.md

@@ -535,6 +535,16 @@ match item.type_name() {                        // 'type_name' returns the name
 }
 ```
 
+The following conversion traits are implemented for `Dynamic`:
+
+* `From<i64>` (`i32` if [`only_i32`])
+* `From<f64>` (if not [`no_float`])
+* `From<bool>`
+* `From<String>`
+* `From<char>`
+* `From<Vec<T>>` (into an [array])
+* `From<HashMap<String, T>>` (into an [object map]).
+
 Value conversions
 -----------------
 
@@ -684,7 +694,7 @@ fn main()
     engine.register_result_fn("divide", safe_divide);
 
     if let Err(error) = engine.eval::<i64>("divide(40, 0)") {
-       println!("Error: {:?}", *error);          // prints ErrorRuntime("Division by zero detected!", (1, 1)")
+       println!("Error: {:?}", *error);         // prints ErrorRuntime("Division by zero detected!", (1, 1)")
     }
 }
 ```
@@ -1430,6 +1440,7 @@ engine.register_fn("push", |list: &mut Array, item: MyType| list.push(Box::new(i
 Object maps
 -----------
 
+[`Map`]: #object-maps
 [object map]: #object-maps
 [object maps]: #object-maps
 
@@ -1630,13 +1641,13 @@ ts == 42;               // false - types are not the same
 Boolean operators
 -----------------
 
-| Operator | Description                     |
+| Operator | Description                           |
-| -------- | ------------------------------- |
+| -------- | ------------------------------------- |
-| `!`      | Boolean _Not_                   |
+| `!`      | Boolean _Not_                         |
-| `&&`     | Boolean _And_ (short-circuits)  |
+| `&&`     | Boolean _And_ (short-circuits)        |
-| `\|\|`   | Boolean _Or_ (short-circuits)   |
+| `\|\|`   | Boolean _Or_ (short-circuits)         |
-| `&`      | Boolean _And_ (full evaluation) |
+| `&`      | Boolean _And_ (doesn't short-circuit) |
-| `\|`     | Boolean _Or_ (full evaluation)  |
+| `\|`     | Boolean _Or_ (doesn't short-circuit)  |
 
 Double boolean operators `&&` and `||` _short-circuit_, meaning that the second operand will not be evaluated
 if the first one already proves the condition wrong.

src/any.rs

@@ -9,6 +9,7 @@ use crate::parser::FLOAT;
 use crate::stdlib::{
     any::{type_name, Any, TypeId},
     boxed::Box,
+    collections::HashMap,
     fmt,
     string::String,
 };
@@ -65,6 +66,9 @@ impl<T: Any + Clone> Variant for T {
 }
 
 /// A trait to represent any type.
+///
+/// `From<_>` is implemented for `i64` (`i32` if `only_i32`), `f64` (if not `no_float`),
+/// `bool`, `String`, `char`, `Vec<T>` (into `Array`) and `HashMap<String, T>` (into `Map`).
 #[cfg(feature = "sync")]
 pub trait Variant: Any + Send + Sync {
     /// Convert this `Variant` trait object to `&dyn Any`.
@@ -525,6 +529,23 @@ impl From<String> for Dynamic {
         Self(Union::Str(Box::new(value)))
     }
 }
+impl<T: Variant + Clone> From<Vec<T>> for Dynamic {
+    fn from(value: Vec<T>) -> Self {
+        Self(Union::Array(Box::new(
+            value.into_iter().map(Dynamic::from).collect(),
+        )))
+    }
+}
+impl<T: Variant + Clone> From<HashMap<String, T>> for Dynamic {
+    fn from(value: HashMap<String, T>) -> Self {
+        Self(Union::Map(Box::new(
+            value
+                .into_iter()
+                .map(|(k, v)| (k, Dynamic::from(v)))
+                .collect(),
+        )))
+    }
+}
 
 /// Private type which ensures that `rhai::Any` and `rhai::AnyExt` can only
 /// be implemented by this crate.