Planned v0.4.0 API changes (discussion)

[ddrcode]

This is a discussion / proposal topic. Let's discuss API changes that should be implemented in the next minor release. Breaking changes ar ok. Please add your proposals in comments. Any ideas welcome

Proposals (so far)

1. Public traits consistency (associated type in Topic)
2. Type redundancy cleanup (<E: Event, T: Topic<E>> into <T: Topic>)
3. ErrorAction as a result of on_error handler (see Improve on_error logic by returning ErrorAction  #12 )

Approved

• idea 3: ErrorAction (Improve on_error logic by returning ErrorAction  #12 )

[ddrcode]

Ok, two from me - related

1. Public traits inconsistency

Actor is

pub trait Actor {
    type Event;
    // ...
}

but Topic is

pub trait Topic<E: Event> { }

I would vote for associated type in Topic too, aligning it with Actor. That would also help with 2 (see below)

2. Remvoing information redundancy in <E: Event, T: Topic<E>>

The two generic types are scattered everywhere across the code - Supervisor, Broker, test harness, etc. But topic, especially if we introduce associated type, caries the information about the event, so we could have:

pub struct Supervisor<T: Topic> { ... }

and if event type ever needed, we could obtain it as T::Event. Single generic type, no redundancy.

The only drawback I see - DefaultTopic that would need to turn into DefaultTopic<E>. Besides that - I don't see other issues. I have implemented it, actually, ready for inspection. It's a big breaking change, so I'd value someones opinion.

See topic branch to explore how it looks like.

[vnermolaev]

Problem. Actors that emit events currently need to store Context<E> and wire it manually. This feels unnecessary: context is almost always injected, and this repeated setup looks like a good candidate for elimination.

Goal. The goal is automatic context injection with zero user work for all actors, including those that do not use context.

At the moment, full opacity is blocked by the API shape: context reaches actors only through the factory in Supervisor::add_actor, while actor callbacks do not accept context:

• handle_event(&mut self, envelope: &Envelope<Self::Event>)
• step(&mut self)

As a result, context must live in actor state when needed. Without trait/API changes, fully automatic hidden injection is not feasible in safe Rust.

Suggested design (opaque and safe): redesign actor callbacks so runtime passes context directly:

• handle_event(&mut self, ctx: &Context<Self::Event>, envelope: &Envelope<Self::Event>)
• step(&mut self, ctx: &Context<Self::Event>)
• optionally lifecycle hooks:
  • on_start(&mut self, ctx: &Context<Self::Event>)
  • on_shutdown(&mut self, ctx: &Context<Self::Event>)

Profit

• Context-specific fields in struct implementing Actor are not required, thus no manual wiring.
• less cloning.

[vnermolaev]

2. Remvoing information redundancy in <E: Event, T: Topic<E>>

I like that. It makes code simpler for comprehension and makes it more DRY.

The only drawback I see - DefaultTopic that would need to turn into DefaultTopic<E>.

This drawback is partially alleviated with the fact that the compiler can often deduce types, e.g.

let mut sup = Supervisor::<DefaultTopic<_>>::default();