One struct, many tables... Reusable code?

[cryo-warden]

I have a struct that I want to split across different tables. The docs recommend reusing spacetimedb::table for this.

#[spacetimedb::table(name = observable_events, public)]
#[spacetimedb::table(name = early_events, public)]
#[spacetimedb::table(name = late_events, public)]
#[derive(Debug, Clone)]
pub struct Event {
    #[primary_key]
    #[auto_inc]
    pub id: u64,
    pub time: Timestamp,
    pub owner_entity_id: u64,
    pub event_type: EventType, // Non-empty enum! Can't filter, even if indexed. Will instead route to different tables on creation.
}

So far so good!

However, I want some of my code to operate on every table for this struct.

for event in ctx.db.early_events().iter() {
    ctx.db.early_events().id().delete(event.id);
}
for event in ctx.db.late_events().iter() {
    ctx.db.late_events().id().delete(event.id);
}
for event in ctx.db.observable_events().iter() {
    ctx.db.observable_events().id().delete(event.id);
}

Problem: The real code is much more complex than this, and I want to avoid repeating it if at all possible.

Is it really necessary that each table from the same struct be defined as a different type, even when they share all the same attributes? Is there any common type I could use to capture not only the Table trait, but also the indexes?

---

In the meantime, I have simplified the code inside my loops as much as possible, making some logic reusable directly from my Event struct. The only parts I can't reuse are the iteration logic and anything which would go back to the corresponding event table, such as updating the record after processing.

This is okay, but it feels like I'm failing to understand something that should be simple.

Update, 3 weeks later: After learning more about Rust macros, it looks like they're the ideal way to reduce boilerplate.