Rust实现无大型枚举的类型安全事件处理API遇阻求助

目标API风格 #

我长期以来的目标是实现如下风格的API：

struct GetEvent;

fn handler(_event: &mut GetEvent) {}

pub fn main() {
    let mut server = Server::default();

    server.handle(handler);

    server.emit(PostEvent);
}

注：名称和类型仅为示例，实际程序与HTTP无关

近两天我重新着手解决这个问题，多次感觉接近成功，但始终无法彻底实现，这让我十分头疼。

以下是我尝试的方案：

方案1：直接装箱 #

我初步尝试使用Any类型，创建了如下哈希表：

struct Server {
    handlers: HashMap<TypeId, Box<dyn Handler<dyn Any>>>,
}

fn handle<E>(&mut self, handler: impl Handler<E>) {
    self.handlers.insert(TypeId::of::<E>(), Box::new(handler));
}

但出现编译错误：

--> src/main.rs:26:49
   |
26 |         self.handlers.insert(TypeId::of::<E>(), Box::new(handler));
   |                                                 ^^^^^^^^^^^^^^^^^ the trait `for<'a> Fn(&'a mut (dyn Any + 'static))` is not implemented for `impl Handler<E>`, which is required by `impl Handler<E>: Handler<(dyn Any + 'static)>`
   |

我完全不理解这个错误，推测该方案不可行。

方案2：全程使用Any #

struct Server {
    handlers: HashMap<TypeId, Box<dyn Any>>,
}

fn handle<E: 'static>(&mut self, handler: impl Handler<E>) {
    self.handlers.insert(TypeId::of::<E>(), Box::new(handler));
}

这次编译成功了！但随后在实现emit方法时出现运行时错误：

fn emit<E: 'static>(&mut self, mut event: E) {
    let Some(handler) = self.handlers.get_mut(&TypeId::of::<E>()) else {
        println!("did not find handler...");
        return;
    };

    let handler = handler.downcast_ref::<Box<dyn Handler<E>>>().unwrap();

    handler.handle(&mut (event as E));
}

错误信息：

thread 'main' panicked at src/main.rs:36:69:
called `Option::unwrap()` on a `None` value

我认为原因是注册函数fn handle<E: 'static>(...)会被转为静态分发，存储的类型不是Box<dyn Handler<E>>，而是具体的函数指针类型。

方案3：先转为Handler trait #

fn handle<E: 'static>(&mut self, handler: impl Handler<E>) {
    let handler = Box::new(handler) as Box<dyn Handler<E>>;
    self.handlers.insert(TypeId::of::<E>(), handler);
}

但出现编译错误：

= note: expected struct `Box<(dyn Any + 'static)>`
                found struct `Box<dyn Handler<E>>`

尝试让Handler trait继承Any + 'static，但又出现：

cannot cast `dyn Handler<E>` to `dyn Any`, trait upcasting coercion is experimental

方案4：尝试类型擦除 #

我尝试定义HandlerErased trait：

trait HandlerErased {
    fn handle(&self, event: &mut dyn Any);
}

impl<E, H: Handler<E>> HandlerErased for H {
    fn handle(&self, event: &mut dyn Any) {
        // Check if correct type
        todo!();
    }
}

但出现编译错误：

error[E0207]: the type parameter `E` is not constrained by the impl trait, self type, or predicates
  --> src/main.rs:24:6
   |
24 | impl<E, H: Handler<E>> HandlerErased for H {
   |      ^ unconstrained type parameter

我还尝试了其他方案，但均无成效。我知道可以使用大型枚举实现，但当前API过于繁琐，我的目标是让API使用者能按需处理事件，同时希望无需宏即可检测并生成服务器能力相关值。

解决方案 #

要实现目标中的类型安全事件系统，核心是通过类型擦除统一处理器的调用接口，同时在编译期绑定事件与处理器的类型匹配。以下是可行的实现：

1. 定义核心Trait #

首先定义Handler trait，并为函数指针实现该Trait，支持直接传递函数作为处理器：

use std::any::{Any, TypeId};
use std::collections::HashMap;

// 处理特定事件类型的Trait
trait Handler<E> {
    fn handle(&self, event: &mut E);
}

// 为任意符合签名的函数实现Handler
impl<E, F> Handler<E> for F
where
    F: Fn(&mut E),
{
    fn handle(&self, event: &mut E) {
        self(event);
    }
}

2. 实现类型擦除的包装Trait #

定义一个擦除了具体事件类型的Trait，让所有处理器可以被统一存储和调用：

// 擦除事件类型的统一处理器Trait
trait ErasedHandler {
    fn handle_erased(&self, event: &mut dyn Any);
}

// 为任意Handler<E>实现ErasedHandler
impl<E: 'static, H: Handler<E>> ErasedHandler for H {
    fn handle_erased(&self, event: &mut dyn Any) {
        // 将dyn Any向下转型为具体的E类型，转型成功则调用处理器
        if let Some(event) = event.downcast_mut::<E>() {
            self.handle(event);
        }
    }
}

这里E: 'static是必要约束，确保事件类型可以安全地与Any trait交互。

3. 实现Server结构体 #

Server通过TypeId作为键，存储装箱后的ErasedHandler实例：

#[derive(Default)]
struct Server {
    handlers: HashMap<TypeId, Box<dyn ErasedHandler>>,
}

impl Server {
    // 注册处理器：将具体的Handler<E>转为ErasedHandler存储
    fn handle<E: 'static>(&mut self, handler: impl Handler<E> + 'static) {
        self.handlers.insert(
            TypeId::of::<E>(),
            Box::new(handler) as Box<dyn ErasedHandler>,
        );
    }

    // 触发事件：根据事件类型找到对应处理器并调用
    fn emit<E: 'static>(&mut self, mut event: E) {
        match self.handlers.get(&TypeId::of::<E>()) {
            Some(handler) => handler.handle_erased(&mut event as &mut dyn Any),
            None => println!("No handler found for event type: {:?}", TypeId::of::<E>()),
        }
    }
}

4. 使用示例 #

// 自定义事件类型
struct GetEvent;
struct PostEvent {
    data: String,
}

// 处理器函数
fn handle_get(_event: &mut GetEvent) {
    println!("Handling GetEvent");
}

fn handle_post(event: &mut PostEvent) {
    println!("Handling PostEvent with data: {}", event.data);
}

pub fn main() {
    let mut server = Server::default();

    // 注册处理器
    server.handle(handle_get);
    server.handle(handle_post);

    // 触发事件
    server.emit(GetEvent);
    server.emit(PostEvent { data: "Hello World".to_string() });
}

运行输出：

Handling GetEvent
Handling PostEvent with data: Hello World

方案说明 #

• 类型安全：编译期确保处理器与事件类型匹配，emit时无对应处理器只会打印提示，不会触发panic。
• 无宏依赖：所有逻辑通过Trait实现，无需额外宏生成代码。
• 扩展性强：新增事件类型和处理器无需修改Server核心逻辑，只需实现对应函数即可。

内容的提问来源于stack exchange，提问作者Elias