pub struct Dynamic(/* private fields */);
Expand description
Dynamic type containing any value.
Implementations§
source§impl Dynamic
impl Dynamic
sourcepub fn as_string(self) -> Result<String, &'static str>
👎Deprecated since 1.1.0: use into_string
instead
pub fn as_string(self) -> Result<String, &'static str>
into_string
insteadConvert the Dynamic
into a String
and return it.
If there are other references to the same string, a cloned copy is returned.
Returns the name of the actual type if the cast fails.
§Deprecated
This method is deprecated.
Use into_string
instead.
This method will be removed in the next major version.
sourcepub fn as_immutable_string(self) -> Result<ImmutableString, &'static str>
👎Deprecated since 1.1.0: use into_immutable_string
instead
pub fn as_immutable_string(self) -> Result<ImmutableString, &'static str>
into_immutable_string
insteadConvert the Dynamic
into an ImmutableString
and return it.
Returns the name of the actual type if the cast fails.
§Deprecated
This method is deprecated.
Use into_immutable_string
instead.
This method will be removed in the next major version.
source§impl Dynamic
impl Dynamic
sourcepub const fn is_variant(&self) -> bool
pub const fn is_variant(&self) -> bool
Does this Dynamic
hold a variant data type instead of one of the supported system
primitive types?
Is the value held by this Dynamic
shared?
Not available under no_closure
.
source§impl Dynamic
impl Dynamic
sourcepub const NEGATIVE_ONE: Self = _
pub const NEGATIVE_ONE: Self = _
A Dynamic
containing the integer -1.
sourcepub const NEGATIVE_TWO: Self = _
pub const NEGATIVE_TWO: Self = _
A Dynamic
containing the integer -2.
sourcepub const FLOAT_ZERO: Self = _
pub const FLOAT_ZERO: Self = _
A Dynamic
containing 0.0
.
Not available under no_float
.
sourcepub const FLOAT_HUNDRED: Self = _
pub const FLOAT_HUNDRED: Self = _
A Dynamic
containing 100.0
.
Not available under no_float
.
sourcepub const FLOAT_THOUSAND: Self = _
pub const FLOAT_THOUSAND: Self = _
A Dynamic
containing 1000.0
.
Not available under no_float
.
sourcepub const FLOAT_MILLION: Self = _
pub const FLOAT_MILLION: Self = _
A Dynamic
containing 1000000.0
.
Not available under no_float
.
sourcepub const FLOAT_NEGATIVE_ONE: Self = _
pub const FLOAT_NEGATIVE_ONE: Self = _
A Dynamic
containing -1.0
.
Not available under no_float
.
sourcepub const FLOAT_NEGATIVE_TWO: Self = _
pub const FLOAT_NEGATIVE_TWO: Self = _
A Dynamic
containing -2.0
.
Not available under no_float
.
sourcepub const FLOAT_HALF: Self = _
pub const FLOAT_HALF: Self = _
A Dynamic
containing 0.5
.
Not available under no_float
.
sourcepub const FLOAT_QUARTER: Self = _
pub const FLOAT_QUARTER: Self = _
A Dynamic
containing 0.25
.
Not available under no_float
.
sourcepub const FLOAT_FIFTH: Self = _
pub const FLOAT_FIFTH: Self = _
A Dynamic
containing 0.2
.
Not available under no_float
.
sourcepub const FLOAT_TENTH: Self = _
pub const FLOAT_TENTH: Self = _
A Dynamic
containing 0.1
.
Not available under no_float
.
sourcepub const FLOAT_HUNDREDTH: Self = _
pub const FLOAT_HUNDREDTH: Self = _
A Dynamic
containing 0.01
.
Not available under no_float
.
sourcepub const FLOAT_THOUSANDTH: Self = _
pub const FLOAT_THOUSANDTH: Self = _
A Dynamic
containing 0.001
.
Not available under no_float
.
sourcepub const FLOAT_MILLIONTH: Self = _
pub const FLOAT_MILLIONTH: Self = _
A Dynamic
containing 0.000001
.
Not available under no_float
.
sourcepub const FLOAT_HALF_PI: Self = _
pub const FLOAT_HALF_PI: Self = _
A Dynamic
containing π/2.
Not available under no_float
.
sourcepub const FLOAT_QUARTER_PI: Self = _
pub const FLOAT_QUARTER_PI: Self = _
A Dynamic
containing π/4.
Not available under no_float
.
sourcepub const FLOAT_TWO_PI: Self = _
pub const FLOAT_TWO_PI: Self = _
A Dynamic
containing 2π.
Not available under no_float
.
sourcepub const FLOAT_INVERSE_PI: Self = _
pub const FLOAT_INVERSE_PI: Self = _
A Dynamic
containing 1/π.
Not available under no_float
.
sourcepub const FLOAT_LOG_E: Self = _
pub const FLOAT_LOG_E: Self = _
A Dynamic
containing log
e.
Not available under no_float
.
sourcepub const FLOAT_LN_10: Self = _
pub const FLOAT_LN_10: Self = _
A Dynamic
containing ln 10
.
Not available under no_float
.
sourcepub const fn from_float(value: FLOAT) -> Self
pub const fn from_float(value: FLOAT) -> Self
sourcepub fn from_decimal(value: Decimal) -> Self
pub fn from_decimal(value: Decimal) -> Self
sourcepub fn from_array(array: Array) -> Self
pub fn from_array(array: Array) -> Self
sourcepub fn from_timestamp(value: Instant) -> Self
pub fn from_timestamp(value: Instant) -> Self
sourcepub fn into_read_only(self) -> Self
pub fn into_read_only(self) -> Self
Make this Dynamic
read-only (i.e. a constant).
sourcepub fn is_read_only(&self) -> bool
pub fn is_read_only(&self) -> bool
Is this Dynamic
read-only?
Constant Dynamic
values are read-only.
§Usage
If a &mut Dynamic
to such a constant is passed to a Rust function, the function
can use this information to return the error
ErrorAssignmentToConstant
if its value
will be modified.
This safe-guards constant values from being modified within Rust functions.
§Shared Value
If a Dynamic
holds a shared value, then it is read-only only if the shared value
itself is read-only.
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its access mode cannot be determined).
Under these circumstances, false
is returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn from<T: Variant + Clone>(value: T) -> Self
pub fn from<T: Variant + Clone>(value: T) -> Self
Create a Dynamic
from any type. A Dynamic
value is simply returned as is.
§Arrays
Beware that you need to pass in an Array
type for it to be recognized as
an Array
. A Vec<T>
does not get automatically converted to an
Array
, but will be a custom type instead (stored as a trait object).
Use array.into()
or array.into_iter()
to convert a Vec<T>
into a Dynamic
as
an Array
value. See the examples for details.
§Hash Maps
Similarly, passing in a HashMap<String, T>
or
BTreeMap<String, T>
will not get a Map
but a
custom type.
Again, use map.into()
to get a Dynamic
with a Map
value.
See the examples for details.
§Examples
use rhai::Dynamic;
let result = Dynamic::from(42_i64);
assert_eq!(result.type_name(), "i64");
assert_eq!(result.to_string(), "42");
let result = Dynamic::from("hello");
assert_eq!(result.type_name(), "string");
assert_eq!(result.to_string(), "hello");
let new_result = Dynamic::from(result);
assert_eq!(new_result.type_name(), "string");
assert_eq!(new_result.to_string(), "hello");
// Arrays - this is a custom object!
let result = Dynamic::from(vec![1_i64, 2, 3]);
assert_eq!(result.type_name(), "alloc::vec::Vec<i64>");
// Use '.into()' to convert a Vec<T> into an Array
let result: Dynamic = vec![1_i64, 2, 3].into();
assert_eq!(result.type_name(), "array");
// Hash map
let mut map = HashMap::new();
map.insert("a".to_string(), 1_i64);
// This is a custom object!
let result = Dynamic::from(map.clone());
assert_eq!(result.type_name(), "std::collections::hash::map::HashMap<alloc::string::String, i64>");
// Use '.into()' to convert a HashMap<String, T> into an object map
let result: Dynamic = map.into();
assert_eq!(result.type_name(), "map");
Turn the Dynamic
value into a shared Dynamic
value backed by an
Rc<RefCell<Dynamic>>
or Arc<RwLock<Dynamic>>
depending on the sync
feature.
Not available under no_closure
.
Shared Dynamic
values are relatively cheap to clone as they simply increment the
reference counts.
Shared Dynamic
values can be converted seamlessly to and from ordinary Dynamic
values.
If the Dynamic
value is already shared, this method returns itself.
sourcepub fn take(&mut self) -> Self
pub fn take(&mut self) -> Self
Return this Dynamic
, replacing it with Dynamic::UNIT
.
sourcepub fn try_cast<T: Any>(self) -> Option<T>
pub fn try_cast<T: Any>(self) -> Option<T>
Convert the Dynamic
value into specific type.
Casting to a Dynamic
simply returns itself.
§Errors
Returns None
if types mismatch.
§Shared Value
If the Dynamic
is a shared value, it returns the shared value if there are no
outstanding references, or a cloned copy otherwise.
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the cast also fails.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
§Example
use rhai::Dynamic;
let x = Dynamic::from(42_u32);
assert_eq!(x.try_cast::<u32>().expect("x should be u32"), 42);
sourcepub fn cast<T: Any + Clone>(self) -> T
pub fn cast<T: Any + Clone>(self) -> T
Convert the Dynamic
value into a specific type.
Casting to a Dynamic
just returns as is.
§Panics
Panics if the cast fails (e.g. the type of the actual value is not the same as the specified type).
§Shared Value
If the Dynamic
is a shared value, it returns the shared value if there are no
outstanding references, or a cloned copy otherwise.
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the shared value is simply cloned, which means that the returned value is also shared.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
§Example
use rhai::Dynamic;
let x = Dynamic::from(42_u32);
assert_eq!(x.cast::<u32>(), 42);
sourcepub fn clone_cast<T: Any + Clone>(&self) -> T
pub fn clone_cast<T: Any + Clone>(&self) -> T
Clone the Dynamic
value and convert it into a specific type.
Casting to a Dynamic
just returns as is.
§Panics
Panics if the cast fails (e.g. the type of the actual value is not the same as the specified type).
§Shared Value
If the Dynamic
is a shared value, a cloned copy of the shared value is returned.
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the shared value is simply cloned.
This normally shouldn’t occur since most operations in Rhai are single-threaded.
§Example
use rhai::Dynamic;
let x = Dynamic::from(42_u32);
let y = &x;
assert_eq!(y.clone_cast::<u32>(), 42);
sourcepub fn flatten_clone(&self) -> Self
pub fn flatten_clone(&self) -> Self
Flatten the Dynamic
and clone it.
If the Dynamic
is not a shared value, a cloned copy is returned.
If the Dynamic
is a shared value, a cloned copy of the shared value is returned.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the shared value is simply cloned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn flatten(self) -> Self
pub fn flatten(self) -> Self
Flatten the Dynamic
.
If the Dynamic
is not a shared value, it simply returns itself.
If the Dynamic
is a shared value, it returns the shared value if there are no
outstanding references, or a cloned copy otherwise.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the shared value is simply cloned, meaning that the result value will also be shared.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn read_lock<T: Any + Clone>(&self) -> Option<DynamicReadLock<'_, T>>
pub fn read_lock<T: Any + Clone>(&self) -> Option<DynamicReadLock<'_, T>>
Get a reference of a specific type to the Dynamic
.
Casting to Dynamic
just returns a reference to it.
Returns None
if the cast fails.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, this call also fails if the data is currently borrowed for write.
Under these circumstances, None
is also returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn write_lock<T: Any + Clone>(&mut self) -> Option<DynamicWriteLock<'_, T>>
pub fn write_lock<T: Any + Clone>(&mut self) -> Option<DynamicWriteLock<'_, T>>
Get a mutable reference of a specific type to the Dynamic
.
Casting to Dynamic
just returns a mutable reference to it.
Returns None
if the cast fails.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, this call also fails if the data is currently borrowed for write.
Under these circumstances, None
is also returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn is_unit(&self) -> bool
pub fn is_unit(&self) -> bool
Return true
if the Dynamic
holds a ()
.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, false
is returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn is_int(&self) -> bool
pub fn is_int(&self) -> bool
Return true
if the Dynamic
holds the system integer type INT
.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, false
is returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn is_float(&self) -> bool
pub fn is_float(&self) -> bool
Return true
if the Dynamic
holds the system floating-point type FLOAT
.
Not available under no_float
.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, false
is returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn is_decimal(&self) -> bool
pub fn is_decimal(&self) -> bool
(decimal) Return true
if the Dynamic
holds a Decimal
.
Exported under the decimal
feature only.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, false
is returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn is_bool(&self) -> bool
pub fn is_bool(&self) -> bool
Return true
if the Dynamic
holds a bool
.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, false
is returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn is_char(&self) -> bool
pub fn is_char(&self) -> bool
Return true
if the Dynamic
holds a char
.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, false
is returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn is_string(&self) -> bool
pub fn is_string(&self) -> bool
Return true
if the Dynamic
holds an ImmutableString
.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, false
is returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn is_array(&self) -> bool
pub fn is_array(&self) -> bool
Return true
if the Dynamic
holds an Array
.
Not available under no_index
.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, false
is returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn is_blob(&self) -> bool
pub fn is_blob(&self) -> bool
Return true
if the Dynamic
holds a Blob
.
Not available under no_index
.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, false
is returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn is_map(&self) -> bool
pub fn is_map(&self) -> bool
Return true
if the Dynamic
holds a Map
.
Not available under no_object
.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, false
is returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn is_fnptr(&self) -> bool
pub fn is_fnptr(&self) -> bool
Return true
if the Dynamic
holds a FnPtr
.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, false
is returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn is_timestamp(&self) -> bool
pub fn is_timestamp(&self) -> bool
Return true
if the Dynamic
holds a timestamp.
Not available under no_time
.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, false
is returned.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn as_unit(&self) -> Result<(), &'static str>
pub fn as_unit(&self) -> Result<(), &'static str>
Cast the Dynamic
as a unit ()
.
§Errors
Returns the name of the actual type as an error if the cast fails.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the cast also fails.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn as_int(&self) -> Result<INT, &'static str>
pub fn as_int(&self) -> Result<INT, &'static str>
Cast the Dynamic
as the system integer type INT
.
§Errors
Returns the name of the actual type as an error if the cast fails.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the cast also fails.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn as_float(&self) -> Result<FLOAT, &'static str>
pub fn as_float(&self) -> Result<FLOAT, &'static str>
Cast the Dynamic
as the system floating-point type FLOAT
.
Not available under no_float
.
§Errors
Returns the name of the actual type as an error if the cast fails.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the cast also fails.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn as_decimal(&self) -> Result<Decimal, &'static str>
pub fn as_decimal(&self) -> Result<Decimal, &'static str>
(decimal) Cast the Dynamic
as a Decimal
.
Exported under the decimal
feature only.
§Errors
Returns the name of the actual type as an error if the cast fails.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the cast also fails.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn as_bool(&self) -> Result<bool, &'static str>
pub fn as_bool(&self) -> Result<bool, &'static str>
§Errors
Returns the name of the actual type as an error if the cast fails.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the cast also fails.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn as_char(&self) -> Result<char, &'static str>
pub fn as_char(&self) -> Result<char, &'static str>
§Errors
Returns the name of the actual type as an error if the cast fails.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the cast also fails.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn into_string(self) -> Result<String, &'static str>
pub fn into_string(self) -> Result<String, &'static str>
Convert the Dynamic
into a String
.
If there are other references to the same string, a cloned copy is returned.
§Errors
Returns the name of the actual type as an error if the cast fails.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the cast also fails.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn into_immutable_string(self) -> Result<ImmutableString, &'static str>
pub fn into_immutable_string(self) -> Result<ImmutableString, &'static str>
Convert the Dynamic
into an ImmutableString
.
§Errors
Returns the name of the actual type as an error if the cast fails.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the cast also fails.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn into_array(self) -> Result<Array, &'static str>
pub fn into_array(self) -> Result<Array, &'static str>
Convert the Dynamic
into an Array
.
Not available under no_index
.
§Errors
Returns the name of the actual type as an error if the cast fails.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the cast also fails.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn into_typed_array<T: Variant + Clone>(
self
) -> Result<Vec<T>, &'static str>
pub fn into_typed_array<T: Variant + Clone>( self ) -> Result<Vec<T>, &'static str>
Convert the Dynamic
into a Vec
.
Not available under no_index
.
§Errors
Returns the name of the actual type as an error if the cast fails.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the cast also fails.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
sourcepub fn into_blob(self) -> Result<Blob, &'static str>
pub fn into_blob(self) -> Result<Blob, &'static str>
Convert the Dynamic
into a Blob
.
Not available under no_index
.
§Errors
Returns the name of the actual type as an error if the cast fails.
§Shared Value
Under the sync
feature, a shared value may deadlock.
Otherwise, the data may currently be borrowed for write (so its type cannot be determined).
Under these circumstances, the cast also fails.
These normally shouldn’t occur since most operations in Rhai are single-threaded.
Trait Implementations§
source§impl BorrowMut<Dynamic> for Target<'_>
impl BorrowMut<Dynamic> for Target<'_>
source§fn borrow_mut(&mut self) -> &mut Dynamic
fn borrow_mut(&mut self) -> &mut Dynamic
source§impl<'de> Deserialize<'de> for Dynamic
impl<'de> Deserialize<'de> for Dynamic
source§fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
source§impl Extend<Dynamic> for FnPtr
impl Extend<Dynamic> for FnPtr
source§fn extend<T: IntoIterator<Item = Dynamic>>(&mut self, iter: T)
fn extend<T: IntoIterator<Item = Dynamic>>(&mut self, iter: T)
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl From<FloatWrapper<f64>> for Dynamic
impl From<FloatWrapper<f64>> for Dynamic
source§fn from(value: FloatWrapper<FLOAT>) -> Self
fn from(value: FloatWrapper<FLOAT>) -> Self
source§impl From<RangeInclusive<i64>> for Dynamic
impl From<RangeInclusive<i64>> for Dynamic
source§fn from(value: RangeInclusive<INT>) -> Self
fn from(value: RangeInclusive<INT>) -> Self
source§impl<T: Variant + Clone> FromIterator<T> for Dynamic
impl<T: Variant + Clone> FromIterator<T> for Dynamic
source§fn from_iter<X: IntoIterator<Item = T>>(iter: X) -> Self
fn from_iter<X: IntoIterator<Item = T>>(iter: X) -> Self
source§impl<'de> IntoDeserializer<'de, Box<EvalAltResult>> for &'de Dynamic
impl<'de> IntoDeserializer<'de, Box<EvalAltResult>> for &'de Dynamic
§type Deserializer = DynamicDeserializer<'de>
type Deserializer = DynamicDeserializer<'de>
source§fn into_deserializer(self) -> Self::Deserializer
fn into_deserializer(self) -> Self::Deserializer
Auto Trait Implementations§
impl Freeze for Dynamic
impl !RefUnwindSafe for Dynamic
impl !Send for Dynamic
impl !Sync for Dynamic
impl Unpin for Dynamic
impl !UnwindSafe for Dynamic
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Variant for T
impl<T> Variant for T
source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Variant
trait object to &mut dyn Any
.source§fn as_boxed_any(self: Box<T>) -> Box<dyn Any>
fn as_boxed_any(self: Box<T>) -> Box<dyn Any>
Variant
trait object to Box<dyn Any>
.