What strategy should be used to initialize an actor state asynchronously?

[tylerhjones]

For example the initialStateFunc is:

  initializeState () {
    if (this.initialStateFunc) {
      try {
        this.state = this.initialStateFunc(this.createContext(undefined));
      } catch (e) {
        this.handleFault(undefined, undefined, e);
      }
    } else {
      this.state = this.initialState;
    }
  }

I want to create an actor which is wrapping a document the user edits. My store for this document acts asynchronously, so how can I ensure that messages sent to this actor will be acting on the latest version of the inner document?
Am I supposed to dispatch a message from inside the initialStateFunc? would doing so even be possible?

[ncthbrt]

Are you using nact or @nact/core? The latter supports async init functions.

[ncthbrt]

Alternatively, you could dispatch a message immediately after creating the actor inside the initialStateFunction (as context is available). This would guarantee that the message would be processed first

[tylerhjones]

Ill try the message approach to be more 'actor-ish' as thats part of what im trying to experiment with.
However to understand a bit more about your question, im not sure what the difference is or which I am using; nact/@nact/core.
Im using what ever yarn/npm gave me for the getting started in https://nact.xyz/en_uk/lesson/javascript/getting-started
Ive been reading the src files and tests from this repo for information.

Where / what is @nact/core ?

doh, I see, its on the next branch -> https://github.com/nactio/nact/blob/next/%40nact/core
Im using the older version from the getting started.

I can consider switching to the next branch and playing with it, but im not super confident in my js language understanding to be able to understand how to accomplish things just from the src.
upcoming problems up on the list:

• how to resume a system and startup a list of top level actors. (currently im using an actor with state which spawns the other actors with the system as parent, but the known issue is that I cannot know if those actors were spawned before they start to communicate or if outside the system msgs are sent before they are spawned and msgs are not deliverable.)
• how to build a msg tracing plugin to know relations between actors. (i see the plugin mechanic and how it passes the system to the plugin function where i guess you modify the system as needed, but tbd/more learning on approach)
• how to abstract persistence on an actor. (im just not yet confident in the way to accomplish it or the side effect behaviors of my choices for persistence yet. I was using pouch db for storing 'documents' with actors as the owners of those documents, but they often get msgs that do not change doc state, so I need to build the wrapper to check current and previous state before updating the storage, but I also wanted to keep it open enough to allow an external pouchdb where the document can be updated by other systems and have my abstraction handle the collisions/ apply updates as needed.

Would the next version be worth switching to for these given my experience?

Lots of learning and play testing. Enjoying the nact library so far, much simpler than some other frameworks Ive seen or played with.