值中有何？

Rust的核心优势在于其能够在编译时提供内存安全和性能保证，这是通过其所有权和借用系统实现的。但对于Rust编写的应用程序，开发人员处理运行时定义的动态数据类型的能力仍然是一项重要任务，这可以增加应用程序的通用性，同时提供处理广泛用例的能力。

在Rust中创建的各种解释型DSL语言使用了为特定语言创建的运行时动态数据类型系统。出色的crate Serde也实现了允许在运行时处理动态数据类型的trait Value。但没有任何一种解决方案是Rust开发者完美的，因为它们要么专注于特定的DSL，要么处理JSON值。

rust_dynamic是一个crate，专为Rust语言创建，实现了帮助Rust开发者解决在运行时定义的动态数据类型特定问题的原语。目前，rust_dynamic支持以下数据类型

• 整数，内部表示为i64
• 浮点数，内部表示为f64
• 布尔值
• 字符串，内部表示为String
• 对，作为动态值的对
• 列表，作为动态值的列表
• 二进制，作为u8值的向量
• 纳秒级时间戳
• 包裹在任何动态类型对象中的对象
• 用于i64和f64的复数
• 映射
• 关联
• 无
• NODATA
• 错误
• 作为TIMESTAMP->F64样本向量的度量

动态值被包裹并存储在Value结构中，可以将其转换回原始Rust值。

use rust_dynamic::value::Value;

let mut value = Value::from(42).unwrap();
println!("Type of the stored value is {}", &value.type_name());
println!("Dynamic value of the value is {:?}", &value.cast_integer());

动态类型对象的属性是什么？

• 值对象可以包裹任何受支持类型的值，并且是功能纯的。一旦你分配了值，你就不能更改它，只有一个例外。任何更改尝试都将导致生成一个新的Value对象。但你可以推送一个新的值到List类型的对象中，而无需重新创建一个新对象。
• 所有动态类型对象都是可哈希的，因此您可以将它们用作HasMap对象的键。
• 所有动态类型对象都包含存储数据类型的完整信息。
• 所有动态类型对象存储一个唯一的对象标识符。
• 所有动态类型对象都可以序列化为JSON和二进制编码。
• 您可以遍历所有动态类型对象。
• 您可以创建附加到包装数据的属性。
• 支持基本数学运算：加、减、乘、除，适用于FLOAT和INTEGER类型。
• 支持字符串连接和乘法。

如何创建动态类型值

rust_dynamic包支持许多函数原语，这些函数原语将接受原始值并返回包装的动态对象。

存在一个泛型函数Value::from()，它会自动转换适当的数据类型，并返回对象或错误消息。

如何将Rust值从动态类型值转换

rust_dynamic支持许多转换函数，这些函数将尝试从包含动态类型值的对象中提取包装值。

示例

use rust_dynamic::value::Value;

// First we create a dynamically-typed value from a raw static value
let mut value = Value::from(42).unwrap();

// Then we can cast raw value back from the dynamic object
let raw_value = value.cast_integer().unwrap()

如何设置Value的属性

Value属性是存储在Value对象中的值的Vector。您可以为Value对象分配任意数量的Value对象作为属性。属性是可序列化和可包装的。

示例

// Create object
let v = Value::from(42 as i64).unwrap()
                // Set the attributes of the object
                .attr(vec![Value::from(41.0 as f64).unwrap()])
                // And merge some extra attributes. The first attribute now have a value of 42.0
                .attr_merge(vec![Value::from(42.0 as f64).unwrap()]);

如何序列化和反序列化动态类型值

目前rust_dynamic支持两种序列化格式：JSON和Bincode。

示例

// This call will create a new dynamic value
let mut data = Value::from(42 as i64).unwrap();
// This call will serialize object to Bincode format
let bin_out = data.to_binary().unwrap();
// This will re-create an object from it's Bincode representation
let mut data2 = Value::from_binary(bin_out).unwrap();

动态类型值与serde_json crate的集成

Crate rust_dynamic能够将Value对象导出为serde_json::value::Value

示例

// This call will create a Value object of type PAIR and on-the-fly exports it
// to the serde_json::value::Value object that can be processed as any other Value object created by serde_json crate.
let v = Value::pair(Value::from_int(1), Value::from_int(2)).as_json_value();

与动态类型值的功能操作

虽然rust_dynamic crate并不力求提供完整的动态值功能接口，但已经实现了一些特定于函数式编程的功能。

映射示例

// First, we define a function which will cast value of f64 and apply f64.sin() operation
fn comp_sin(value: Value) -> Value {
    match value.data {
        Val::F64(f_val) => {
            return Value::from_float(f64::sin(f_val));
        }
        _ => return value,
    }
}
// Then we create a single value object (map could be epplied to ether list or single value object)
let mut v = Value::from(42.0).unwrap();
// Now v contains result of computation
v = v.map_value(comp_sin);

绑定示例

// First, let's create a "binding function" which will takes two Value objects and return a new Value
// In our example, simple sum() will be performed
fn sum_of_values(v1: Value, v2: Value) -> Value {
    v1 + v2
}
// Then let's create two values
let v1 = Value::from(41.0 as f64).unwrap();
let v2 = Value::from(1.0 as f64).unwrap();
// Value referred as _s_ now contains value of 42.0
let s = Value::bind_values(sum_of_values, v1, v2);

maybe()示例

// First, we create a function that will check if v is float and is 42
fn if_value_is_42(v: &Value) -> bool {
    if v.cast_float().unwrap() == 42.0 {
        return true;
    }
    false
}
// And because it is, v is object of Value(42.0)
// Otherwise it would be Value::none()
let v = Value::from(42.0 as f64).unwrap()
        .maybe(if_value_is_42);

减少示例

// First, we shall create a list of the values
let mut v = Value::from_list(
    vec![Value::from_float(41.0 as f64),
    Value::from_float(1.0 as f64)]);
// Then reduce this list applying function that sums "accumulator" and current value
v = v.freduce(
    |x: Value,y: Value| -> Value { x+y },
    Value::from_float(0.0 as f64));
// This function shall return a single FLOAT value wrapping number 42.0

如何将动态类型对象用作HashMap键

use std::collections::HashMap;

// This call will create a key object. Key object can be of any supported type
let key = Value::from(42.0 as f64).unwrap();

// Then we are creating a HashMap
let mut h: HashMap<Value, String> = HashMap::new();

// and store a key->value association
h.insert(key, "value".to_string());

如何迭代动态类型对象

let mut c = 0.0;
// Let's create a object of LIST type and push two elements into list
let v = Value::list()
        .push(Value::from(1.0 as f64).unwrap())
        .push(Value::from(41.0 as f64).unwrap());
// We can iterate over dynamically-typed object
for i in v {
    c += i.cast_float().unwrap();
}

如何映射动态类型对象

在这个示例中，我们将f64::sin函数应用于动态类型对象的每个可迭代的值

let mut v = Value::from(42.0).unwrap();
v = v.map_float(f64::sin);

如何使用动态类型对象进行数学运算

目前，仅支持FLOAT和INTEGER对象的数学运算。

// Let's create x and y objects both of FLOAT type
let mut x = Value::from(1.0 as f64).unwrap();
let y = Value::from(41.0 as f64).unwrap();
// And perform math operation as usual
x = x + y;

如何连接字符串对象

目前，只有STRING对象支持该操作。

// Let's create x and y objects both of STRING type
let mut x = Value::from("Hello").unwrap();
// Then perform operation as usual, x shall be a object of STRING type containing string "Hello world"
let y = Value::from(" world").unwrap();
x = x + y;

如何将String转换为Float

// This call returns the object of type FLOAT
let val = Value::from("42").unwrap().conv(FLOAT).unwrap();

rust_dynamic的功能特性

创建和使用Applicative

您可以通过包装一个函数来创建一个Applicative，并将带有包装值的Value对象应用到Applicative上。例如

// First, as usual, we are defining function, that will be wrapped in Applicative
fn comp_sin(value: Value) -> Value {
    match value.data {
        Val::F64(f_val) => {
            return Value::from_float(f64::sin(f_val));
        }
        _ => return value,
    }
}

// Create applicative and wrap a function
let sin = Applicative::new(comp_sin);
// Then apply a Value to a wrapped function
let res = sin.apply(Value::from(42.0).unwrap());