Replace all occurrences of "Commit" with "Hold"

- A little CLI fun to do a global search and replace of "Commit"
with "Hold" in all files that are not in the vendor or .git directories:

```
find . -type f \( -name "*.tcl" -o -name "*.folk" -o -name "*.md" -o -name "*.js" \) \
  -not -path "*/vendor/*" \
  -not -path "*/.git/*" \
  -exec sed -i '' \
    -e 's/Commit/Hold/g' \
    -e 's/commit/hold/g' \
    -e 's/COMMIT/HOLD/g' \
    -e 's/Commits/Holds/g' \
    -e 's/commits/holds/g' \
    -e 's/COMMITS/HOLDS/g' \
    -e 's/Committed/Held/g' \
    -e 's/committed/held/g' \
    -e 's/COMMITTED/HELD/g' \
  {} +
```

- Double checked my work by running `rg -i commit --glob '!vendor'`,
  ensuring it doesn't return any results.

Author: cwervo

README.md

@@ -329,7 +329,7 @@ created. Therefore, it will eventually be useful for you to know
 syntax](https://www.ee.columbia.edu/~shane/projects/sensornet/part1.pdf).
 
 These are all implemented in `main.tcl`. For most things, you'll
-probably only need `Wish`, `Claim`, `When`, and maybe `Commit`.
+probably only need `Wish`, `Claim`, `When`, and maybe `Hold`.
 
 ### Wish and Claim
 
@@ -428,25 +428,25 @@ cool`.
 first-class object. You can use `&` joins in that pattern as
 well.)
 
-### Commit
+### Hold
 
-Experimental: `Commit` is used to register claims that will stick
-around until you do another `Commit`. You can use this to create the
+Experimental: `Hold` is used to register claims that will stick
+around until you do another `Hold`. You can use this to create the
 equivalent of 'variables', stateful statements.
 
 ```
-Commit { Claim $this has a ball at x 100 y 100 }
+Hold { Claim $this has a ball at x 100 y 100 }
 
 When $this has a ball at x /x/ y /y/ {
     puts "ball at $x $y"
     After 10 milliseconds {
-        Commit { Claim $this has a ball at x $x y [expr {$y+1}] }
+        Hold { Claim $this has a ball at x $x y [expr {$y+1}] }
         if {$y > 115} { set ::done true }
     }
 }
 ```
 
-`Commit` will overwrite all statements made by the previous `Commit`
+`Hold` will overwrite all statements made by the previous `Hold`
 (scoped to the current `$this`).
 
 **Notice that you should scope your claim: it's `$this has a ball`, not `there
@@ -459,13 +459,13 @@ If you want multiple state atoms, you can also provide a key -- you
 can be like
 
 ```
-Commit ball position {
+Hold ball position {
   Claim $this has a ball at blahblah
 }
 ```
 
-and then future commits with that key, `ball position`, will
-overwrite this statement but not override different commits with
+and then future holds with that key, `ball position`, will
+overwrite this statement but not override different holds with
 different keys
 
 (there's currently no way to overwrite state from other pages, but we
@@ -475,24 +475,24 @@ that if it was useful.)
 ### Every time
 
 Experimental: `Every time` works almost like `When`, but it's used to
-commit when an 'event' happens without causing a reaction cascade.
+hold when an 'event' happens without causing a reaction cascade.
 
 **You can't make Claims, Whens, or Wishes inside an `Every time`
-block. You can only Commit.**
+block. You can only Hold.**
 
 Example:
 
 ```
-Commit { Claim $this has seen 0 boops }
+Hold { Claim $this has seen 0 boops }
 
 Every time there is a boop & $this has seen /n/ boops {
-  Commit { Claim $this has seen [expr {$n + 1}] boops }
+  Hold { Claim $this has seen [expr {$n + 1}] boops }
 }
 ```
 
 If you had used `When` here, it wouldn't terminate, since the new
-`$this has seen n+1 boops` commit would cause the `When` to retrigger,
-resulting in a `$this has seen n+2 boops` commit, then another
+`$this has seen n+1 boops` hold would cause the `When` to retrigger,
+resulting in a `$this has seen n+2 boops` hold, then another
 retrigger, and so on.
 
 `Every time`, in contrast, will 'only react once' to the boop; nothing

lib/folk.js

@@ -250,9 +250,9 @@ class FolkWS {
     await this.evaluate(tcl`Assert when websocket $chan is connected [list {this __seq} ${message}] with environment [list $chan [incr ::__seq]]`);
   }
   // Evaluates inside a persistent match context that replaces any
-  // previous commit with same key:
-  async commit(key, program) {
-    await this.evaluate(tcl`Commit (non-capturing) (on $chan) ${key} ${program}`);
+  // previous hold with same key:
+  async hold(key, program) {
+    await this.evaluate(tcl`Hold (non-capturing) (on $chan) ${key} ${program}`);
   }
 
   async watchCollected(statement, onChange) {

main.tcl

@@ -183,9 +183,9 @@ proc After {n unit body} {
         }]] {*}$argValues]
     } else { error }
 }
-set ::committed [dict create]
-set ::toCommit [dict create]
-proc Commit {args} {
+set ::holdted [dict create]
+set ::toHold [dict create]
+proc Hold {args} {
     set this [uplevel {expr {[info exists this] ? $this : "<unknown>"}}]
     set key [list]
     set body [lindex $args end]
@@ -201,10 +201,10 @@ proc Commit {args} {
             lappend key $arg
         }
     }
-    set key [list Commit $this {*}$key]
+    set key [list Hold $this {*}$key]
 
     if {$body eq ""} {
-        dict set ::toCommit $key $body
+        dict set ::toHold $key $body
     } else {
         if {$isNonCapturing} {
             set argNames {}
@@ -213,7 +213,7 @@ proc Commit {args} {
             lassign [uplevel Evaluator::serializeEnvironment] argNames argValues
         }
         set lambda [list {this} [list apply [list $argNames $body] {*}$argValues]]
-        dict set ::toCommit $key $lambda
+        dict set ::toHold $key $lambda
     }
 }
 
@@ -228,22 +228,22 @@ proc StepImpl {} {
     # Receive statements from all peers.
     foreach peerNs [namespace children ::Peers] {
         upvar ${peerNs}::process peer
-        Commit $peer [list Say $peer is sharing statements [${peerNs}::receive]]
+        Hold $peer [list Say $peer is sharing statements [${peerNs}::receive]]
     }
 
-    while {[dict size $::toCommit] > 0 || ![Evaluator::LogIsEmpty]} {
-        dict for {key lambda} $::toCommit {
+    while {[dict size $::toHold] > 0 || ![Evaluator::LogIsEmpty]} {
+        dict for {key lambda} $::toHold {
             if {$lambda ne ""} {
                 Assert $key has program $lambda
             }
-            if {[dict exists $::committed $key] && [dict get $::committed $key] ne $lambda} {
-                Retract $key has program [dict get $::committed $key]
+            if {[dict exists $::holdted $key] && [dict get $::holdted $key] ne $lambda} {
+                Retract $key has program [dict get $::holdted $key]
             }
             if {$lambda ne ""} {
-                dict set ::committed $key $lambda
+                dict set ::holdted $key $lambda
             }
         }
-        set ::toCommit [dict create]
+        set ::toHold [dict create]
         Evaluator::Evaluate
     }
 
@@ -296,7 +296,7 @@ source "lib/math.tcl"
 
 
 # this defines $this in the contained scopes
-# it's also used to implement Commit
+# it's also used to implement Hold
 Assert when /this/ has program /__program/ {{this __program} {
     apply $__program $this
 }}

test/commit.tcl

@@ -1,9 +1,9 @@
 Assert programBall has program {{this} {
-    Commit { Claim $this has a ball at x 100 y 100 }
+    Hold { Claim $this has a ball at x 100 y 100 }
 
     When $this has a ball at x /x/ y /y/ {
         After 10 milliseconds {
-            Commit { Claim $this has a ball at x $x y [expr {$y+1}] }
+            Hold { Claim $this has a ball at x $x y [expr {$y+1}] }
             if {$y > 115} { set ::done true }
         }
     }
@@ -15,10 +15,10 @@ vwait ::done
 Retract programBall has program /something/
 
 Assert programUpdate has program {{this} {
-    Commit { Claim $this has seen 0 boops }
+    Hold { Claim $this has seen 0 boops }
 
     Every time there is a boop & $this has seen /n/ boops {
-        Commit { Claim $this has seen [expr {$n + 1}] boops }
+        Hold { Claim $this has seen [expr {$n + 1}] boops }
     }
 }}
 Assert there is a boop
@@ -36,9 +36,9 @@ assert {[dict get [lindex [Statements::findMatches [list /someone/ claims /thing
 
 Assert programTestReset has program {{this} {
     When $this has context color /color/ {
-        Commit { Claim $this has counter 0 }
+        Hold { Claim $this has counter 0 }
         Every time a button is pressed & $this has counter /counter/ {
-            Commit { Claim $this has counter [incr counter] }
+            Hold { Claim $this has counter [incr counter] }
         }
     }
 }}

test/stale.tcl

@@ -1,5 +1,5 @@
 for {set i 0} {$i < 30000} {incr i} {
-    Commit [list Claim the iteration count is $i]
+    Hold [list Claim the iteration count is $i]
     Step
 }
 

test/survival.tcl

@@ -14,11 +14,11 @@ Assert when we are running {{} {
 Assert we are running
 Step
 
-Commit Omar { Claim tag 1 was seen by Omar at home }
-Commit Mom { Claim tag 1 was seen by Mom at restaurant }
+Hold Omar { Claim tag 1 was seen by Omar at home }
+Hold Mom { Claim tag 1 was seen by Mom at restaurant }
 Step
 
-Commit Omar { Claim tag 1 was seen by Omar at work }
+Hold Omar { Claim tag 1 was seen by Omar at work }
 Step
 
 # Statements::print

user-programs/haippi7/laser-camera.folk

@@ -23,7 +23,7 @@ On process {
             set tags [::BlobDetect::detect $grayFrame $threshold]
         }]
 
-        Commit {
+        Hold {
             Claim the camera frame is $grayFrame
 
             Claim the camera time is $cameraTime

virtual-programs/camera.folk

@@ -378,7 +378,7 @@ Start process "camera" {
     set ::oldFrames [list]
     When $::thisProcess has step count /c/ {
         set frame [Camera::grayFrame]
-        Commit {
+        Hold {
             Claim the camera time is $::stepTime
             Claim the camera frame is $frame at [clock milliseconds]
         }

virtual-programs/display.folk

@@ -1684,7 +1684,7 @@ Start-display-process {
         }]
         if {$macos} { Gpu::poll }
 
-        Commit { Claim the display time is "render $renderTime us ($::stepTime)" }
+        Hold { Claim the display time is "render $renderTime us ($::stepTime)" }
     }
 }