Use `holding` blocks for mutexed data instead of lambdas

1 files changed, 24 insertions, 32 deletions

diff --git a/test/threads.tm b/test/threads.tm
index 772c866f..adf7784a 100644
--- a/test/threads.tm
+++ b/test/threads.tm
@@ -2,55 +2,47 @@ enum Job(Increment(x:Int), Decrement(x:Int))
 
 func main():
     do:
-        >> with_nums := mutexed [10, 20, 30]
-        with_nums(func(nums:&[Int]):
+        >> nums := mutexed [10, 20, 30]
+        holding nums:
             >> nums[]
             = [10, 20, 30]
             nums:insert(40)
-        )
-        with_nums(func(nums:&[Int]):
+
+        holding nums:
             >> nums[]
             = [10, 20, 30, 40]
-        )
 
 
-    with_jobs := mutexed [Job.Increment(5)]
-    enqueue_job := func(job:Job):
-        with_jobs(func(jobs:&[Job]): jobs:insert(job))
-    dequeue_job := func():
-        job := @none:Job
-        with_jobs(func(jobs:&[Job]): job[] = jobs:pop(1))
-        job[]
+    jobs := mutexed [Job.Increment(5)]
 
-    with_results := mutexed [:Int]
-    enqueue_result := func(result:Int):
-        with_results(func(results:&[Int]): results:insert(result))
-    dequeue_result := func():
-        result := @none:Int
-        repeat:
-            with_results(func(results:&[Int]): result[] = results:pop(1))
-            stop if result[]
-            sleep(0.00001)
-        result[]!
+    results := mutexed [:Int]
 
     >> thread := Thread.new(func():
         !! In another thread!
         repeat:
-            job := dequeue_job() or stop
+            job := holding jobs: (jobs:pop(1) or stop)
             when job is Increment(x):
-                enqueue_result(x + 1)
+                holding results: results:insert(x + 1)
             is Decrement(x):
-                enqueue_result(x - 1)
+                holding results: results:insert(x - 1)
     )
 
-    enqueue_job(Decrement(100))
-    enqueue_job(Decrement(200))
-    enqueue_job(Decrement(300))
-    enqueue_job(Decrement(400))
-    enqueue_job(Decrement(500))
-    enqueue_job(Decrement(600))
+    holding jobs:
+        jobs:insert(Decrement(100))
+        jobs:insert(Decrement(200))
+        jobs:insert(Decrement(300))
+        jobs:insert(Decrement(400))
+        jobs:insert(Decrement(500))
+        jobs:insert(Decrement(600))
+        jobs:insert(Increment(1000))
 
-    >> enqueue_job(Increment(1000))
+    dequeue_result := func():
+        result := none:Int
+        repeat:
+            result = (holding results: results:pop(1))
+            stop if result
+            sleep(0.00001)
+        return result!
 
     >> dequeue_result()
     = 6