Lib.rs

pub struct Foo(i32);

// generated by `[derive(DerivingVia)]` ---+
impl Deref for Foo {                    // |
  type Target = i32;                    // |
                                        // |
  fn deref(&self) -> &Self::Target {    // |
    &self.0                             // |
  }                                     // |
} // <-------------------------------------+

fn main() {
  let foo = Foo(42);

  // This works because of Deref trait.
  // ToOwned trait is implemented for i32.
  // Foo is dereferenced to i32 and to_owned for i32 is called.
  let i: i32 = foo.to_owned();
}

显式泛型新类型派生

可以使用#[deriving]属性进行显式泛型新类型派生。

示例（GND）

use deriving_via::DerivingVia;

#[derive(DerivingVia)]
pub struct A(i32);

#[derive(DerivingVia)]
#[deriving(Display)]
pub struct B(A);

fn main() {
  let b = B(A(42));

  println!("{b}"); // prints "42"
}

通过派生

使用通过派生功能，可以生成从多层包装类型的特定基础实现中派生的代码。

示例（通过派生）

此示例不使用通过派生功能。

use std::fmt::Display;

use deriving_via::DerivingVia;

#[derive(DerivingVia)]
pub struct A(i32);

#[derive(DerivingVia)]
pub struct B(A);

fn main() {
  let b = B(A(42));

  // `b.to_string()` uses `A::Display` impl (most nearest impl).
  assert_eq!(b.to_string(), "A(42)");
}

此示例使用通过派生功能。类型B从i32实现中派生Display特性。

use std::fmt::Display;

use deriving_via::DerivingVia;

#[derive(DerivingVia)]
pub struct A(i32);

impl Display for A {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(f, "A({})", self.0)
  }
}

#[derive(DerivingVia)]
#[deriving(Display(via: i32))] // a new line
pub struct B(A);

fn main() {
  let b = B(A(42));

  // `b.to_string()` uses `B::Display` impl directly.
  assert_eq!(b.to_string(), "42");
}

#[transitive]属性

顺便说一句，当你想要派生Add时，你可以解引用到i32，但不能从i32解引用到Self。因此，你需要从i32派生到Self的From。你还需要指定返回顺序的#[transitive]属性。一些特性需要#[transitive]属性（请参阅可用派生部分）。

注意：From<T> for T是通过泛型实现实现的。

示例（传递性）

以下示例为C派生了Add和Display。要实现Display，将C解引用到i32就足够了。但是，要实现Add，需要从i32解引用回C。为此，你需要为每个新类型派生From。此外，你还需要使用#[transitive]属性指定从i32到C的返回顺序。

use std::fmt::Display;

use deriving_via::DerivingVia;

#[derive(DerivingVia)]
#[deriving(From)]
pub struct A(i32);

#[derive(DerivingVia)]
#[deriving(From)]
pub struct B(A);

#[derive(DerivingVia)]
#[deriving(From, Add(via: i32), Display(via: i32))]
#[transitive(i32 -> A -> B -> C)]
pub struct C(B);

fn main() {
  let c: C = C(B(A(42))) + C(B(A(42)));
  println!("{c}");
}

可用派生

struct Base(Underlying);

#[derive(DerivingVia)]
#[deriving(<Derive>)]
struct Target(Base);

• fmt
  • Display
    • 要求：Base: Display或(via = <Type>) and Type: Display
• ops
  • Eq
    • 要求：Base: Eq或(via = <Type>) and Type: Eq
  • Ord
    • 要求：Base: Ord或(via = <Type>) and Type: Ord
  • 类似Add的（Add，Sub）
    • 要求：Base: From<Underlying>
    • 限制：单跳或#[transitive]
  • 类似Mul的（Mul，Div）
    • 要求：Base: From<Underlying>
    • 限制：单跳或#[transitive]
  • Arithmetic（Add，Sub，Mul，Div）
    • 要求：Base: From<Underlying>
    • 限制：单跳或#[transitive]
  • 索引
    • 需要： Base: Index 或 (via = <Type>) 和 Type: Index
  • IndexMut
    • 需要： Base: IndexMut 或 (via = <Type>) 和 Type: IndexMut
  • DerefMut
    • 需要： Base: DerefMut 或 (via = <Type>) 和 Type: DerefMut
• hash
  • Hash
    • 需要： Base: Hash 或 (via = <Type>) 和 Type: Hash
• serde
  • Serialize
    • 需要： Base: Serialize 或 (via = <Type>) 和 Type: Serialize
  • Deserialize
    • 需要： Base: Deserialize 或 (via = <Type>) 和 Type: Deserialize
• convert
  • AsRef
  • AsMut
  • FromIterator
    • 需要： (via: <ItemType>)
  • IntoIterator
    • 需要： Base: IntoIterator 或 (via: <Type>), Type: IntoIterator
  • Into
    • 需要： Base: Into<Underlying>
    • 限制：单跳或#[transitive]
  • From
    • 限制：单跳或#[transitive]
  • TryFrom
    • 要求：Base: From<Underlying>
    • 限制：单跳或#[transitive]
  • FromStr
    • 要求：Base: From<Underlying>
    • 限制：单跳或#[transitive]
• impls
  • Iter
    • 需要： Base: IntoIterator 和 Base 可解引用到切片 或 (via: <Type>), Type: IntoIterator 和 Type 可解引用到切片
  • IntoInner
    • 需要： Base: Clone 或 (via: <Type>), Type: Clone