Table of Contents

HipHop Signals and Variables

Signals enable HipHop components to communicate with one another. They play a role akin to variables in traditional programming languages. They are the central component to store and exchange information between componnents. They also implement outside world communications. A signal is identified by its name. It can be local, i.e., defined locally inside a module and invisible outside this module, or global, that is defined as an input or as an output of the main module. Signals have a direction. A signal may be an input from the outside world, an output to the outside world, or used in both directions.

A signal can also carry a value. The value is specified by the emitter and transmitted to the receiver. If a same signal is to be emitted several times during a reaction with different values, a combination used to accumulate all the values must be specified when the signal is declared. The combination function is an arbitrary JavaScript but it must be associative and commutative.

A signal has four attributes that are invariant during a reaction:

 

Note the asymmetry between nowval and preval. The attribute nowval stores the most recent value emitted and it changes when a new emission happens. The attribute preval stores the value of the signal only at the previous reaction.

Variables are regular JavaScript variables. Assignments to variables should never be observed during a reaction. That is, a variable should never been read after having being assigned during a reaction. It is the responsibility of the program that ensure that this property holds.

Signal Declarations

Signals are declared in module signatures, possibly via an interface declaration or inside an HipHop statement, with the signal construct.

signal [direction] ident [= value] [combine function] ...

signal [direction] ... ident, ident [= value] [combine function] ...

signal implements [mirror] intf ...

☆ Formal syntax

See the module documentation for module signals.

The signal form enables to define local signals whose visibility is restricted to the block that define them. Example:

hiphop module M() {
  in S1; // module bound signal
  yield;
  signal L; // local signal only visible in the current block
  fork {
    await (S1.now);
    emit L(true);
  par {
    await (L.now);
  }
}

Module signals are declared with the keywords in, out, and inout. The signals can be used from outside of the machine to pass values in or to receive values after a reaction.

★ Example: samelocalname.hh.js 

import * as hh from "@hop/hiphop";
import { format } from "util";

hiphop module prg() {
   in SAME = 1;
   emit SAME( 2 );
   
   pragma { mach.outbuf += ( "1: " + SAME.nowval ) + "\n" }
   {
      signal S1=5, SAME=10;
      pragma { mach.outbuf += ( "before2: " + SAME.nowval ) + "\n"; }
      pragma { mach.outbuf += ( "before2bis: " + SAME.nowval ) + "\n"; }
      {
         signal SAME=100;
         pragma { mach.outbuf += ( "2: " + SAME.nowval ) + "\n"; }
      }

      pragma { mach.outbuf += ( "after2: " + SAME.nowval ) + "\n"; }
   }

   pragma { mach.outbuf += ( "3: " + SAME.nowval ) + "\n" }
}

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

Multiple emission with combine functions :

Signals can only be emitted once per instant, unless they are declared with a default value and a combination function. If such a function is specified, it must be associative and commutative. Signals associated with a combination function can be emitted several time during the reaction. The .nowval will contain all the values emitted during the reaction.

★ Example: incr-branch.hh.js 

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

hiphop module prg() {
   out O combine (x, y) => x + y;
   loop {
      fork "par" {
         emit O(1);
      }
      yield;
      yield;
   }
}

function add_emit(machine) {
   machine.getElementById("par").appendChild(hiphop emit O(1));
}

export const mach = new hh.ReactiveMachine(prg, { name: "incr-branch", sweep: false, dynamic: true });
mach.outbuf = "";
mach.debug_emitted_func = val => {
   mach.outbuf += (val.toString() ? "[ '" + val + "' ]\n" : "[]\n");
}

mach.react()
mach.react()
mach.react()
mach.react()
add_emit(mach);
mach.react()
mach.react()
mach.react()
add_emit(mach);
add_emit(mach);
add_emit(mach);
mach.react()
mach.react()

★ Example: toggle.hh.js 

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

function bool_and(x, y) {
   return x && y
}

function bool_or(x, y) {
   return x || y
}

function plus(x, y) {
   return x + y
}

hiphop module prg() {
   inout SEQ=1 combine plus;
   inout STATE1=false combine bool_or;
   inout STATE2=false combine bool_and;
   inout S;
   inout TOGGLE;
                
   loop {
      emit SEQ(SEQ.preval + 1);
      emit STATE1(true);
      emit STATE1(false);
      emit STATE2(true);
      emit STATE2(false);
      if (S.pre) {
         emit TOGGLE(true);
      } else {
         emit TOGGLE(false);
         emit S();
      }
      yield;
   }
}

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

The form signal implements [mirror] intf declares locally the signals declared in the interface intf. The optional keyword mirror swaps the input and output signals.

★ Example: imirror.hh.js 

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

hiphop interface Intf { in I; out O };

hiphop module M1() implements Intf {
   if (I.now) emit O();
}

hiphop module M2() implements mirror Intf {
   out OK;
   
   emit I();
   if (O.now) emit OK();
}

hiphop module Main() {
   inout OK;
   signal implements Intf;

   fork {
      run M1() { * };
   } par {
      run M2() { OK, + };
   }
}

export const mach = new hh.ReactiveMachine(Main);
mach.addEventListener("OK", v => mach.outbuf += "got OK\n");

mach.react();

Transient signals are declared with the addition of the transient keyword. They do not save their nowval value from one instant to the other, contrary to plain signals that do.

★ Example: transient.hh.js 

"use @hop/hiphop"
"use hopscript"

import { ReactiveMachine } from "@hop/hiphop";

hiphop module prg() {
   signal S;
   signal T transient;

   fork {
      emit S(1);
      emit T(2);
      yield;
      emit S(10);
      emit T(11);
      yield;
      yield;
      yield;
      yield;
      emit S(20);
      yield;
      emit S(30);
      emit T(31);
   } par {
      loop {
         pragma {
            mach.outbuf += ("S=" + S.now +" " + S.nowval + " " + S.preval) + "\n";
            mach.outbuf += ("T=" + T.now +" " + T.nowval + " " + T.preval) + "\n";
         }
         yield;
      }
   }
}

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

mach.react();
mach.react();
mach.react();
mach.react();
mach.react();
mach.react();
mach.react();
mach.react();
mach.react();

The form using the ... syntax enables several signals to share the same attributes. For instance in the declaration in ... x, y, z = 1, the three signals x, y, and z` will be initialized to 1.

★ Example: incr-branch2.hh.js 

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

hiphop module prg() {
   out ... O, P combine (x, y) => x + y;
   loop {
      fork "par" {
         emit O(1);
         emit P(1);
      }
      yield;
      yield;
   }
}

function add_emit(machine) {
   machine.getElementById("par").appendChild(hiphop { emit O(1); emit P(1); });
}

export const mach = new hh.ReactiveMachine(prg, { name: "incr-branch", sweep: false, dynamic: true });
mach.outbuf = "";
mach.debug_emitted_func = val => {
   mach.outbuf += (val.toString() ? "[ '" + val + "' ]\n" : "[]\n");
}

mach.react()
mach.react()
mach.react()
mach.react()
add_emit(mach);
mach.react()
mach.react()
mach.react()
add_emit(mach);
add_emit(mach);
add_emit(mach);
mach.react()
mach.react()

Variable Declarations

let ident [= value], ...,

☆ Formal syntax

Along with signals, HipHop supports local Hop variables. They are local variable carrying Hop values. These variable can be used in all the Hop expressions HipHop might used, for instance, for computing a delay, for producing an emission value, or for running asynchronous computation.

★ Example: variable.hh.js 

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

hiphop module prg() {
   in sig;
   let v = 1;

   every (sig.now) {
      if (sig.nowval > v) {
         pragma { v = sig.nowval + 1 }
      }

      pragma { mach.outbuf += ("v= " + v) + "\n" }
      yield;
   }
}

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

mach.react()
mach.react({sig: 0});
mach.react({sig: 10});

Using Signals in Expressions

Signals presence (has a signal been emitted or not during the reaction) and signal values can be used in HipHop JavaScript expressions. For that, HipHop analyses Hop expressions and detect signal accesses. It recognizes four syntactic constructs that correspond to signal access. Notice that these detections are only executed within the syntactic context of an HipHop expression:

signal.now

A predicate that is true if and only if signal has been emitted during the reaction.

signal.pre

A predicate that is true if and only if signal has been emitted during the previous reaction.

signal.nowval

The current value of the signal. Note that values are preserved from reaction to reaction so if a signal is emitted during reaction r1 and not at reaction i1 + 1, getting the value at reaction i1 + 1 will return the same value as reaction i1, although signal.now at reaction i1 + 1 will be false.

signal.preval

The previous value of the signal. The previous value corresponds to the value of the previous signal emission. Notice that the previous emission is not supposed to have happened during the previous reaction.

The following example illustrates the various values of now, pre, nowval, and preval along instants.

★ Example: npnvpv.hh.js 

import * as hh from "@hop/hiphop";
import { format } from "util";

hiphop module prg() {
   in A = "_"; in B;
   loop {
      pragma {
         mach.outbuf += ("A.now=" + A.now + " A.pre=" + A.pre + 
            " A.nowval=" + A.nowval + " A.preval=" + A.preval) + "\n";
         mach.outbuf += ("B.now=" + B.now + " B.pre=" + B.pre +
            " B.nowval=" + B.nowval + " B.preval=" + B.preval) + "\n";
      }
      yield;
   }
}

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

When executed with the following input signals. It generates the following output.

signal.signame

Returns the JavaScript name of a signal. This is useful when dealing with async forms (see async documentation).

Await, and Emit

await delay

☆ Formal syntax

It is frequent for a program to wait for one or several signals to be emitted. This can be acheived with the await construct, which waits for a condition to be true. The delay expression can be:

The await form is derived form from the elementary if and loop constructs. The form:

await immediate (expr);

is equivalent to:

loop {
  if (!expr) yield;
}

The form:

await (expr)

is equivalent to:

yield;
await immediate (expr);

The form:

await count(5, expr)

is equivalent to:

await (expr);
await (expr);
await (expr);
await (expr);
await (expr);

The form await (delay) is equivalent to:

endif: loop {
   yield;
   if (delay) break endif;
}

emit signal([ value ])

☆ Formal syntax

The emit form emit the value in the instant. The form emit sig1() emits a signal without value. The form emit sig2(val) emits a signal with a value.

 

If a valued signal is to be emitted several times within a single reaction it must be declared with a combinaison function that is a Hop function that must be commutative and associative. It is up to the Hop program to check and satisfy this requirement.

sustain signal([ value ])

☆ Formal syntax

Similar to emit but the emission is repeated at each instant. The statement

sustain sig(expr);

is equivalent to

loop {
   emit sig(expr);
   yield;
}

Examples

A module waiting sequentially for A and B to be emitted during distinct reactions and that emits O right after B is received.

★ await-seq.hh.js 

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

const prg = hiphop module() {
   in A; in B; out O;
            
   await (A.now);
   await (B.now);
   emit O();
}

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

A module that waits the event I to be present in three distinctive instants.

★ await-count.hh.js 

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

hiphop module prg() {
   in I; out O;
   loop {
      await count(3, I.now);
      emit O();
   }
}

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

A module using Hop variable inside HipHop statements.

★ variable.hh.js 

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

hiphop module prg() {
   in sig;
   let v = 1;

   every (sig.now) {
      if (sig.nowval > v) {
         pragma { v = sig.nowval + 1 }
      }

      pragma { mach.outbuf += ("v= " + v) + "\n" }
      yield;
   }
}

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

mach.react()
mach.react({sig: 0});
mach.react({sig: 10});

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