Table of Contents

HipHop

The "hiphop" JavaScript module contains utilities for creating and running HipHop reactive machines.

Use import * as hiphop from "@hop/hiphop" to use it.

Once defined, a HipHop program must be loaded into a HipHop reactive machine that execute this program by running reactions. A reactive machine is an instance of the JavaScript ReactiveMachine class which is exported by the @hop/hiphop module.

Creating HipHop Reactive Machines

new hiphop.ReactiveMachine(hhprgm [, opts]) 

import { ReactiveMachine } from "@hop/hiphop";
import { mod } from "./prgm.hh.js";

const m = new ReactiveMachine(mod);

The optional opts argument can be:

If opts is an object, its optional properties are:

Running HipHop Reactive Machines

mach.react(sigset)

The react function machine reactions. If called with no argument, it proceed to one step. If called with one or several arguments, it proceeds as follows for each argument:

The react function returns the machine itself.

Example:

// proceed to one reaction
m.react(); 

// proceed to 4 reactions, with first the signal O emitded with value 24,
// P with value 53, then a second reaction with only o emitted with value 56,
// ...
m.react({ O: 24, P: 53 });
m.react({ O: 56 });
m.react({ O: 77 });
m.react({ P: 10 });

After a reaction, each output signal of the main program module is bound in the machine as a JavaScript property. For instance, is a reaction emits the signal O with value 1 at the first reaction of the machine m and O with value 2 at the second reaction, checking m.O after that reaction would return:

{ nowval: 2, preval: 1, now: true, pre: true }

For symmetry with the argument of the react method, its returned value is an object whose property names are the names of the signal emitted during the reaction and the property values the values associated to these signals.

mach.init(values)

Set the value of the machine's main module parameters. Can only be executed once, and before the machine first reaction.

★ Example: trap-kill.hh.js 

import * as hh from "@hop/hiphop";

export const mach = new hh.ReactiveMachine(
   hiphop module(resolve) {
      T: fork {
         async () {
            setTimeout(this.notify.bind(this), 100);
         }
         break T;
      } par {
         async () {
            setTimeout(this.notify.bind(this), 500);
         } kill {
            mach.outbuf = ("been killed\n");
         }
      }
      pragma { resolve(false); }
   });

mach.outbuf = "";
mach.batchPromise = new Promise((res, rej) => mach.init(res));
mach.react();

mach.input(sigset)

The input function emits signal in the machine but does not triggers the reaction. For instance,

m.input({ O: 24 });
m.input({ P: 53 })
m.react();

Is equivalent to

m.react({ O: 24, P: 53 })
m.react();

mach.age()

Return the number of reactions mach has already executed.

mach.name()

Return the machine name.

Interfacing with HipHop Reactive Machines

mach.promise(ressigname = "res", rejsigname = "rej")

Return a promise that resolves when the machine emits the signal named ressigname and that rejects when the machine emits the signal named rejsigname. The machine must define the two output signals ressigname and rejsigname.

★ Example: promise.hh.js 

import * as hh from "@hop/hiphop";

hiphop module prg() {
   out res, rej;
   emit res("resolved");
}

export const mach = new hh.ReactiveMachine(prg, "promise");
mach.outbuf = "";

mach.batchPromise = mach.promise().then(v => mach.outbuf += mach.name() + " " + v + "\n");
mach.react();

mach.addEventListener(signame, listener)

Associate a listener to the machine event signame.

Listeners are invoked with one object with one or two fields:

The stopPropagation() is a method that, if called within the listener, will inhibit the call of others callback mapped on this signal.

★ Example: reactfun.hh.js 

import * as hh from "@hop/hiphop";

function foo(evt) {
   m.outbuf += ("hi from foo signal " + evt.signame + " is set!\n");
}

function bar(evt) {
   m.outbuf += ("hi from bar signal " + evt.signame + " is set!\n");
}

function foo2(evt) {
   m.outbuf += ("hi from foo2 signal " + evt.signame + " is set with " + evt.nowval + " !\n");
}

function bar2(evt) {
   m.outbuf += ("hi from bar2 signal " + evt.signame + " is set with " + evt.nowval + " !\n");
}

hiphop module prg() {
   in I1; in I2; out O1, O11, O2;
   loop {
      if (I1.now) {
         emit O1();
         emit O11();
      }
      if (I2.now) {
         emit O2(I2.nowval);
      }
      yield;
   }
}

const m = new hh.ReactiveMachine(prg, "reactfunc");
m.outbuf = "";

m.addEventListener("O1", foo);
m.addEventListener("O11", foo);
m.addEventListener("O11", bar);
m.addEventListener("O2", foo2)
m.addEventListener("O2", bar2);

export const mach = m;

mach.removeEventListener(signame, listener)

Remove the listener from the machine.

mach.bindEvent(event, obj)

A shortcut for:

obj.addEventListener(event, e => mach.react({ [ event ]: e.value }));

[main page] | [documentation] | [license]