Extended Observer pattern in rust with dynamic payloads

First of all, let's take a look at how we could make HashMap behave with enum variants with the same values even if the underlying data is different.

#[derive(Debug, Clone)] pub enum Event { ElementACreated(ElementA), ElementADeleted(ElementAId), ElementBCreated(ElementB>), ElementBDeleted(ElementBId), } 

It's fairly simple. To accomplish it need to implement Hash, PartialEq, and Eq with our own implementation instead of the derived one.

impl Hash for Event { fn hash<H: Hasher>(&self, state: &mut H) { match self { Event::ElementACreated(_) => { "ElementACreated".hash(state); } Event::ElementADeleted(_) => { "ElementADeleted".hash(state); } Event::ElementBCreated(_) => { "ElementBCreated".hash(state); } Event::ElementBDeleted(_) => { "ElementBDeleted".hash(state); } } } } // discriminant function returns a value uniquely identifying the enum variant impl PartialEq for Event { fn eq(&self, other: &Self) -> bool { std::mem::discriminant(self) == std::mem::discriminant(other) } } impl Eq for Event {} 

Then Event could be used as a key type for HashMap and as a data container. But here is a catch. Publisher accepts event in a subscribe function. pub fn subscribe(&mut self, event_type: Event, listener: Subscriber)

That leads to very inconvenient(bad) API design. The user must pass the event instance to the subscribe function.

let mut p = Publisher::default(); p.subscribe(Event::ElementACreated(...), |ev| { println!("Received event: {:?}", ev); }); 

To resolve this situation let's refactor the current design of the event to two enums and combine the structure with these two enums.

#[derive(Debug, Clone)] pub enum EventData { ElementA { id: ElementAId, name: String }, ElementAId(u64), ElementB { id: ElementBId, name: String }, ElementBId(u64), } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum EventType { ElementACreated, ElementADeleted, ElementBCreated, ElementBDeleted, } #[derive(Debug, Clone)] pub struct Event { event_type: EventType, data: EventData, } 

Then subscribe will look like this

pub fn subscribe(&mut self, event_type: EventType, listener: Subscriber) { self.events .entry(event_type.clone()) .or_default() .push(listener); println!("Subscribed to event: {:?}", event_type); } 

In notify, only data should be passed, and then the necessary event for that data can be determined.

pub(crate) fn notify(&self, data: EventData) { let event_type = match &data { EventData::ElementA { .. } => EventType::ElementACreated, EventData::ElementAId(_) => EventType::ElementADeleted, EventData::ElementB { .. } => EventType::ElementBCreated, EventData::ElementBId(_) => EventType::ElementBDeleted, }; let listeners = self.events.get(&event_type).unwrap(); for listener in listeners { listener(Event { event_type: event_type.clone(), data: data.clone(), }); } println!( "Notified {} listeners about event: {:?}", listeners.len(), event_type ); } 

P.S.

Also, Event could be obliterated, and Subscriber will pass EventType and EventData.

pub type Subscriber = fn(event_type: EventType, data: EventData);