Control Flow Operators

Sequence, Test, Yield, and Parallelism

sequence

Sequences are implicit in HipHop. That is, two statements separated by a ; are executed sequentially.

pragma

The pragma form executes a JavaScript statement during the reaction.

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

hiphop module t() {
   in n;
   pragma { mach.outbuf +=  "1 " + n.nowval + "\n"; }
   pragma { mach.outbuf += "2\n"; }
}

export const mach = new hh.ReactiveMachine(t);
mach.outbuf = "";
mach.react({n: 34});

The JavaScript body may have signal dependencies.

★ Example: atom-dep-par.hh.js

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

hiphop module prg() {
   inout A combine (x, y) => x + y;
   
   fork {
      loop {
         emit A(0);
         yield;
      }
   } par {
      loop {
         emit A(1);
         pragma { mach.outbuf += A.nowval + "\n"; }
         yield;
      }
   } par {
      loop {
         emit A(2);
         pragma { mach.outbuf += A.nowval + "\n"; }
         yield;
      }
   }
}

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

mach.outbuf = "";
mach.debug_emitted_func = val => mach.outbuf += "[ '" + val + "' ]\n";

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

Under no circumstances JavaScript side effects must be observable from within a HipHop reaction. It is the responsability of the JavaScript program not to execute visible side effects. If such a side effect happen and is observed from within a HipHop reaction, its behavior becomes unpredictable.

if (delay) { block } [else { block }]

Execute the then block is delay is true, execute the optional else block otherwise. The delay expression can any JavaScript that evaluates to a boolean. If that expression uses signal attributes (now, pre, nowval, or preval), HipHop computes a flow dependency in order to evalute the delay only when all the values of these attributes are known.

For instance, the test:

if (!SIG.now) { ... }

depends on the now attribute of the signal SIG. It cannot be evaluated before it is know that SIG is emitted during the reaction or not. The HipHop runtime system computes these dependencies automatically.

A value of a signal can also be checked. For instance:

if(SIG.nowval > 10 && SIG.nowval < 100) { pragma { console.log("signal in range") } }

See staging for using dynamic signal names in delay expressions.

★ Example: if1.hh.js

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

const prg = hiphop module() {
   in I1; inout O1; in I2; inout O2;
   loop {
      if (I1.now) emit O1();
      if (I2.nowval > 2) emit O2();
      yield;
   }
}

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

yield

☆ Formal syntax

A thread of execution can suspend itself for the current instance using the yield construct. The execution will resume after the yield when the react method of the machine will be called again.

★ Example: weak.hh.js

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

const prg = hiphop module() {
   in S; out O, F, W;
   weakabort (S.now) {
      loop {
         emit O();
         yield;
         emit W();
      }
   }
   emit F();
}

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

★ Example: trap-par-3.hh.js

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

const prg = hiphop module() {
   inout S1_and_S2, S1_and_not_S2, not_S1_and_S2, not_S1_and_not_S2;
   signal S1, S2;

   loop {
      T1: fork {
         emit S1();
         yield;
         break T1;
      } par {
         T2: fork {
            emit S2();
            yield;
            break T2;
         } par {
            if( S1.now ) {
               if( S2.now ) {
                  emit S1_and_S2();
               } else {
                  emit S1_and_not_S2();
               }
            } else {
               if( S2.now ) {
                  emit not_S1_and_S2();
               } else {
                  emit not_S1_and_not_S2();
               }
            }
            yield;
         }
      }
   }
}

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

fork { ... } par { ... }

☆ Formal syntax

Run all the bodies in parallel. Complete when all bodies have completed. A body completes because it has executed all its statements or because it has exited using break.

★ Example: parallel-unary.hh.js

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

hiphop module prg() {
   out O;
   loop {
      signal L;

      fork {
         emit L();
      } par {
         fork {
            if (L.now) emit O();
         }
      }

      yield;
   }
}

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

This example uses two nested fork constructs. The second is synchronized with the first as it waits for an event the first branch is to emit.

★ Example: trap-loop-2.hh.js

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

const prg = hiphop module() {
   in A, B, R; out O;

   loop {
      pragma { mach.outbuf += ("loop " + mach.age() + "\n"); }
      T1: fork {
         pragma { mach.outbuf += ("S1\n"); }
         yield;
         break T1;
      }
   }
}
 
export const mach = new hh.ReactiveMachine(prg, "TRAP-LOOP-2");
mach.outbuf = "";

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

This second example uses a label and a break to terminate a parallel branch.

halt

Block infinitly the current thread. Keep in mind that a blocked thread can be suspended or even aborted.

★ Example: run-add-par.hh.js

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

hiphop module m1() {
   inout S, U, W, Z;
   fork {
      if (S.now) emit W();
   } par {
      if (U.now) emit Z();
   }
}

hiphop module run2() {
   inout S, U, A, B;
   fork "par" {
      run m1() { S, U, A as W, B as Z };
   } par {
      halt;
   }
}

export const mach = new hh.ReactiveMachine(run2, { name: "run-add-par", dynamic: true });
mach.outbuf = "";
mach.debug_emitted_func = val => {
   mach.outbuf += format(val) + "\n";
}

mach.outbuf += ("m.inputAndReact(S)") + "\n";
mach.react({S: undefined});

mach.getElementById("par").appendChild(hiphop run m1() { S, U, A as Z });

mach.outbuf += ("==================== ADD RUN PARALLEL ==================") + "\n";

mach.outbuf += ("m.inputAndReact(U)") + "\n";
mach.react({U: undefined});

Loop

Loops are so central HipHop program control flow that HipHop proposes several loop constructs, see derived forms. These are all based on a combination of the elementary loop construct and lexical espaces.

loop { ... }

☆ Formal syntax

This is the basis loop construct that implements an infinite loop

★ Example: sync1.hh.js

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

hiphop module prg() {
   out O;
   signal L;

   fork {
      loop {
         emit L();
         yield;
      }
   } par {
      loop {
         await(L.now);
         emit O();
      }
   }
}

export const mach = new hh.ReactiveMachine(prg, "sync1");
mach.outbuf = "";
mach.debug_emitted_func = emitted => {
   mach.outbuf += format(emitted) + "\n";
};

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

A loop can be interrupted by exiting with a break statement.

★ Example: trap-loop.hh.js

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

hiphop module prg() {
   out tick;
   signal cnt = 5;
   
   exit: loop {
      emit tick("loop" + cnt.preval);
      emit cnt(cnt.preval - 1);
      
      yield;

      if (cnt.preval === 0) {
         break exit;
      }
   }
   emit tick("done");
}
   
export const mach = new hh.ReactiveMachine(prg, "TRAP-LOOP");

It is not permitted to implement instantaneous loops, that is a loop for which two iterations may execute during the same reaction. This will be rejected by the compiler. All loops must have a yield statement in their control flow.

Suspension

suspend delay { block }

Suspend the execution of block while delay is true.

★ Example: suspend.hh.js

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

const prg = hiphop module() {
   in I; out J, O;
   suspend (I.now) {
      loop {
         emit O();
         yield;
      }
   }
   emit J();
}   

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

★ Example: trap-suspend.hh.js

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

export const mach = new hh.ReactiveMachine(
   hiphop module() {
      in L;
      T1: fork {
         break T1;
      } par {
         suspend (L.now) {
            yield;
         }
      }
      pragma { mach.outbuf += "exit trap\n"; }
   } );

mach.outbuf = "";
mach.react();

Lexical Escapes

HipHop supports an escape mechanism by the means for the exit/break constructs. They enable a program to abort an ongoing computation.

lbl

☆ Formal syntax

An exit is syntactically similar to a JavaScript label. it must be followed by a HipHop statement. This statement can be interrupted by breaking to that exit form.

break lbl

☆ Formal syntax

Abort the execution of the current statement and continue the execution after the statement that follows that break label. The break form can be used to abord an execution thread when used to escape a fork/par form.

★ Example: timeout.hh.js

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

hiphop module prg(resolve) {
   inout X = 1, Y, Z;
   T: {
      signal __internal = -1 combine (x, y) => x + y;

      loop {
         if (__internal.preval === -1) {
            emit __internal(X.nowval + 5);
         }
         if (__internal.nowval === 0) {
            break T;
         }
         async () {
            setTimeout(this.notify.bind(this), 10);
         }
         emit Y();
         emit __internal(__internal.preval - 1);
      }
   }
   emit Z();
   pragma { resolve(false); }
}

export const mach = new hh.ReactiveMachine(prg);
mach.outbuf = "";
mach.batchPromise = new Promise((res, rej) => mach.init(res));
mach.debug_emitted_func = val => val;

mach.addEventListener("Y", function(evt) {
   mach.outbuf += "Y emitted\n";
});

mach.addEventListener("Z", function(evt) {
   mach.outbuf += "Z emitted\n";
});

mach.react();

This example shows how to exit a loop.

★ Example: trap-par.hh.js

"use @hop/hiphop";
"use hopscript";

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

hiphop module prg() {
   inout A, B, C;
   T: fork {
      emit A();
      break T;
   } par {
      emit B();
      yield;
      emit C();
   }
}

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

This example shows how to exit a fork/par.

★ Example: trap-await-parallel.hh.js

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

hiphop module prg() {
   inout A, B;
   EXIT: fork {
      await(A.now);
      pragma { mach.outbuf += "A\n"; }
      break EXIT;
   } par {
      await(B.now);
      pragma { mach.outbuf += "B\n"; }
      break EXIT;
   }

   pragma { mach.outbuf += "end\n"; }
}

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

mach.react();
mach.react({B: undefined});

This example shows that several threads can decide to exit from a fork/par.

★ Example: p18.hh.js

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

function sum(arg1, arg2) {
   return arg1 + arg2;
}

hiphop module prg() {
   inout S1_and_S2, S1_and_not_S2, not_S1_and_S2, not_S1_and_not_S2;
   loop {
      T1: {
         signal S1;

         fork {
            yield;
            emit S1();
            break T1;
         } par {
            loop {
               T2: {
                  signal S2;
                  
                  fork {
                     yield;
                     emit S2();
                     break T2;
                  } par {
                     loop {
                        if(S1.now) {
                           if(S2.now) {
                              emit S1_and_S2();
                           } else {
                              emit S1_and_not_S2();
                           }
                        } else if(S2.now) {
                           emit not_S1_and_S2();
                        } else {
                           emit not_S1_and_not_S2();
                        }
                        yield;
                     }
                  }
               }
            }
         }
      }
   }
}

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

Derived Forms

every delay { ... }

☆ Formal syntax

A loop executed each time the delay is true. Abort the execution of the body when delay is true. Delays are documented here.

★ Example: every1.hh.js

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

hiphop module prg() {
   in I; out O;
   every (I.now) {
      emit O();
   }
}

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

All the delay forms can be used with every. ★ Example: every-delay.hh.js

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

hiphop module prg() {
   in I; out O;
   every count(2, I.now) {
      emit O();
   }
}

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

The form every is a derived form. The form:

every (expr) {
   ... body ...
}

is equivalent to:

await (expr);
loop {
  continue: fork {
    ... body ...
  } par {
    await (expr);
        break continue;
  }
}

do { ... } every delay

☆ Formal syntax

Execute the do's body and loop when test is true.

★ Example: loopeach.hh.js

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

hiphop module prg() {
   in I; out O;
   do {
      emit O();
   } every(I.now)
}

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

The form do/every is a dericed form. The form:

do { 
 ...
} every (expr);

is equivalent to:

loop {
  ... body ...
  await (expr);
}

abort delay { ... }

☆ Formal syntax

Execute the abort's body and abort the execution when delay is true.

★ Example: abort-par.hh.js

"use @hop/hiphop";
"use hopscript";

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

const prg = hiphop module() {
   in I; out O;
   signal L;
   
   fork {
      abort (L.now) {
         loop {
            emit O();
            yield;
         }
      }
   } par {
      await (I.now);
      emit L();
   }
}

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

★ Example: abortpre.hh.js

"use @hop/hiphop";
"use hopscript";

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

hiphop module prg() {
   inout O; inout S;
   loop {
      abort( S.pre ) {
         emit S();
         yield;
         emit O();
      }
      yield;
   }
}

//console.error(prg.pretty_print())

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

The form:

abort (expr) { ... body ... }

is equivalent to

exit: fork {
  ... body ... 
} par {
  await (expr);
  break exit;
}

weakabort delay { ... }

☆ Formal syntax

Execute the weakabort's body and abort the execution when delay is true at the end of the reaction

★ Example: loopeach-weakabort-emit.hh.js

"use @hop/hiphop";
"use hopscript";

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

export const mach = new hh.ReactiveMachine(
   hiphop module() {
      inout A; inout B;
      do {
         weakabort( B.now ) {
            fork {
               yield;
               emit B();
            }
         }
         pragma { mach.outbuf += ( "weakabort terminated 1." ) + "\n"; }
      } every( A.now )
   } );

mach.outbuf = "";
mach.react();
mach.react();
mach.react();
//mach.outbuf += ( machine.pretty_print() ) + "\n";

const machine2 = new hh.ReactiveMachine(
   hiphop module() {
      inout A; inout B;
      do {
         weakabort( B.now ) {
            fork {
               yield;
               emit B();
            }
         }
         pragma { mach.outbuf += ( "weakabort terminated 2." ) + "\n"; }
      } every( A.now )
   } );

machine2.react();
machine2.react();
machine2.react();
machine2.react();
//mach.outbuf += ( machine2.pretty_print() ) + "\n";

const machine3 = new hh.ReactiveMachine(
   hiphop module() {
      inout A; inout B;
      do {
         T: fork {
            await( B.now );
            break T;
         } par {
            yield;
            emit B();
         }
         pragma { mach.outbuf += ( "weakabort terminated 3." ) + "\n"; }
      } every( A.now )
   } );

machine3.react();
machine3.react();
machine3.react();
machine3.react();

★ Example: weak2.hh.js

"use @hop/hiphop";
"use hopscript";

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

hiphop module m() {
   in S; out O, F, W, Z;
   weakabort( S.now ) {
      loop {
         emit O();
         yield;
         emit W();
         yield;
         emit Z();
      }
   }
   emit F();
}
   
export const mach = new hh.ReactiveMachine( m, "wabort2" );

★ Example: weak-immediate.hh.js

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

hiphop module m() {
   in S; out O, F, W;
   weakabort immediate(S.now) {
      loop {
         emit O();
         yield;
         emit W();
      }
   }
   emit F();
}

export const mach = new hh.ReactiveMachine(m, "wabortimmediate")

The form:

abort (expr) { ... body ... }

is equivalent to

exit: fork {
  ... body ... 
} par {
  await (expr);
  break exit;
}

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

HipHop.js / flow

Table of Contents

Control Flow Operators

Sequence, Test, Yield, and Parallelism

sequence

pragma

if (delay) { block } [else { block }]

yield

fork { ... } par { ... }

halt

Loop

loop { ... }

Suspension

suspend delay { block }

Lexical Escapes

lbl

break lbl

Derived Forms

every delay { ... }

do { ... } every delay

abort delay { ... }

weakabort delay { ... }