Tart stepping


Stepping configuration implementation for Tiny Actor Run-Time in JavaScript.

@dalnefre, @tristanls

Stepping configuration implementation for Tiny Actor Run-Time in JavaScript.

To run the below example run:

npm run readme
"use strict";
var tart = require('../index.js');
var util = require('util');
var stepping = tart.stepping();
var createdBeh = function createdBeh(message) {};
var becomeBeh = function becomeBeh(message) {};
var oneTimeBeh = function oneTimeBeh(message) {
    var actor = this.sponsor(createdBeh); // create 
    actor('foo'); // send 
    this.behavior = becomeBeh; // become 
var actor = stepping.sponsor(oneTimeBeh);
var effect;
console.log(util.inspect(stepping, {depth: null}));
while ((effect = stepping.dispatch()) !== false) {
    console.log(util.inspect(effect, {depth: null}));
console.log(util.inspect(stepping, {depth: null}));
npm test

An event is an abstraction around the concept of a message being delivered to the actor. It is a tuple of a message and context. When an event is dispatched, the actor context is bound to this
and the context.behavior is executed with the message as a parameter. The result of processing the message is an effect.

An event has the following attributes:

  • context: Object Actor context the message was delivered to.
  • message: Any Message that was delivered.

An effect is an Object that is the effect of dispatching an event. It has the following attributes:

  • became: Function (Default: undefined) function (message) {} If the actor changed its behavior as a result of processing a message, the new behavior it became is referenced here.
  • behavior: Function (Default: undefined) function (message) {} The behavior that executed to cause this effect, if any.
  • created: Array An array of created contexts. A context is the execution context of an actor behavior (the value of this when the behavior executes).
  • event: Object (Default: undefined) The event that is the cause of this effect, if any.
  • exception: Error (Default: undefined) If dispatching the event caused an exception, that exception is stored here.
  • sent: Array An array of events that represent messages sent by the actor as a result of processing a message.

Public API

  • options: Object (Default: undefined) Optional overrides.
    WARNING: Implementation of enqueue and dequeue are tightly coupled and should be overridden together.
    • constructConfig: Function (Default: function (options) {}) function (options) {} Configuration creation function that is given options. It should return a capability function (behavior) {} to create new actors.
    • enqueue: Function function (eventQueue, events){} Function that enqueues the new events onto the eventQueue in place, causing side-effects _(Example: function (eventQueue, events){ Array.prototype.push.apply(eventQueue, events); })_.
    • dequeue: Function function (eventQueue){} Function that returns next event to be dispatched given an eventQueue _(Example: function (eventQueue){ return eventQueue.shift(); })_.
  • Return: Object The stepping control object.
    • dispatch: Function function () {} Function to call in order to dispatch a single event.
    • eventLoop: Function function ([control]) {} Function to call in order to dispatch multiple events.
    • effect: Object Accumulated effects from current step.
    • sponsor: Function function (behavior) {} A capability to create new actors.

Create a stepping control object.

  • Return: Effect or false. Effect of dispatching the next event or false if no events exists for dispatch.

Dispatch the next event.

var tart = require('tart-stepping');
var stepping = tart.stepping();
var effect = stepping.effect;
while ((effect = stepping.dispatch()) !== false) {
  • control: Object (Default: undefined) Optional overrides.
    • count: Number (Default: undefined) Maximum number of events to dispatch, or unlimited if undefined.
    • fail: Function function (exception) {} Function called to report exceptions thrown from an actor behavior. Exceptions are thrown by default. _(Example: function (exception) {/*ignore exceptions*/})_.
    • log: Function function (effect) {} Function called with every effect resulting from an event dispatch.
  • Return: Boolean true if event queue is exhausted, false otherwise.

Dispatch events in a manner provided by control.

By default, calling stepping.eventLoop() with no parameters dispatches all events in the event queue.

var tart = require('tart-stepping');
var stepping = tart.stepping();
var actor = stepping.sponsor(function (message) {
// foo 
// bar 
// baz 
  • behavior: Function function (message) {} Actor behavior to invoke every time an actor receives a message.
  • Return: Function function (message) {} Actor reference in form of a capability that can be invoked to send the actor a message.

Creates a new actor and returns the actor reference in form of a capability to send that actor a message.

var tart = require('tart-stepping');
var stepping = tart.stepping();
var actor = stepping.sponsor(function (message) {
    console.log('got message', message);