use inherit_methods_macro::inherit_methods;
 pub struct Stack<T>(Vec<T>);

 // Annotate an impl block with #[inherit_methods(from = "...")] to enable automatically
 // inheriting methods from a field, which is specifiedd by the from attribute.
 #[inherit_methods(from = "self.0")]
 impl<T> Stack<T> {
     // Normal methods can be implemented with inherited methods in the same impl block.
     pub fn new() -> Self {
         Self(Vec::new())
     }

     // All methods without code blocks will "inherit" the implementation of Vec by
     // forwarding their method calls to self.0.
     pub fn push(&mut self, value: T);
     pub fn pop(&mut self) -> Option<T>;
     pub fn len(&self) -> usize;
 }

如果你想要为包装类型派生常见特性（如AsRef和Deref），请查看shrinkwraprs crate。

模拟经典的OOP继承

在许多面向对象编程框架或应用程序中，拥有一个所有对象从中继承的基础类非常有用。在这个例子中，我们希望做同样的事情，创建一个基础类（用于接口的 Object 特性和用于实现的 ObjectBase 结构体），这样所有对象都应该“继承”。

use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Mutex;

use inherit_methods_macro::inherit_methods;

pub trait Object {
    fn type_name(&self) -> &'static str;
    fn object_id(&self) -> u64;
    fn name(&self) -> String;
    fn set_name(&self, new_name: String);
}

struct ObjectBase {
    object_id: u64,
    name: Mutex<String>,
}

impl ObjectBase {
    pub fn new() -> Self {
        static NEXT_ID: AtomicU64 = AtomicU64::new(0);
        Self {
            object_id: NEXT_ID.fetch_add(1, Ordering::Relaxed),
            name: Mutex::new(String::new()),
        }
    }

    pub fn object_id(&self) -> u64 {
        self.object_id
    }

    pub fn name(&self) -> String {
        self.name.lock().unwrap().clone()
    }

    pub fn set_name(&self, new_name: String) {
        *self.name.lock().unwrap() = new_name;
    }
}

struct DummyObject {
    base: ObjectBase,
}

impl DummyObject {
    pub fn new() -> Self {
        Self {
            base: ObjectBase::new(),
        }
    }
}

#[inherit_methods(from = "self.base")]
impl Object for DummyObject {
    // Give this method an implementation specific to this type
    fn type_name(&self) -> &'static str {
        "DummyObject"
    }

    // Inherit methods from the base class
    fn object_id(&self) -> u64;
    fn name(&self) -> String;
    fn set_name(&self, new_name: String);
}