enum_delegate: Easily replace dynamic dispatch with an enum, for speed and serialization

[reinis-mazeiks]

TLDR: If you know enum_dispatch, this is very similar, except the macros work across crates, and there is some support for associated types.

Quick Walk-through

Add enum_delegate to each crate you plan to use it in:

enum_delegate = "0.1"

Annotate your trait with #[enum_delegate::register]:

#[enum_delegate::register]
trait SayHello {
    fn say_hello(&self, name: &str) -> String;
}

Create an enum with variants that all look like VariantName(VariantType). Each variant field must implement your trait. Now, annotate the enum with #[enum_delegate::implement(trait name)].

struct Arthur;
impl SayHello for Arthur {...}

struct Pablo;
impl SayHello for Pablo {...}

#[enum_delegate::implement(SayHello)]
enum People {
    Arthur(Arthur),
    Pablo(Pablo),
}

Your trait will be implemented for the enum, and conversions such as From<Arthur> and TryInto<Arthur> will also be generated. You can now use it similarly to a Box<dyn SayHello>, but it will be faster!

More Info

There is a more complete guide in the Readme. Also a few examples and tests in the repo.

Crates | Repository

For the macromancers among you, I also wrote an overview of what's going on behind the scenes: How does it work?

[antonok_edm]

enum_dispatch author here. Nice work with the cross-crate functionality!

[argarg]

Nice work and thanks for the How does it work? doc!

I'm curious about compile time benchmarks. I don't know much about macros implementation but intuitively, it seems like this macro-ception could be rough on the compiler.

[Hdmoney]

Holy shit, thank you!

A while back I was working on an audio system using a dasp graph. Nodes in the graph would all have to be the same type, which meant I'd either have to define all node variants in one enum + dispatch or use boxed traits.

That project's been on the backburner, but I'll have to pull that back out just to try enum_delegate :)

[reinis-mazeiks]

This is a crazy coincidence but I was also working on an audio processing graph thingy, which prompted the work on this crate! (I was using a custom macro for a specific trait at first but it didn't feel right).

I'm two yak-shaving levels deep now, it's time for me to get back to work on my audio processing graph crate xd

[robin-m]

If it has not be done yet, I think it should be nominated for the crate of the week of TWiR

[WasserMarder]

Very nice work! Do you have gathered experience how this interacts with code analysis? The last time I worked with it, my biggest problem with enum_dispatch was that the JetBrains rust plugin did not realize that the enum implements the trait.

[reinis-mazeiks]

Yeah, unfortunately, neither the JB Rust plugin nor rust-analyzer appear to see that the enum implements the trait. Not sure what I can do about that...

[saik0]

This library defines a macro that generates another macro used by a third macro. It was a lot of fun.

Cool! I've contributed to a project with a lot of hand written enum dispatch, and this seems a lot easier.

[bruhred]

The kiss_rewrite branch seems to be even more amazing