在实现impl 的时候，有没有参数获取被impl的struct或enum的名字？

在 Rust 中，你可以通过使用关键字 `Self` 来获取被 impl 的 struct 或 enum 的名字。

如下面这个例子，我们通过在 impl 块中使用 `Self` 来获取 `MyStruct` 的名字：

struct MyStruct;

impl MyStruct {
    fn print_name() {
        println!("MyStruct");
    }
}

此外，还可以使用 `std::any::type_name` 来获取类型的名字, 例如:

let name = std::any::type_name::<MyStruct>();
println!("Type name: {}", name);

这样就可以得到类型名称的字符串。

如果你想要动态地获取被 impl 的 struct 或 enum 的名字，则可以使用反射库，例如：

let name = std::any::type_name::<MyStruct>();
let type_id = std::any::TypeId::of::<MyStruct>();

我希望这些示例能帮助你解决你的问题。

相关问题

rust怎么使用trait和impl的方式实现代码重用和抽象？

Trait是Rust中用于抽象共性行为的一种机制，可用于实现代码的重用和抽象。要使用trait和impl的方式实现代码重用和抽象，可以首先定义一个trait，然后在struct或enum中实现这个trait。如下所示：

trait Animal {
    fn make_sound(&self) -> String;
}

struct Dog {}
struct Cat {}

impl Animal for Dog {
    fn make_sound(&self) -> String {
        "Woof".to_string()
    }
}

impl Animal for Cat {
    fn make_sound(&self) -> String {
        "Meow".to_string()
    }
}

在上面的例子中，我们定义了一个Animal trait，其中包含一个make_sound方法。然后我们定义了两个struct，Dog和Cat，并在它们的impl块中实现了Animal trait。这样就可以通过调用make_sound方法来让不同的动物发出不同的声音了。

rust实现std::promise

Rust没有内置的std :: promise类，但是可以使用Rust的Future和async / await语法来实现类似的功能。

一个可能的实现如下：

use std::sync::{Arc, Mutex};
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::cell::UnsafeCell;

struct Promise<T> {
    state: Arc<Mutex<State<T>>>,
}

impl<T> Promise<T> {
    fn new() -> (Self, FuturePromise<T>) {
        let state = Arc::new(Mutex::new(State::Pending));
        let promise = Promise { state: state.clone() };
        let future = FuturePromise { state };
        (promise, future)
    }

    fn set_value(&self, value: T) {
        let mut state = self.state.lock().unwrap();
        match *state {
            State::Pending => {
                *state = State::Resolved(value);
            }
            _ => panic!("Promise already resolved"),
        }
    }

    fn set_error(&self, error: String) {
        let mut state = self.state.lock().unwrap();
        match *state {
            State::Pending => {
                *state = State::Rejected(error);
            }
            _ => panic!("Promise already resolved"),
        }
    }
}

enum State<T> {
    Pending,
    Resolved(T),
    Rejected(String),
}

struct FuturePromise<T> {
    state: Arc<Mutex<State<T>>>,
}

impl<T> Future for FuturePromise<T> {
    type Output = Result<T, String>;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let mut state = self.state.lock().unwrap();
        match &mut *state {
            State::Pending => Poll::Pending,
            State::Resolved(value) => {
                let value = std::mem::replace(value, unsafe { std::mem::uninitialized() });
                Poll::Ready(Ok(value))
            }
            State::Rejected(error) => {
                let error = std::mem::replace(error, unsafe { std::mem::uninitialized() });
                Poll::Ready(Err(error))
            }
        }
    }
}

unsafe impl<T> Send for Promise<T> {}
unsafe impl<T> Sync for Promise<T> {}
unsafe impl<T> Send for FuturePromise<T> {}
unsafe impl<T> Sync for FuturePromise<T> {}

fn main() {
    let (promise, future) = Promise::new();
    let handle = std::thread::spawn(move || {
        std::thread::sleep(std::time::Duration::from_secs(1));
        promise.set_value(42);
    });
    let result = futures::executor::block_on(future);
    handle.join().unwrap();
    println!("{:?}", result);
}

这个实现使用了Arc，Mutex和UnsafeCell来实现线程安全的状态共享。FuturePromise实现了Future trait，它持有一个Mutex来保护状态。在poll方法中，它首先获取Mutex的锁，然后检查状态是否已经解决。如果状态是Pending，则返回Pending，否则返回Ready结果，同时从状态中提取值或错误。Promise实现了set_value和set_error方法，它们分别将状态设置为Resolved或Rejected状态，并在状态已经解决时抛出错误。在main函数中，我们创建一个Promise和FuturePromise对，并使用线程来解决Promise。最后，我们使用futures :: executor :: block_on函数等待FuturePromise结果，并打印它。