---

5.3.3 Using actormaps

As already shown, before using objects in an actormap, one must first create those objects in the context of that actormap:

Procedure: actormap-spawn actormap actor-constructor args … ¶

Spawn an actor inside actormap, but do not commit the transaction. Return a reference to the spawned object and a transactormap.

• actor-constructor: Constructor for the actor to be spawned.
• args: Arguments to actor-constructor.

Procedure: actormap-spawn! actormap actor-constructor args … ¶

Like actormap-spawn, but do commit the transaction.

Procedure: actormap-spawn-named actormap name actormap-constructor args … ¶

Like actormap-spawn, but uses name as the debug name for the object reference.

Procedure: actormap-spawn-named! actormap name actormap-constructor args … ¶

Like actormap-spawn!, but uses name as the debug name for the object reference.

Once objects have been put into an actormap, they may be invoked to perform some action . There are several ways to do this, falling into one of two general categories: turns and churns. A turn is the processing of a single message. A turn may generate additional near or far messages to be dispatched afterwards. A churn starts with a turn but then takes additional turns to process all subsequent near messages (which may in turn generate even more messages), halting when only far messages remain. In other words, a churn is a loop that takes one or more turns until it reaches quiescence.

Procedure: actormap-turn* actormap to-refr args ¶

Perform a single turn in actormap by invoking to-refr with the list of arguments args. Return the result of the invoked behavior, a new actormap, and a list of new messages generated by the turn.

Procedure: actormap-turn actormap to-refr args … ¶

Like actormap-turn*, but create a new generation of transaction with actormap as the parent and operate in it instead.

Procedure: actormap-turn-message actormap msg [#:error-handler simple-display-error] [#:reckless? #f] [#:catch-errors? #t] ¶

Return the result of msg in the context of actormap. How to handle errors and transactions is controlled by keyword args:

• error-handler: Procedure to handle errors. It is passed msg, the error, and the stack at the time of the error.
• reckless?: If #t, operate within actormap instead of creating a new generation; otherwise, create a new generation.
• catch-errors?: If #t, capture the stack and abort to a prompt; otherwise, propagate the error.

Procedure: actormap-peek actormap to-refr args … ¶

Perform a turn in actormap only to return the results; do not commit the transaction to the transaction history.

• to-refr: Object to be invoked.
• args: Arguments passed to to-refr.

Procedure: actormap-poke! actormap to-refr args … ¶

Perform a turn in actormap and commit the results, but ignore any messages generated by it. Return the results.

• to-refr: Object to be invoked.
• args: Arguments passed to to-refr.

Procedure: actormap-reckless-poke! actormap to-refr args … ¶

Like actormap-poke!, but commit the results to the current transaction generation without creating a new one. This voids Goblin’s transactionality guarantees like time travel.

Procedure: actormap-run actormap thunk ¶

Execute thunk in actormap, but do not commit the results. Return the results.

Procedure: actormap-run! actormap thunk [#:reckless? #f] ¶

Like actormap-run, and commit the results. If reckless? is #t, do not create a new generation for the turn.

Procedure: actormap-run* actormap thunk ¶

Like actormap-run, and return a reference to the new actormap as well as any messages generated.

Procedure: actormap-churn am msg [#:catch-errors? #t] [#:make-transactormap? #t] ¶

Perform every turn in am possible without needing to invoke far objects to resolve msg, then dispatch messages to the appropriate far objects.

• catch-errors?: If #f, do not handle errors.
• make-transactormap?: If #f, operate and commit in am instead of creating a new generation.

Procedure: actormap-churn-run actormap thunk [#:catch-errors? #t] ¶

Evaluate thunk in the context of actormap, performing all possible local invocations to resolve thunk. If catch-errors? is #f, do not handle errors. Return the results, a reference to the new actormap, and any messages generated.

Procedure: actormap-churn-run! actormap thunk [#:catch-errors? #t] ¶

Like actormap-churn-run, but dispatch messages and only return the results of the churn.

When performing any action in a transactormap, one may wish to (but, as has been shown, does not have to) commit the changes to the generational history of the overarching actormap.

Procedure: transactormap-merge! transactormap ¶

Commit the changes in transactormap to the generational history.

Procedure: transactormap-buffer-merge! transactormap ¶

Commit the changes in transactormap to its parent.