Add new_ready to ActorOwned that immediately constructs an Actor in the ready state.

[khoover]

Roughly what it says on the tin, for Actors that don't have any real Prep behaviour, allow constructing them directly into the Ready state without needing to defer an apply_prep.

[uazu]

The intention is that a deferred call should be really fast so this is not a significant cost. All the actor calls will also have the deferred-call cost. Writing the deferred call arguments in the queue is not so different in cost to setting up a normal call on the stack (if registers aren't used). So it is fast. In addition, it's part of the actor contract that actor startup may be asynchronous.

Only the actor implementation code knows whether it needs prep time. The user code calling the actor can't know that in general. So you're hard-coding knowledge of the actor implementation into the user-code calling site, breaking the separation of concerns. So that means rewriting calling code if the actor changes its prep behaviour.

I guess we could have an actor_fast! macro which attempts to initialise the actor synchronously and panics if the actor doesn't support that. Or maybe have a different actor "init" method just for fast startup, which would make it a compilation error if the actor doesn't support it. I don't like either particularly. It's making special cases, and adding confusion.

Do you have a real-world situation that requires this? Does profiling show that it is a cost worth optimising?

[khoover]

The deferred call should be fast, but you do still end up paying a potential allocation/memcopy cost for deferring the prep. And it is part of the contract that it may, but when it isn't (e.g. the only prep method is def init(_cx: CX![], ...) -> Option<Self> { Some(Self::new(...)) }), there's an optimization to be had by skipping the Prep state entirely.

Only the actor implementation knows, sure, but if it's internal code to a library, then it can choose to make the new function crate-public to signal that it doesn't need any. And if it decides to require prep time later, simply make the function private again and you'll fail to compile until you make all the old sync instantiations into deferred ones.