Replace optional arguments for newly scheduled threads with an enum

This much better conveys the meaning of this argument, especially from the call site

Author: ssoelvsten

rt/src/Scheduler.mts

@@ -18,6 +18,16 @@ import {SYSTEM_PROCESS_STRING} from './Constants.mjs'
 import { getCliArgs, TroupeCliArg } from './TroupeCliArgs.mjs';
 const argv = getCliArgs();
 
+/** Enum for termination statuses. */
+export enum ThreadType {
+    /** System service thread. */
+    System = -1,
+    /** Main thread. */
+    Main   = 0,
+    /** Other threads, spawned from 'Main' or 'System'. */
+    Other  = 1
+}
+
 /** Enum for termination statuses. */
 enum TerminationStatus {
     /** Thread finished its computation. */
@@ -105,18 +115,16 @@ export class Scheduler implements SchedulerInterface {
                               arg: any,
                               pc: Level,
                               block: Level,
-                              ismain: boolean        = false,
-                              persist: boolean | null = null,
-                              isSystem: boolean      = false)
+                              tType: ThreadType = ThreadType.Other)
     {
         // Create a new process ID at the given level.
-        const pid = isSystem ? SYSTEM_PROCESS_STRING : uuidv4();
+        const pid = tType === ThreadType.System ? SYSTEM_PROCESS_STRING : uuidv4();
         const pidObj = new ProcessID(this.rt_uuid, pid, this.__node);
-        const newPid =  new LVal(pidObj, pc);
+        const newPid = new LVal(pidObj, pc);
 
         // Epilogue for thread.
-        const halt = ismain ?  () => { this.haltMain (persist) } :
-                               () => { this.haltOther () };
+        const halt = tType === ThreadType.Main ? () => { this.haltMain() }
+                                               : () => { this.haltOther() };
 
         // New thread
         const t = new Thread
@@ -197,7 +205,7 @@ export class Scheduler implements SchedulerInterface {
     }
 
     /** Epilogue for `main` thread: notify monitors, print and persist the final value  */
-    haltMain  (persist=null)  {
+    haltMain ()  {
         this.__currentThread.raiseCurrentThreadPCToBlockingLev()
         let retVal = new LVal (this.__currentThread.r0_val,
                                lub(this.__currentThread.bl, this.__currentThread.r0_lev),
@@ -207,6 +215,7 @@ export class Scheduler implements SchedulerInterface {
 
       delete this.__alive[this.__currentThread.tid.val.toString()];
         console.log(">>> Main thread finished with value:", retVal.stringRep());
+        const persist = argv[TroupeCliArg.Persist];
         if (persist) {
             this.rtObj.persist(retVal, persist)
             console.log("Saved the result value in file", persist)

rt/src/runtimeMonitored.mts

@@ -4,7 +4,7 @@ import { v4 as uuidv4 } from 'uuid'
 import AggregateError from 'aggregate-error';
 import { __unit } from './UnitVal.mjs'
 import { Authority } from './Authority.mjs'
-import { Scheduler } from './Scheduler.mjs'
+import { Scheduler, ThreadType } from './Scheduler.mjs'
 import { MailboxProcessor } from './MailboxProcessor.mjs'
 import { RuntimeInterface } from './RuntimeInterface.mjs'
 import { LVal, MbVal } from './Lval.mjs'
@@ -445,18 +445,15 @@ export async function start(f) {
           , service_arg
           , levels.TOP
           , levels.BOT
-          , false
-          , null
-          , true);
+          , ThreadType.System);
   }
 
   __sched.scheduleNewThreadAtLevel(
     () => f.main({__dataLevel:levels.BOT})
     , mainAuthority
     , levels.BOT
     , levels.BOT
-    , true
-    , argv[TroupeCliArg.Persist]
+    , ThreadType.Main
   );
   __sched.loop();
 }