simon/beowulf
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Huge amount of work, not much real progress.

Browse source
This commit is contained in:
Simon Brooke 2023-03-24 22:18:18 +00:00
parent 75da14790c
commit c0a362f213
No known key found for this signature in database
GPG key ID: A7A4F18D1D4DF987
12 changed files with 266 additions and 182 deletions
Download patch file Download diff file Expand all files Collapse all files

8
test/beowulf/bootstrap_test.clj
View file

@ -179,22 +179,22 @@
actual (MEMBER
(gsp "ALBERT")
(gsp "(ALBERT BELINDA CHARLIE DORIS ELFREDA FRED)"))]
(= actual expected))
(is (= actual expected)))
(let [expected 'T
actual (MEMBER
(gsp "BELINDA")
(gsp "(ALBERT BELINDA CHARLIE DORIS ELFREDA FRED)"))]
(= actual expected))
(is (= actual expected)))
(let [expected 'T
actual (MEMBER
(gsp "ELFREDA")
(gsp "(ALBERT BELINDA CHARLIE DORIS ELFREDA FRED)"))]
(= actual expected))
(is (= actual expected)))
(let [expected 'F
actual (MEMBER
(gsp "BERTRAM")
(gsp "(ALBERT BELINDA CHARLIE DORIS ELFREDA FRED)"))]
(= actual expected))))
(is (= actual expected)))))
(deftest pairlis-tests
(testing "pairlis"

22
test/beowulf/mexpr_test.clj
View file

@ -25,10 +25,10 @@
(deftest variable-tests
(testing "Variable translation"
(let [expected "X"
actual (print-str (generate (simplify (parse "x"))))]
actual (print-str (gsp "x"))]
(is (= actual expected)))
(let [expected "CAR"
actual (print-str (generate (simplify (parse "car"))))]
actual (print-str (gsp "car"))]
(is (= actual expected)))
))
@ -39,28 +39,30 @@
;; Wrapping in a function call puts us into mexpr contest;
;; "T" would be interpreted as a sexpr, which would not be
;; quoted.
(let [expected "(ATOM (QUOTE T))"
actual (print-str (generate (simplify (parse "atom[T]"))))]
(is (= actual expected)))
(let [expected "(ATOM (QUOTE A))"
actual (print-str (gsp "atom[A]"))]
(is (= actual expected)
"Atoms should normally be quoted"))
;; I'm not clear how `car[(A B C)]` should be translated, but
;; I suspect as (CAR (LIST 'A 'B 'C)).
))
(deftest fncall-tests
(testing "Function calls"
(let [expected "(CAR X)"
actual (print-str (generate (simplify (parse "car[x]"))))]
actual (print-str (gsp "car[x]"))]
(is (= actual expected)))
(let [expected "(FF (CAR X))"
actual (print-str (generate (simplify (parse "ff[car[x]]"))))]
actual (print-str (gsp "ff[car[x]]"))]
(is (= actual expected)))))
(deftest conditional-tests
(testing "Conditional expressions"
(let [expected "(COND ((ATOM X) X) ((QUOTE T) (FF (CAR X))))"
actual (print-str (generate (simplify (parse "[atom[x]->x; T->ff[car[x]]]"))))]
(let [expected "(COND ((ATOM X) X) (T (FF (CAR X))))"
actual (print-str (gsp "[atom[x]->x; T->ff[car[x]]]"))]
(is (= actual expected)))
(let [expected "(LABEL FF (LAMBDA (X) (COND ((ATOM X) X) ((QUOTE T) (FF (CAR X))))))"
(let [expected "(LABEL FF (LAMBDA (X) (COND ((ATOM X) X) (T (FF (CAR X))))))"
actual (print-str
(generate
(simplify

48
test/beowulf/sexpr_test.clj
View file

@ -10,19 +10,19 @@
(deftest atom-tests
(testing "Reading atoms"
(let [expected 'A
actual (generate (simplify (parse (str expected))))]
actual (gsp(str expected))]
(is (= actual expected)))
(let [expected 'APPLE
actual (generate (simplify (parse (str expected))))]
actual (gsp(str expected))]
(is (= actual expected)))
(let [expected 'PART2
actual (generate (simplify (parse (str expected))))]
actual (gsp(str expected))]
(is (= actual expected)))
(let [expected 'EXTRALONGSTRINGOFLETTERS
actual (generate (simplify (parse (str expected))))]
actual (gsp(str expected))]
(is (= actual expected)))
(let [expected 'A4B66XYZ2
actual (generate (simplify (parse (str expected))))]
actual (gsp(str expected))]
(is (= actual expected)))))
(deftest comment-tests
@ -54,67 +54,67 @@
(deftest number-tests
(testing "Reading octal numbers"
(let [expected 1
actual (generate (simplify (parse "1Q")))]
actual (gsp "1Q")]
(is (= actual expected)))
(let [expected -1
actual (generate (simplify (parse "-1Q")))]
actual (gsp "-1Q")]
(is (= actual expected)))
(let [expected 8
actual (generate (simplify (parse "1Q1")))]
actual (gsp "1Q1")]
(is (= actual expected)))
(let [expected -8
actual (generate (simplify (parse "-1Q1")))]
actual (gsp "-1Q1")]
(is (= actual expected)))
(let [expected 128
actual (generate (simplify (parse "2Q2")))]
actual (gsp "2Q2")]
(is (= actual expected)))
(let [expected 2093056
actual (generate (simplify (parse "777Q4")))]
actual (gsp "777Q4")]
(is (= actual expected))))
(testing "Reading decimal numbers - broadly should be homiconic"
(let [expected 7
actual (generate (simplify (parse "7")))]
actual (gsp "7")]
(is (= actual expected)))
(let [expected -7
actual (generate (simplify (parse "-7")))]
actual (gsp "-7")]
(is (= actual expected)))
(let [expected 3.141592
actual (generate (simplify (parse "3.141592")))]
actual (gsp "3.141592")]
(is (= actual expected)))
(let [expected 1234567890
actual (generate (simplify (parse "1234567890")))]
actual (gsp "1234567890")]
(is (= actual expected)))
(let [expected -45.23
actual (generate (simplify (parse "-45.23")))]
actual (gsp "-45.23")]
(is (= actual expected))))
(testing "Reading scientific notation")
(let [expected 2/5
actual (generate (simplify (parse "4E-1")))]
actual (gsp "4E-1")]
(is (< (abs (- actual expected)) 0.0001)))
(let [expected 60
actual (generate (simplify (parse "6E1")))]
actual (gsp "6E1")]
(is (< (abs (- actual expected)) 0.0001)))
(let [expected 60
actual (generate (simplify (parse "600.00E-1")))]
actual (gsp "600.00E-1")]
(is (< (abs (- actual expected)) 0.0001)))
(let [expected 60
actual (generate (simplify (parse "0.6E2")))]
actual (gsp "0.6E2")]
(is (< (abs (- actual expected)) 0.0001))))
(deftest dotted-pair-tests
(testing "Reading dotted pairs"
(let [expected "(A . B)"
actual (print-str (generate (simplify (parse expected))))]
actual (print-str (gsp expected))]
(is (= actual expected)))
(let [expected "(A B C . D)"
actual (print-str (generate (simplify (parse expected))))]
actual (print-str (gsp expected))]
(is (= actual expected)))
(let [expected "(A B (C . D) E)"
actual (print-str (generate (simplify (parse expected))))]
actual (print-str (gsp expected))]
(is (= actual expected)))))
(deftest list-tests
(testing "Reading arbitrarily structured lists"
(let [expected "(DEFUN FACT (X) (COND ((ZEROP X) 1) (T (TIMES X (FACT (SUB1 X))))))"
actual (print-str (generate (simplify (parse expected))))]
actual (print-str (gsp expected))]
(is (= actual expected)))))