boring-derive

为特质简单实现提供 derive 宏。

例如，From 通常具有非常简单的实现。

enum Thing {
  Item1(String),
  Item2(usize),
  Item3(f32),
}

impl From<String> for Thing {
  fn from(value: String) -> Self {
    Thing::Item1(value)
  }
}

impl From<usize> for Thing {
  fn from(value: usize) -> Self {
    Thing::Item2(value)
  }
}

impl From<f32> for Thing {
  fn from(value: f32) -> Self {
    Thing::Item3(value)
  }
}

所以只需

#[derive(From)]
enum Thing {
  Item1(String),
  Item2(usize),
  Item3(f32),
}

lib.rs:

为一些常见模式提供 derive 宏

当前实现的模式有

• Builder
• From

Builder

对于 Builder 宏，它生成具有以下形式的方法的 impl

fn field(mut self, value: impl Into<Type>) -> Self {
    self.field = value.into()
    self
}

以下是一个结构体生成的示例代码

#[derive(Default, Builder)]
struct Example {
    item: String,
    value: usize,
}

// generated impl
impl Example {
    fn item(mut self, value: impl Into<String>) -> Self {
        self.item = value.into();
        self
    }

    fn value(mut self, value: impl Into<usize>) -> Self {
        self.value = value.into();
        self
    }
}

// using the values
fn func() {
    let ex = Example::default()
        .item("something")
        .value(1);
    ...
}

如果你想在构建器模式中不包括字段，请使用 skip 属性

#[derive(Builder)]
struct Example {
    #[builder(skip)]
    item: String,
    value: usize,
}

如果你不想使用 Into，请使用 no_into 属性

#[derive(Builder)]
struct Example {
    #[builder(no_into)]
    item: String,
    value: usize,
}

如果你需要更改关联方法的名称，请使用 prefix 和/或 rename 属性。

#[derive(Builder)]
#[builder(prefix = "set_")]
struct Example {
    item: String,
    #[builder(rename = "num")]
    value: usize,
}

// will generate
impl Example {
    fn set_item(mut self, ..) -> Self {..}
    fn num(mut self, ..) -> Self {..}
}

Builder 模式不适用于枚举、单元类结构、新类型和元组结构

From

对于 From derive，它实现了简单的 From<Type> 实现

#[derive(From)]
enum Example {
    Empty,
    Number(f32),
    Pair(String, String),
}

// will generate
impl From<()> for Example {
    fn from(value: ()) -> Self {
        Example::Empty
    }
}
impl From<f32> for Example {
    fn from(value: f32) -> Self {
        Example::Number(f32)
    }
}
impl From<(String, String)> for Example {
    fn from(value: (String, String)) -> Self {
        Example::Pair(value.0, value.1)
    }
}

对于结构体数据类型，它使用元组作为转换类型

#[derive(From)]
struct Example {
    item: usize
    value: String
}

// generates
impl From<(usize, String)> for Example {
    fn from(value: (usize, String)) -> Self {
        Example {
            item: value.0,
            value: value.1,
        }
    }
}

如果你不需要生成 From 实现，请使用 skip 属性

#[derive(From)]
enum Example {
    #[from(skip)]
    Empty,
    Number(f32),
    Pair(String, String),
}