Enum Value 

pub enum Value {
    Float(f64),
    Int(i64),
    Bool(bool),
    String(Str),
    Map(Map),
    Array(Array),
    None,
}

A dynamically‑typed value used throughout the library.

This enum can represent the primitive scalar types supported by the library as well as compound collection types. It is deliberately exhaustive so that a Value can be stored in heterogeneous containers (e.g., maps or arrays) without losing type information.

Variants

• Float(f64) – A 64‑bit floating‑point number. Mirrors the behaviour of f64 in the Rust standard library, including NaN and Infinity handling.

• Int(i64) – A signed 64‑bit integer. Provides the full range of i64 values.

• Bool(bool) – A boolean value, either true or false.

• String(Str) – A string value that may be a static slice, an Arc<String>, or an owned String. See Str for details.

• Map(Map) – An associative container mapping string keys to Values. See Map for the underlying implementation.

• Array(Array) – An ordered list of Values. See Array for the underlying implementation.

Examples

let v = Value::from(3.14);
assert!(matches!(v, Value::Float(_)));

let s = Value::from("hello");
assert_eq!(s.as_str(), "hello");
assert_eq!(v.as_str(), "3.14");

Variants

Float(f64)

64‑bit floating‑point number.

Int(i64)

64‑bit signed integer.

Bool(bool)

Boolean value.

String(Str)

String value, using the library’s flexible Str type.

Map(Map)

Map (dictionary) of string keys to Values.

Array(Array)

Array (list) of Values.

None

None value

Implementations

impl Value

pub fn from<T: Into<Value>>(value: T) -> Self

Creates a Value from any type that implements Into<Value>. /// This is a convenience method that allows for easy conversion of common types into Value instances.

Examples

let v_float = Value::from(3.14);
let v_int = Value::from(42);
let v_bool = Value::from(true);
let v_string = Value::from("hello");
assert!(matches!(v_float, Value::Float(_)));
assert!(matches!(v_int, Value::Int(_)));
assert!(matches!(v_bool, Value::Bool(_)));
assert!(matches!(v_string, Value::String(_)));

pub fn as_str(&self) -> Cow<'_, str>

Returns a string representation of the value.

If the value is a String, a borrowed &str is returned. Otherwise the value is formatted with to_string() and an owned String is returned inside a Cow::Owned.

Examples

let v = Value::String(Str::from_static("hello"));
assert_eq!(v.as_str(), "hello");

let v = Value::Int(42);
assert_eq!(v.as_str(), "42");

pub fn as_float(&self) -> f64

Attempts to interpret the value as a 64‑bit floating‑point number.

The conversion rules are:

• Float – returns the contained f64.
• Int – casts the integer to f64.
• String – parses the string as f64; on parse failure 0.0 is returned.
• Bool – true becomes 1.0, false becomes 0.0.
• Any other variant – returns 0.0.

Examples

assert_eq!(Value::Float(3.14).as_float(), 3.14);
assert_eq!(Value::Int(2).as_float(), 2.0);
assert_eq!(Value::Bool(true).as_float(), 1.0);
assert_eq!(Value::String("2.5".into()).as_float(), 2.5);

pub fn as_int(&self) -> i64

Attempts to interpret the value as a signed 64‑bit integer.

The conversion rules are:

• Int – returns the contained integer.
• Float – truncates the floating‑point value.
• String – parses the string as i64; on parse failure 0 is returned.
• Bool – true becomes 1, false becomes 0.
• Any other variant – returns 0.

Examples

assert_eq!(Value::Int(7).as_int(), 7);
assert_eq!(Value::Float(3.9).as_int(), 3);
assert_eq!(Value::Bool(false).as_int(), 0);
assert_eq!(Value::String("42".into()).as_int(), 42);

pub fn as_bool(&self) -> bool

Returns the boolean representation of the value.

Conversion rules:

• Bool – returns the contained boolean.
• Int – 0 is false, any other integer is true.
• Float – 0.0 is false, any other number is true.
• String – empty string is false, otherwise true.
• Map / Array – empty collections are false, otherwise true.

Examples

assert!(Value::Bool(true).as_bool());
assert!(!Value::Int(0).as_bool());
assert!(Value::String("text".into()).as_bool());

pub fn as_map(&self) -> Option<&Map>

Returns a reference to the underlying map if the value is a Map.

Returns

• Some(&Map) – when the variant is Value::Map.
• None – for all other variants.

Examples

let map = Map::new();
let v = Value::Map(map);
assert!(v.as_map().is_some());

pub fn as_array(&self) -> Option<&Array>

Returns a reference to the underlying array if the value is an Array.

Returns

• Some(&Array) – when the variant is Value::Array.
• None – for all other variants.

Examples

let arr = Array::new();
let v = Value::Array(arr);
assert!(v.as_array().is_some());

pub fn is_float(&self) -> bool

Returns true if the value is a Float.

pub fn is_int(&self) -> bool

Returns true if the value is an Int.

pub fn is_bool(&self) -> bool

Returns true if the value is a Bool.

pub fn is_string(&self) -> bool

Returns true if the value is a String.

pub fn is_map(&self) -> bool

Returns true if the value is a Map.

pub fn is_array(&self) -> bool

Returns true if the value is an Array.

pub fn new_map() -> Self

Creates a new empty Value::Map.

pub fn new_array() -> Self

Creates a new empty Value::Array.

pub fn get(&self, key: &str) -> Option<&Value>

Safely gets a value from a map by key, returning None if not a map or key doesn’t exist

pub fn get_index(&self, index: usize) -> Option<&Value>

Safely gets a value from an array by index

pub fn from_json(s: &str) -> Result<Self, Error>

Deserialises a JSON string into a Value.

Returns a serde_json::Error if the JSON cannot be parsed.

Examples

use anyval::Value;

let json = r#"{"key":"value","num":42}"#;
let val = Value::from_json(json).unwrap();
assert_eq!(val["key"].as_str(), "value");
assert_eq!(val["num"].as_int(), 42);

Array example

use anyval::Value;

let json = r#"["value",42,true]"#;
let val = Value::from_json(json).unwrap();
assert_eq!(val[0].as_str(), "value");
assert_eq!(val[1].as_int(), 42);
assert_eq!(val[2].as_bool(), true);

pub fn to_json(&self) -> Result<String, Error>

Serialises the value to a JSON string.

Returns a serde_json::Error if the value cannot be serialised.

Examples

use anyval::Value;

let val = Value::from("hello");
let json = val.to_json().unwrap();
assert_eq!(json, r#""hello""#);

Map example

use anyval::{Value, Map};

let mut map = Map::new();
map["key"] = "value".into();
let val = Value::Map(map);
let json = val.to_json().unwrap();
assert_eq!(json, r#"{"key":"value"}"#);

pub fn to_json_writer<W: Write>(&self, writer: W) -> Result<(), Error>

Serialises the value to a JSON writer.

Returns a serde_json::Error if the value cannot be serialised.

Examples

use anyval::Value;

let val = Value::from(42);
let mut buffer = Vec::new();
val.to_json_writer(&mut buffer).unwrap();
assert_eq!(String::from_utf8(buffer).unwrap(), "42");

impl Value

pub fn as_map_mut(&mut self) -> Option<&mut Map>

Returns a mutable reference to the underlying map if the value is a Map.

pub fn as_array_mut(&mut self) -> Option<&mut Array>

Returns a mutable reference to the underlying array if the value is an Array.

pub fn is_none(&self) -> bool

Returns true if the value is None.

pub fn take(&mut self) -> Value

Takes the value out, leaving Value::None in its place.

Trait Implementations

impl Clone for Value

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Value

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Value

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Value

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&String> for Value

fn from(s: &String) -> Self

Converts to this type from the input type.

impl From<&'static str> for Value

fn from(s: &'static str) -> Self

Converts to this type from the input type.

impl From<Arc<String>> for Value

fn from(s: Arc<String>) -> Self

Converts to this type from the input type.

impl From<Array> for Value

fn from(a: Array) -> Self

Converts to this type from the input type.

impl From<Map> for Value

fn from(m: Map) -> Self

Converts to this type from the input type.

impl From<Str> for Value

fn from(s: Str) -> Self

Converts to this type from the input type.

impl From<String> for Value

fn from(s: String) -> Self

Converts to this type from the input type.

impl From<bool> for Value

fn from(b: bool) -> Self

Converts to this type from the input type.

impl From<f32> for Value

fn from(f: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Value

fn from(f: f64) -> Self

Converts to this type from the input type.

impl From<i128> for Value

fn from(i: i128) -> Self

Converts to this type from the input type.

impl From<i32> for Value

fn from(i: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Value

fn from(i: i64) -> Self

Converts to this type from the input type.

impl From<u128> for Value

fn from(u: u128) -> Self

Converts to this type from the input type.

impl From<u64> for Value

fn from(u: u64) -> Self

Converts to this type from the input type.

impl FromIterator<Value> for Array

fn from_iter<T: IntoIterator<Item = Value>>(iter: T) -> Self

Creates a value from an iterator.

impl Index<&str> for Value

type Output = Value

The returned type after indexing.

fn index(&self, index: &str) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<usize> for Value

type Output = Value

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<&str> for Value

fn index_mut(&mut self, index: &str) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IndexMut<usize> for Value

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl Into<bool> for Value

fn into(self) -> bool

Converts this type into the (usually inferred) input type.

impl Into<f64> for Value

fn into(self) -> f64

Converts this type into the (usually inferred) input type.

impl Into<i128> for Value

fn into(self) -> i128

Converts this type into the (usually inferred) input type.

impl Into<i16> for Value

fn into(self) -> i16

Converts this type into the (usually inferred) input type.

impl Into<i32> for Value

fn into(self) -> i32

Converts this type into the (usually inferred) input type.

impl Into<i64> for Value

fn into(self) -> i64

Converts this type into the (usually inferred) input type.

impl Into<i8> for Value

fn into(self) -> i8

Converts this type into the (usually inferred) input type.

impl Into<isize> for Value

fn into(self) -> isize

Converts this type into the (usually inferred) input type.

impl Into<usize> for Value

fn into(self) -> usize

Converts this type into the (usually inferred) input type.

impl PartialEq for Value

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Value

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Value> for String

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self, Self::Error>

Performs the conversion.