• 推荐几个编写Rust程序常用的库
  • 发布于 1个月前
  • 98 热度
    0 评论
  • DuXing
  • 7 粉丝 30 篇博客
  •   
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<MyEnum> 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倍。
用户评论