refactor: rt/ cleanup (Part II)

compiler/src/IR.hs

@@ -306,6 +306,7 @@ instance WellFormedIRCheck IRExpr where
                      , "newlabel"                     
                      , "node"
                      , "_pc"
+                     , "_bl"
                      , "pcpop"
                      , "peek"
                      , "pinipush"

rt/README.md

@@ -0,0 +1,21 @@
+# Troupe Runtime
+
+## Structure
+
+The *src/* folder includes the implementation of Troupe's runtime. At its root
+is the key orchestration of the virtual machine runtime, e.g. its *Threads*,
+*Scheduler*, *Mailbox* and much more. Next to that, we have the following
+subdirectories to separate concerns.
+
+- `src/builtins`: Troupe's builtin functions and operations that are be called
+  by the user's program.
+
+- `src/base`: Troupe's base types and values, e.g. `LVal` (labelled value),
+  `list`, `record`.
+
+- `src/levels`: The labelled lattice for Troupe's IFC.
+
+- `src/p2p`: The peer-to-peer layer.
+
+There are also a few other folders, `src/dev` and `src/_experiments`. But, they
+can be ignored.

rt/src/AbstractLevel.mts

@@ -1,8 +1,8 @@
-import { TroupeType } from "./TroupeTypes.mjs";
-import { TroupeRawValue } from "./TroupeRawValue.mjs";
+import { TroupeType } from "./base/TroupeTypes.mjs";
+import { RawValue } from "./base/RawValue.mjs";
 
 export abstract class AbstractLevel <T extends AbstractLevel<T>> 
- implements TroupeRawValue {
+ implements RawValue {
   isLevel: boolean = true ;
   _troupeType: TroupeType = TroupeType.LEVEL
   abstract dataLevel;

rt/src/Asserts.mts

@@ -1,22 +1,19 @@
 import { Thread, Capability } from './Thread.mjs';
 
-import { isListFlagSet, isTupleFlagSet } from './ValuesUtil.mjs';
-import * as proc from './process.mjs';
-const ProcessID = proc.ProcessID;
+import { isAuthority, isBoolean, isList, isNumber, isProcessID, isString, isTuple, isUnit } from './base/rawUtil.mjs';
 import { AbstractLevel } from './AbstractLevel.mjs';
 import { Level } from './Level.mjs';
-import { Authority } from './Authority.mjs'
 import * as levels from './Level.mjs'; 
-import { TroupeType } from './TroupeTypes.mjs';
+import { TroupeType } from './base/TroupeTypes.mjs';
 const actsFor = levels.actsFor;
 
 import { getRuntimeObject } from './SysState.mjs';
 import { __nodeManager } from './NodeManager.mjs';
-import { TroupeAggregateRawValue, TroupeRawValue } from './TroupeRawValue.mjs';
+import { RawAggregate, RawValue } from './base/RawValue.mjs';
 // import { LVal } from './Lval';
 
 function _thread() {
-    return getRuntimeObject().__sched.__currentThread
+    return getRuntimeObject().__sched.getCurrentThread()
 }
 
 function __stringRep (v) {
@@ -33,7 +30,10 @@ function __stringRep (v) {
     }
 }
 
-let err = x => _thread().threadError(x)
+function err (errorMessage: string, internal: boolean = false) {
+    _thread().threadError(errorMessage, internal);
+}
+
 export function assertIsAtom (x: any) {
     _thread().raiseBlockingThreadLev(x.tlev)
     if (x.val._troupeType != TroupeType.ATOM ) {
@@ -42,27 +42,27 @@ export function assertIsAtom (x: any) {
 }
 
 export function rawAssertIsNumber (x) {
-    if (typeof x != 'number') {
+    if (!isNumber(x)) {
         err("value " + __stringRep(x) + " is not a number")
     }
 }
 
 export function assertIsNumber(x: any) {
     _thread().raiseBlockingThreadLev(x.tlev)
-    if (typeof x.val != 'number') {
+    if (!isNumber(x.val)) {
         err("value " + __stringRep(x) + " is not a number")
     }
 }
 
 export function assertIsBoolean(x: any) {
     _thread().raiseBlockingThreadLev(x.tlev);
-    if (typeof x.val != 'boolean') {
+    if (!isBoolean(x.val)) {
         err("value " + __stringRep(x) + " is not a boolean")
     }
 }
 
 export function rawAssertIsBoolean(x:any) {
-    if (typeof x != 'boolean') {
+    if (!isBoolean(x)) {
         err("value " + __stringRep(x) + " is not a boolean")
     }
 }
@@ -74,7 +74,7 @@ export function assertIsFunction(x: any, internal = false) {
 
 export function rawAssertIsFunction(x, internal = false) {
     if (x._troupeType != TroupeType.CLOSURE) {
-        _thread().threadError("value " + __stringRep(x) + " is not a function", internal)
+        err("value " + __stringRep(x) + " is not a function", internal)
     }
 }
 
@@ -95,15 +95,15 @@ export function assertIsHandler(x: any) {
 
 export function assertIsUnit(x: any) {
     _thread().raiseBlockingThreadLev(x.tlev);
-    if (!x.val._is_unit) {
+    if (!isUnit(x.val)) {
         err("value " + __stringRep(x) + " is not unit")
     }
 }
 
 
 export function assertIsListOrTuple(x: any) {
     _thread().raiseBlockingThreadLev(x.lev);;
-    if (!((isListFlagSet(x.val) || isTupleFlagSet(x.val)))) {
+    if (!((isList(x.val) || isTuple(x.val)))) {
         err("value " + __stringRep(x) + " is not a list or tuple")
     }
 }
@@ -114,28 +114,28 @@ export function assertIsList(x: any) {
 }
 
 export function rawAssertIsList (x:any) {
-    if (!isListFlagSet(x)) {
+    if (!isList(x)) {
         err("value " + __stringRep(x) + " is not a list")
     }
 }
 
 export function assertIsNTuple(x: any, n: number) {
     _thread().raiseBlockingThreadLev(x.lev);
-    if (!(Array.isArray(x.val) && isTupleFlagSet(x.val) && x.val.length == n)) {
+    if (!(Array.isArray(x.val) && isTuple(x.val) && x.val.length == n)) {
         err("value " + __stringRep(x) + " is not a " + n + "-tuple")
     }
 }
 
 
-export function assertIsNTupleR3 (x:TroupeRawValue, lev:Level, tlev:Level, n:number) {
+export function assertIsNTupleR3 (x:RawValue, lev:Level, tlev:Level, n:number) {
     _thread().raiseBlockingThreadLev(lev);
-    if (!(Array.isArray(x) && isTupleFlagSet(x) && x.length == n)) {
+    if (!(Array.isArray(x) && isTuple(x) && x.length == n)) {
         err("value " + __stringRep(x) + " is not a " + n + "-tuple")
     }
 }
 
 export function rawAssertIsTuple (x)  {
-    if (!(Array.isArray(x) && isTupleFlagSet(x) )) {
+    if (!(Array.isArray(x) && isTuple(x) )) {
         err("value " + __stringRep(x) + " is not a tuple")
     } 
 }
@@ -172,13 +172,13 @@ export function rawAssertIsRecord (x: any) {
 
 export function assertIsString(x: any) {
     _thread().raiseBlockingThreadLev(x.tlev);
-    if (typeof x.val != 'string') {
+    if (!isString(x.val)) {
         err("value " + __stringRep(x) + " is not a string")
     }
 }
 
 export function rawAssertIsString(x:any) {
-    if (typeof x != 'string') {
+    if (!isString(x)) {
         err("value " + __stringRep(x) + " is not a string")
     } 
 }
@@ -192,7 +192,7 @@ export function rawAssertNotZero(x:any) {
 
 export function assertIsNode(x: any) {
     _thread().raiseBlockingThreadLev(x.tlev);
-    if (typeof x.val != 'string') {
+    if (!isString(x.val)) {
         err("value " + __stringRep(x) + " is not a node string") // todo: check for it being a proper nodeid format?
     }
     if (x.val.startsWith("@")) {
@@ -204,7 +204,7 @@ export function assertIsNode(x: any) {
 
 export function assertIsProcessId(x: any) {
     _thread().raiseBlockingThreadLev(x.tlev);
-    if (!(x.val instanceof ProcessID)) {
+    if (!(isProcessID(x.val))) {
         err("value " + __stringRep(x) + " is not a process id")
     }
 }
@@ -241,14 +241,14 @@ export function assertIsRootAuthority(x: any) {
 
 export function assertIsAuthority(x: any) {
     _thread().raiseBlockingThreadLev(x.tlev);
-    if (!(x.val instanceof Authority)) {
+    if (!(isAuthority(x.val))) {
         err("value " + __stringRep(x) + " is not a authority");
     }
 }
 
 export function assertIsAuthorityR3(x, lev, tlev) {
     _thread().raiseBlockingThreadLev(x.tlev);
-    if (!(x instanceof Authority)){
+    if (!(isAuthority(x))){
         err("value " + __stringRep(x) + " is not a authority");
     }
 }