the entire etude

Author: begoon

.github/workflows/ci.yaml

@@ -0,0 +1,14 @@
+name: ci
+on:
+    push:
+        paths-ignore: ["README.md"]
+    workflow_dispatch:
+jobs:
+    build:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v5
+            - uses: oven-sh/setup-bun@v2
+            - uses: extractions/setup-just@v3
+            - run: just ci
+            - run: just test-docker

Justfile

@@ -1,7 +1,10 @@
 abc:
 
 factorial:
-    bun trac.ts "@#(ps,50!=)'" factorial.trac
+    bun trac.ts "@#(ps,50!=)'" examples/factorial.trac
 
 test-watch:
     bun test --watch
+
+ci:
+    bun test

README.md

@@ -0,0 +1,51 @@
+# TRAC interpreter
+
+[<img src="trac.jpg">](trac.jpg)
+
+The repository contains a TRAC interpreter described in the book [Etudes for Programmers](https://dl.acm.org/doi/10.5555/1096892) (1978) by Charles Wetherell.
+
+The interpreter is written in JavaScript and implements what is called the original TRAC-64 definition of the languages.
+
+The interpreter also implements additional functions and an ability to call forms as functions by name, suggested by Charles Wetherell as an extension of the etude.
+
+All functions are covered unit tests.
+
+NOTE: However, there are a few unimplemented functions: external stream I/O (`ai`, `ao`, `sp`, `rp`) and external block I/O (`sb`, `fb`, `eb`).
+
+## Examples
+
+### calculate "e" constant
+
+```sh
+node trac.ts examples/e.trac
+```
+
+### Calculate "pi"
+
+```sh
+node trac.ts examples/pi.trac
+```
+
+### Calculate factorial (of `50!`)
+
+```sh
+node trac.ts examples/factorial.trac
+```
+
+### Solve Hanoi puzze recursively
+
+```sh
+node trac.ts examples/hanoi.trac
+```
+
+## Testing
+
+### Prerequisites
+
+- bun.sh
+
+### Run tests
+
+```sh
+bun test
+```

examples/e.trac

@@ -0,0 +1,22 @@
+#(ds,Factorial,(#(eq,X,1,1,(#(ml,X,#(cl,Factorial,#(su,X,1)))))))'
+#(ss,Factorial,X)'
+
+#(ds,pow10,(#(eq,P,0,1,(#(ml,10,#(cl,pow10,#(su,P,1)))))))'
+#(ss,pow10,P)'
+
+#(ds,zeros,(#(eq,K,0,,(0#(cl,zeros,#(su,K,1))))))'
+#(ss,zeros,K)'
+
+#(ds,padfrac,(#(cl,zeros,#(su,P,#(sl,S)))S))'
+#(ss,padfrac,P,S)'
+
+#(ds,esum,(#(eq,N,0,#(ad,A,#(dv,S,1)),(#(cl,esum,#(su,N,1),#(ad,A,#(dv,S,#(cl,Factorial,N))),S)))))'
+#(ss,esum,N,A,S)'
+
+#(ds,N,15)'
+#(ds,P,10)'
+
+#(ds,S,#(cl,pow10,#(cl,P)))'
+#(ds,T,#(cl,esum,#(cl,N),0,#(cl,S)))'
+
+#(ps,#(dv,#(cl,T),#(cl,S)).#(cl,padfrac,#(cl,P),(#(su,#(cl,T),#(ml,#(dv,#(cl,T),#(cl,S)),#(cl,S))))))'

factorial.trac examples/factorial.tracfactorial.trac renamed to examples/factorial.trac

@@ -1 +1,3 @@
-#(ds,Factorial,(#(eq,X,1,1,(#(ml,X,#(cl,Factorial,#(su,X,1)))))))'#(ss,Factorial,X)'#(cl,Factorial,50)'
+#(ds,Factorial,(#(eq,X,1,1,(#(ml,X,#(cl,Factorial,#(su,X,1)))))))'
+#(ss,Factorial,X)'
+#(cl,Factorial,50)'

examples/hanoi.trac

@@ -0,0 +1,10 @@
+#(ds,other,(#(su,6,#(ad,this,that))))'
+#(ss,other,this,that)'
+
+#(ds,hanoi,(#(gr,N,1,
+(#(cl,hanoi,this,#(cl,other,this,that),#(su,N,1))#(ps,from this to that##(dc,10))#(cl,hanoi,#(cl,other,this,that),that,#(su,N,1))),
+(#(ps,from this to that##(dc,10)))
+)))'
+#(ss,hanoi,this,that,N)'
+
+#(hanoi,1,3,3)'

examples/pi.trac

@@ -0,0 +1,29 @@
+#(ds,pow10,(#(eq,P,0,1,(#(ml,10,#(cl,pow10,#(su,P,1)))))))'
+#(ss,pow10,P)'
+
+#(ds,pow,(#(eq,E,0,1,(#(ml,Q,#(cl,pow,Q,#(su,E,1)))))))'
+#(ss,pow,Q,E)'
+
+#(ds,padfrac,(#(gr,P,#(sl,S),(#(cl,padfrac,P,(0S))),S)))'
+#(ss,padfrac,P,S)'
+
+#(ds,denominator,(#(ml,#(ad,#(ml,2,K),1),#(cl,pow,Q,#(ad,#(ml,2,K),1)))))'
+#(ss,denominator,K,Q)'
+
+#(ds,term,(#(dv,scale,#(cl,denominator,K,Q))))'
+#(ss,term,scale,K,Q)'
+
+#(ds,atan,(#(eq,K,#(ad,N,1),A,(#(cl,atan,#(ad,K,1),N,Q,scale,#(su,0,sign),#(ad,A,#(ml,sign,#(cl,term,scale,K,Q))))))) )'
+#(ss,atan,K,N,Q,scale,sign,A)'
+
+#(ds,P,10)'
+#(ds,N5,14)'
+#(ds,N239,8)'
+
+#(ds,S,#(cl,pow10,#(cl,P)))'
+
+#(ds,T5,#(cl,atan,0,#(cl,N5),5,#(ml,16,#(cl,S)),1,0))'
+#(ds,T239,#(cl,atan,0,#(cl,N239),239,#(ml,4,#(cl,S)),1,0))'
+#(ds,T,#(su,#(cl,T5),#(cl,T239)))'
+
+#(ps,#(dv,#(cl,T),#(cl,S)).#(cl,padfrac,#(cl,P),(#(su,#(cl,T),#(ml,#(dv,#(cl,T),#(cl,S)),#(cl,S))))))'

info/cowan/Makefile

@@ -0,0 +1,2 @@
+dist:
+	shar READ.ME Makefile trac trac.1 trac.doc hanoi.trac | gzip >trac.shar.gz

info/cowan/READ.ME

@@ -0,0 +1,19 @@
+This is an implementation of the macro-processing language TRAC.
+
+The file `trac' is written in Perl, and implements a TRAC interpreter.
+You need to fetch a reasonably recent version of Perl (I used 4.0.36)
+if you don't have one already.
+
+The file `trac.doc' is an ASCII file (not a man page) which describes the
+language tersely but completely, explaining both the traditional
+implementation and the Perl one.
+
+The files `trac.1' and `Makefile' are there for the benefit of anal-retentives.
+The only `make' option is `make dist', which regenerates a shar file.
+
+The file `hanoi.trac' implements the Towers of Hanoi.  Commentary on it
+can be found in `trac.doc'.  To run it from the `trac' interpreter, type:
+
+	#(ld,hanoi.trac)
+	#(cl,hanoi,1,2,3)
+	'

info/cowan/hanoi.trac

@@ -0,0 +1,10 @@
+	#(ds,the other,(##(su,6,##(ad,this,that))))
+	#(ss,the other,this,that)
+	#(ds,hanoi,(#(gr,N,1,
+	(#(cl,hanoi,this,#(cl,the other,this,that),##(su,N,1))
+		#(ps,from this to that(
+))
+		#(cl,hanoi,#(cl,the other,this,that),that,##(su,N,1))),
+	(#(ps,from this to that(
+)))	)))
+	#(ss,hanoi,this,that,N)