你需要知道的32个Rust库 - 1

1，Tap

Tap crate可以将函数调用链从前缀表示法转换为后缀表示法，这可以使你编写更具可读性的代码。

用例子来解释是最容易的，例如，一个像这样的调用链：

let val = last(
  third(
    second(first(original_value), another_arg)
  ),
  another_arg,
);

可以重写为：

let val = original_value
  .pipe(first)
  .pipe(|v| second(v, another_arg))
  .pipe(third)
  .pipe(|v| last(v, another_arg));

2，Strum

在Rust中使用枚举时，Strum crate有助于摆脱样板代码，该功能是通过派生宏实现的。

例如：

1. strum::Display：为enum实现std::fmt::Display，因此也实现了to_string() -> String方法。
2. strum::AsRefStr：实现AsRef<&static str>，因此，它不需要像使用to_string()那样分配内存。
3. strum::IntoStaticStr：实现“From for &'static str”，工作原理类似于上一个选项。
4. strum::EnumString：实现std::str::FromStr和std::convert::TryFrom<&str>，允许将字符串转换为enum实例。
5. strum::EnumCount：添加常量COUNT: usize，值为枚举变量的数量。
6. strum::EnumIter：在枚举变量上实现迭代器，变量中的数据将被设置为Default:: Default()。

使用上述宏的例子：

#[derive(
    Debug,
    PartialEq,
    strum::Display,
    strum::IntoStaticStr,
    strum::AsRefStr,
    strum::EnumString,
    strum::EnumCount,
    strum::EnumIter,
)]
enum Color {
    Red,
    Blue(usize),
    Green { range: usize },
}

fn main() {
    assert_eq!(Color::Blue(2).to_string(), "Blue");
    assert_eq!(Color::Green { range: 5 }.as_ref(), "Green");
    assert_eq!(<&str>::from(Color::Red), "Red");

    assert_eq!(Color::Red, Color::from_str("Red").unwrap());
    assert_eq!(Color::COUNT, 3);
    assert_eq!(
        Color::iter().collect::<Vec<_>>(),
        vec![Color::Red, Color::Blue(0), Color::Green { range: 0 }]
    );
}

此外，Strum的不同宏支持行为定制。例如，可以使用属性#[strum(serialize = "redred")]更改将被转换为enum实例的字符串。

3，derive_more

NewType模式在Rust中非常常见。有时需要在我们自己的结构中封装第三方库类型：

pub struct NonEmptyVec(Vec<i32>);

derive_more，本质上是样板代码，因为它复制了Rust内部trait的现有实现，因此不需要我们自己去实现这些trait。我们只需为封装器结构添加派生宏的使用：

#[derive(derive_more::AsRef, derive_more::Deref, derive_more::IntoIterator, derive_more::Index)]
pub struct NonEmptyVec(Vec<i32>);

检查这是否有效：

fn collector(iter: impl IntoIterator<Item = i32>) -> Vec<i32> {
    iter.into_iter().collect()
}

#[test]
fn non_emtpy_vec() -> Result<()> {
    assert!(NonEmptyVec::new(vec![]).is_err());

    let non_empty = NonEmptyVec::new(vec![1, 2, 3])?;
    assert_eq!(non_empty.as_ref(), &[1, 2, 3]);
    assert_eq!(non_empty.deref(), &[1, 2, 3]);
    assert_eq!(non_empty[1], 2);
    assert_eq!(collector(non_empty), vec![1, 2, 3]);
    Ok(())
}

这个crate包含了用于生成转换特征(From, IntoIterator, AsRef等)，格式化特征(类似display)，操作符特征(Add, Index等)的宏。

4，derive_builder

Rust中最流行的模式之一是构建器模式，当需要创建包含许多字段的复杂结构时，此模式非常方便。

使用derive_more crate，可以自动生成构建器模式，使代码更简洁：

#[derive(Debug, Eq, PartialEq, Default, derive_builder::Builder)]
#[builder(pattern = "immutable")]
#[builder(default)]
#[builder(setter(strip_option))]
struct Calculation {
    a: Option<i32>,
    b: Option<i32>,
    c: Option<i32>,
    d: Option<i32>,
    // ... can be more optional fields
}

fn derive_builder() -> Result<()> {
    let builder = CalculationBuilder::default();
    builder.a(1).build()?;
    builder.a(6).d(7).build()?;
    builder.b(2).c(3).build()?;

    Ok(())
}

derive_more crate 还支持构建方法中的字段验证。

5，insta

用于快照测试的库。快照表示测试的预期结果，通常存储在单独的文件中。该库提供了一个命令行实用程序，可以方便地更新快照。

其中一个有用的功能是编辑。它允许测试随机或不确定顺序的字段值，例如HashSet：

#[derive(serde::Serialize)]
pub struct User {
    id: Uuid,
    username: String,
    flags: HashSet<&'static str>,
}
#[test]
fn redactions() {
    let user = User {
        id: Uuid::new_v4(),
        username: "john_doe".to_string(),
        flags: maplit::hashset! {"zzz", "foo", "aha"},
    };
    insta::assert_yaml_snapshot!(user, {
        ".id" => "[uuid]",
        ".flags" => insta::sorted_redaction()
    });
}

对于这个测试，自动生成快照snapshots/insta__tests__redactions.snap，包含以下内容：

---
source: src/bin/insta.rs
expression: user
---
id: "[uuid]"
username: john_doe
flags:
  - aha
  - foo
  - zzz

6，enum_dispatch

Rust通过静态和动态分派特性来支持多态性。如果你使用过动态分派，就知道它会对程序的性能产生负面影响，因为trait的实现是在运行时通过虚函数表查找的。

而 enum_dispatch 库使用枚举将动态分派转换为静态分派。假设我们有这样一个trait和它的实现：

pub trait ReturnsValue {
    fn return_value(&self) -> usize;
}

pub struct Zero;

impl ReturnsValue for Zero {
    fn return_value(&self) -> usize {
        0
    }
}

pub struct Any(usize);

impl ReturnsValue for Any {
    fn return_value(&self) -> usize {
        self.0
    }
}

在这个例子的测试中，我们使用了动态分派：

#[test]
fn derive_dispatch_dynamic() {
    let values: Vec<Box<dyn ReturnsValue>> = vec![Box::new(Zero {}), Box::new(Any(5))];

    assert_eq!(
        values
            .into_iter()
            .map(|dispatched| dispatched.return_value())
            .collect::<Vec<_>>(),
        vec![0, 5]
    );
}

现在让我们使用enum_dispatch：

#[enum_dispatch::enum_dispatch]
pub trait ReturnsValue {
    fn return_value(&self) -> usize;
}

// trait implementations are same

#[enum_dispatch::enum_dispatch(ReturnsValue)]
pub enum EnumDispatched {
    Zero,
    Any,
}

#[test]
fn derive_dispatch_static() {
    let values = vec![EnumDispatched::Zero(Zero {}), EnumDispatched::Any(Any(5))];

    assert_eq!(
        values
            .into_iter()
            .map(|dispatched| dispatched.return_value())
            .collect::<Vec<_>>(),
        vec![0, 5]
    );
}

经过测试，这样的实现可以将trait的使用速度提高10-12倍。