Replace 'timeout.trp' with 'ThreadUtil' module

This also adds the start of a 'Time' module (which is what I initially thought
would be the place to put the new timeout function.

Author: ssoelvsten

examples/fromuserguide/basic_updateableserver.trp

@@ -1,4 +1,5 @@
-import timeout
+import ThreadUtil
+
 let fun v_one n =
          receive [ hn ("REQUEST", senderid) => 
                         let val _ = send (senderid, n) 
@@ -26,7 +27,8 @@ let fun v_one n =
     val _ = send (service, ("UPDATE", v_two))
     val _ = send (service, ("COMPUTE", self(), fn x => x * x, 42))
     val _ = receive [ hn x => print x]
-in exitAfterTimeout 
-        authority 1000 0 "force terminating the server example after 1s"
+in ThreadUtil.spawnTimeout (fn () => print "force terminating the server example after 1s";
+                                     exit (authority, 0))
+                           1000
 end    
 

lib/Makefile

@@ -5,6 +5,7 @@ build:
   # Standard Library
 	$(COMPILER) ./Number.trp -l
 	$(COMPILER) ./List.trp -l
+	$(COMPILER) ./ThreadUtil.trp -l
 	$(COMPILER) ./ListPair.trp -l
 	$(COMPILER) ./DeclassifyUtil.trp -l
 	$(COMPILER) ./String.trp -l
@@ -13,8 +14,6 @@ build:
 	$(COMPILER) ./StencilVector.trp -l
 	$(COMPILER) ./HashMap.trp -l
 	$(COMPILER) ./HashSet.trp -l
-  # Old stuff, here be dragons...
-	$(COMPILER) ./timeout.trp -l
 
 clean:
 	rm -rf out

lib/README.md

@@ -15,6 +15,7 @@ reviewed rigorously rather than depend on the monitor.
 - `Number`         : Operations for numbers, i.e. integer and floats.
 - `StencilVector`  : Memory-efficient implementation of small (sparse) arrays.
 - `String`         : Operations for strings
+- `ThreadUtil`     : Additional functions for thread management.
 - `Unit`           : Unit testing.
 
 ## How to add a new file
@@ -34,6 +35,11 @@ target of the *makefile*.
 - Each function that is exported has to be documented (`(** <text> *)`). In the long run, we will
   auto-generate documentation for the Standard Library.
 
+### Other notes
+
+- The `ThreadUtil` module was initially named `Thread`. But, this suggests incorrectly, that
+  threading is implemented here rather than being a language primitive.
+
 ## TODO
 
 The [modules](#modules) mentioned above already follow the [design principles](#design-principles).

lib/ThreadUtil.trp

@@ -0,0 +1,23 @@
+let (** Run function `f` after `duration` milliseconds. The function `f` is given `()` as its
+     *  argument. *)
+    fun spawnTimeout f duration =
+        spawn (fn () => sleep duration; f ())
+
+    (** Run function `f` each `duration` milliseconds. The function `f` is given the current
+     *  iteration count as argument. *)
+    fun spawnInterval f duration =
+        (* TODO: If `f` takes a considerable time, this will drift! *)
+        let fun f' i = sleep duration; f i; f' (i+1)
+        in spawn (fn () => f' 0) end
+
+    (* TODO: Cancel `spawnTimeout` and `spawnInterval`. But, this requires a non-blocking `receive`
+     *       operation. *)
+
+    (*--- Module ---*)
+    val ThreadUtil = {
+        spawnTimeout,
+        spawnInterval
+    }
+
+in [ ("ThreadUtil", ThreadUtil) ]
+end