shen-ruby 0.6.0 → 0.7.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (23) hide show
  1. checksums.yaml +7 -0
  2. data/HISTORY.md +10 -0
  3. data/README.md +19 -17
  4. data/lib/kl/primitives/streams.rb +7 -17
  5. data/lib/shen_ruby/version.rb +1 -1
  6. data/shen/README.txt +1 -1
  7. data/shen/release/k_lambda/core.kl +56 -56
  8. data/shen/release/k_lambda/declarations.kl +8 -8
  9. data/shen/release/k_lambda/load.kl +15 -15
  10. data/shen/release/k_lambda/macros.kl +30 -28
  11. data/shen/release/k_lambda/prolog.kl +97 -97
  12. data/shen/release/k_lambda/reader.kl +91 -69
  13. data/shen/release/k_lambda/sequent.kl +53 -53
  14. data/shen/release/k_lambda/sys.kl +92 -108
  15. data/shen/release/k_lambda/t-star.kl +50 -55
  16. data/shen/release/k_lambda/toplevel.kl +23 -23
  17. data/shen/release/k_lambda/types.kl +2 -2
  18. data/shen/release/k_lambda/writer.kl +28 -22
  19. data/shen/release/test_programs/interpreter.shen +4 -6
  20. data/shen/release/test_programs/proof_assistant.shen +3 -3
  21. data/shen/release/test_programs/whist.shen +2 -2
  22. data/shen-ruby.gemspec +2 -2
  23. metadata +9 -13
data/shen/release/k_lambda/sequent.kl CHANGED
@@ -47,114 +47,114 @@
47
47
  * explains this license in full. *
48
48
  * *
49
49
  *****************************************************************************************
50
- "(defun shen.datatype-error (V1612) (cond ((and (cons? V1612) (and (cons? (tl V1612)) (= () (tl (tl V1612))))) (simple-error (cn "datatype syntax error here:
50
+ "(defun shen.datatype-error (V1632) (cond ((and (cons? V1632) (and (cons? (tl V1632)) (= () (tl (tl V1632))))) (simple-error (cn "datatype syntax error here:
51
51
 
52
- " (shen.app (shen.next-50 50 (hd V1612)) "
52
+ " (shen.app (shen.next-50 50 (hd V1632)) "
53
53
  " shen.a)))) (true (shen.sys-error shen.datatype-error))))
54
54
 
55
- (defun shen.<datatype-rules> (V1617) (let Result (let Parse_shen.<datatype-rule> (shen.<datatype-rule> V1617) (if (not (= (fail) Parse_shen.<datatype-rule>)) (let Parse_shen.<datatype-rules> (shen.<datatype-rules> Parse_shen.<datatype-rule>) (if (not (= (fail) Parse_shen.<datatype-rules>)) (shen.pair (hd Parse_shen.<datatype-rules>) (cons (shen.hdtl Parse_shen.<datatype-rule>) (shen.hdtl Parse_shen.<datatype-rules>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1617) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
55
+ (defun shen.<datatype-rules> (V1637) (let Result (let Parse_shen.<datatype-rule> (shen.<datatype-rule> V1637) (if (not (= (fail) Parse_shen.<datatype-rule>)) (let Parse_shen.<datatype-rules> (shen.<datatype-rules> Parse_shen.<datatype-rule>) (if (not (= (fail) Parse_shen.<datatype-rules>)) (shen.pair (hd Parse_shen.<datatype-rules>) (cons (shen.hdtl Parse_shen.<datatype-rule>) (shen.hdtl Parse_shen.<datatype-rules>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1637) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
56
56
 
57
- (defun shen.<datatype-rule> (V1622) (let Result (let Parse_shen.<side-conditions> (shen.<side-conditions> V1622) (if (not (= (fail) Parse_shen.<side-conditions>)) (let Parse_shen.<premises> (shen.<premises> Parse_shen.<side-conditions>) (if (not (= (fail) Parse_shen.<premises>)) (let Parse_shen.<singleunderline> (shen.<singleunderline> Parse_shen.<premises>) (if (not (= (fail) Parse_shen.<singleunderline>)) (let Parse_shen.<conclusion> (shen.<conclusion> Parse_shen.<singleunderline>) (if (not (= (fail) Parse_shen.<conclusion>)) (shen.pair (hd Parse_shen.<conclusion>) (shen.sequent shen.single (cons (shen.hdtl Parse_shen.<side-conditions>) (cons (shen.hdtl Parse_shen.<premises>) (cons (shen.hdtl Parse_shen.<conclusion>) ()))))) (fail))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<side-conditions> (shen.<side-conditions> V1622) (if (not (= (fail) Parse_shen.<side-conditions>)) (let Parse_shen.<premises> (shen.<premises> Parse_shen.<side-conditions>) (if (not (= (fail) Parse_shen.<premises>)) (let Parse_shen.<doubleunderline> (shen.<doubleunderline> Parse_shen.<premises>) (if (not (= (fail) Parse_shen.<doubleunderline>)) (let Parse_shen.<conclusion> (shen.<conclusion> Parse_shen.<doubleunderline>) (if (not (= (fail) Parse_shen.<conclusion>)) (shen.pair (hd Parse_shen.<conclusion>) (shen.sequent shen.double (cons (shen.hdtl Parse_shen.<side-conditions>) (cons (shen.hdtl Parse_shen.<premises>) (cons (shen.hdtl Parse_shen.<conclusion>) ()))))) (fail))) (fail))) (fail))) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
57
+ (defun shen.<datatype-rule> (V1642) (let Result (let Parse_shen.<side-conditions> (shen.<side-conditions> V1642) (if (not (= (fail) Parse_shen.<side-conditions>)) (let Parse_shen.<premises> (shen.<premises> Parse_shen.<side-conditions>) (if (not (= (fail) Parse_shen.<premises>)) (let Parse_shen.<singleunderline> (shen.<singleunderline> Parse_shen.<premises>) (if (not (= (fail) Parse_shen.<singleunderline>)) (let Parse_shen.<conclusion> (shen.<conclusion> Parse_shen.<singleunderline>) (if (not (= (fail) Parse_shen.<conclusion>)) (shen.pair (hd Parse_shen.<conclusion>) (shen.sequent shen.single (cons (shen.hdtl Parse_shen.<side-conditions>) (cons (shen.hdtl Parse_shen.<premises>) (cons (shen.hdtl Parse_shen.<conclusion>) ()))))) (fail))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<side-conditions> (shen.<side-conditions> V1642) (if (not (= (fail) Parse_shen.<side-conditions>)) (let Parse_shen.<premises> (shen.<premises> Parse_shen.<side-conditions>) (if (not (= (fail) Parse_shen.<premises>)) (let Parse_shen.<doubleunderline> (shen.<doubleunderline> Parse_shen.<premises>) (if (not (= (fail) Parse_shen.<doubleunderline>)) (let Parse_shen.<conclusion> (shen.<conclusion> Parse_shen.<doubleunderline>) (if (not (= (fail) Parse_shen.<conclusion>)) (shen.pair (hd Parse_shen.<conclusion>) (shen.sequent shen.double (cons (shen.hdtl Parse_shen.<side-conditions>) (cons (shen.hdtl Parse_shen.<premises>) (cons (shen.hdtl Parse_shen.<conclusion>) ()))))) (fail))) (fail))) (fail))) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
58
58
 
59
- (defun shen.<side-conditions> (V1627) (let Result (let Parse_shen.<side-condition> (shen.<side-condition> V1627) (if (not (= (fail) Parse_shen.<side-condition>)) (let Parse_shen.<side-conditions> (shen.<side-conditions> Parse_shen.<side-condition>) (if (not (= (fail) Parse_shen.<side-conditions>)) (shen.pair (hd Parse_shen.<side-conditions>) (cons (shen.hdtl Parse_shen.<side-condition>) (shen.hdtl Parse_shen.<side-conditions>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1627) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
59
+ (defun shen.<side-conditions> (V1647) (let Result (let Parse_shen.<side-condition> (shen.<side-condition> V1647) (if (not (= (fail) Parse_shen.<side-condition>)) (let Parse_shen.<side-conditions> (shen.<side-conditions> Parse_shen.<side-condition>) (if (not (= (fail) Parse_shen.<side-conditions>)) (shen.pair (hd Parse_shen.<side-conditions>) (cons (shen.hdtl Parse_shen.<side-condition>) (shen.hdtl Parse_shen.<side-conditions>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1647) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
60
60
 
61
- (defun shen.<side-condition> (V1632) (let Result (if (and (cons? (hd V1632)) (= if (hd (hd V1632)))) (let Parse_shen.<expr> (shen.<expr> (shen.pair (tl (hd V1632)) (shen.hdtl V1632))) (if (not (= (fail) Parse_shen.<expr>)) (shen.pair (hd Parse_shen.<expr>) (cons if (cons (shen.hdtl Parse_shen.<expr>) ()))) (fail))) (fail)) (if (= Result (fail)) (let Result (if (and (cons? (hd V1632)) (= let (hd (hd V1632)))) (let Parse_shen.<variable?> (shen.<variable?> (shen.pair (tl (hd V1632)) (shen.hdtl V1632))) (if (not (= (fail) Parse_shen.<variable?>)) (let Parse_shen.<expr> (shen.<expr> Parse_shen.<variable?>) (if (not (= (fail) Parse_shen.<expr>)) (shen.pair (hd Parse_shen.<expr>) (cons let (cons (shen.hdtl Parse_shen.<variable?>) (cons (shen.hdtl Parse_shen.<expr>) ())))) (fail))) (fail))) (fail)) (if (= Result (fail)) (fail) Result)) Result)))
61
+ (defun shen.<side-condition> (V1652) (let Result (if (and (cons? (hd V1652)) (= if (hd (hd V1652)))) (let Parse_shen.<expr> (shen.<expr> (shen.pair (tl (hd V1652)) (shen.hdtl V1652))) (if (not (= (fail) Parse_shen.<expr>)) (shen.pair (hd Parse_shen.<expr>) (cons if (cons (shen.hdtl Parse_shen.<expr>) ()))) (fail))) (fail)) (if (= Result (fail)) (let Result (if (and (cons? (hd V1652)) (= let (hd (hd V1652)))) (let Parse_shen.<variable?> (shen.<variable?> (shen.pair (tl (hd V1652)) (shen.hdtl V1652))) (if (not (= (fail) Parse_shen.<variable?>)) (let Parse_shen.<expr> (shen.<expr> Parse_shen.<variable?>) (if (not (= (fail) Parse_shen.<expr>)) (shen.pair (hd Parse_shen.<expr>) (cons let (cons (shen.hdtl Parse_shen.<variable?>) (cons (shen.hdtl Parse_shen.<expr>) ())))) (fail))) (fail))) (fail)) (if (= Result (fail)) (fail) Result)) Result)))
62
62
 
63
- (defun shen.<variable?> (V1637) (let Result (if (cons? (hd V1637)) (let Parse_X (hd (hd V1637)) (if (variable? Parse_X) (shen.pair (hd (shen.pair (tl (hd V1637)) (shen.hdtl V1637))) Parse_X) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
63
+ (defun shen.<variable?> (V1657) (let Result (if (cons? (hd V1657)) (let Parse_X (hd (hd V1657)) (if (variable? Parse_X) (shen.pair (hd (shen.pair (tl (hd V1657)) (shen.hdtl V1657))) Parse_X) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
64
64
 
65
- (defun shen.<expr> (V1642) (let Result (if (cons? (hd V1642)) (let Parse_X (hd (hd V1642)) (if (not (or (element? Parse_X (cons >> (cons ; ()))) (or (shen.singleunderline? Parse_X) (shen.doubleunderline? Parse_X)))) (shen.pair (hd (shen.pair (tl (hd V1642)) (shen.hdtl V1642))) (shen.remove-bar Parse_X)) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
65
+ (defun shen.<expr> (V1662) (let Result (if (cons? (hd V1662)) (let Parse_X (hd (hd V1662)) (if (not (or (element? Parse_X (cons >> (cons ; ()))) (or (shen.singleunderline? Parse_X) (shen.doubleunderline? Parse_X)))) (shen.pair (hd (shen.pair (tl (hd V1662)) (shen.hdtl V1662))) (shen.remove-bar Parse_X)) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
66
66
 
67
- (defun shen.remove-bar (V1643) (cond ((and (cons? V1643) (and (cons? (tl V1643)) (and (cons? (tl (tl V1643))) (and (= () (tl (tl (tl V1643)))) (= (hd (tl V1643)) bar!))))) (cons (hd V1643) (hd (tl (tl V1643))))) ((cons? V1643) (cons (shen.remove-bar (hd V1643)) (shen.remove-bar (tl V1643)))) (true V1643)))
67
+ (defun shen.remove-bar (V1663) (cond ((and (cons? V1663) (and (cons? (tl V1663)) (and (cons? (tl (tl V1663))) (and (= () (tl (tl (tl V1663)))) (= (hd (tl V1663)) bar!))))) (cons (hd V1663) (hd (tl (tl V1663))))) ((cons? V1663) (cons (shen.remove-bar (hd V1663)) (shen.remove-bar (tl V1663)))) (true V1663)))
68
68
 
69
- (defun shen.<premises> (V1648) (let Result (let Parse_shen.<premise> (shen.<premise> V1648) (if (not (= (fail) Parse_shen.<premise>)) (let Parse_shen.<semicolon-symbol> (shen.<semicolon-symbol> Parse_shen.<premise>) (if (not (= (fail) Parse_shen.<semicolon-symbol>)) (let Parse_shen.<premises> (shen.<premises> Parse_shen.<semicolon-symbol>) (if (not (= (fail) Parse_shen.<premises>)) (shen.pair (hd Parse_shen.<premises>) (cons (shen.hdtl Parse_shen.<premise>) (shen.hdtl Parse_shen.<premises>))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1648) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
69
+ (defun shen.<premises> (V1668) (let Result (let Parse_shen.<premise> (shen.<premise> V1668) (if (not (= (fail) Parse_shen.<premise>)) (let Parse_shen.<semicolon-symbol> (shen.<semicolon-symbol> Parse_shen.<premise>) (if (not (= (fail) Parse_shen.<semicolon-symbol>)) (let Parse_shen.<premises> (shen.<premises> Parse_shen.<semicolon-symbol>) (if (not (= (fail) Parse_shen.<premises>)) (shen.pair (hd Parse_shen.<premises>) (cons (shen.hdtl Parse_shen.<premise>) (shen.hdtl Parse_shen.<premises>))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1668) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
70
70
 
71
- (defun shen.<semicolon-symbol> (V1653) (let Result (if (cons? (hd V1653)) (let Parse_X (hd (hd V1653)) (if (= Parse_X ;) (shen.pair (hd (shen.pair (tl (hd V1653)) (shen.hdtl V1653))) shen.skip) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
71
+ (defun shen.<semicolon-symbol> (V1673) (let Result (if (cons? (hd V1673)) (let Parse_X (hd (hd V1673)) (if (= Parse_X ;) (shen.pair (hd (shen.pair (tl (hd V1673)) (shen.hdtl V1673))) shen.skip) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
72
72
 
73
- (defun shen.<premise> (V1658) (let Result (if (and (cons? (hd V1658)) (= ! (hd (hd V1658)))) (shen.pair (hd (shen.pair (tl (hd V1658)) (shen.hdtl V1658))) !) (fail)) (if (= Result (fail)) (let Result (let Parse_shen.<formulae> (shen.<formulae> V1658) (if (not (= (fail) Parse_shen.<formulae>)) (if (and (cons? (hd Parse_shen.<formulae>)) (= >> (hd (hd Parse_shen.<formulae>)))) (let Parse_shen.<formula> (shen.<formula> (shen.pair (tl (hd Parse_shen.<formulae>)) (shen.hdtl Parse_shen.<formulae>))) (if (not (= (fail) Parse_shen.<formula>)) (shen.pair (hd Parse_shen.<formula>) (shen.sequent (shen.hdtl Parse_shen.<formulae>) (shen.hdtl Parse_shen.<formula>))) (fail))) (fail)) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<formula> (shen.<formula> V1658) (if (not (= (fail) Parse_shen.<formula>)) (shen.pair (hd Parse_shen.<formula>) (shen.sequent () (shen.hdtl Parse_shen.<formula>))) (fail))) (if (= Result (fail)) (fail) Result)) Result)) Result)))
73
+ (defun shen.<premise> (V1678) (let Result (if (and (cons? (hd V1678)) (= ! (hd (hd V1678)))) (shen.pair (hd (shen.pair (tl (hd V1678)) (shen.hdtl V1678))) !) (fail)) (if (= Result (fail)) (let Result (let Parse_shen.<formulae> (shen.<formulae> V1678) (if (not (= (fail) Parse_shen.<formulae>)) (if (and (cons? (hd Parse_shen.<formulae>)) (= >> (hd (hd Parse_shen.<formulae>)))) (let Parse_shen.<formula> (shen.<formula> (shen.pair (tl (hd Parse_shen.<formulae>)) (shen.hdtl Parse_shen.<formulae>))) (if (not (= (fail) Parse_shen.<formula>)) (shen.pair (hd Parse_shen.<formula>) (shen.sequent (shen.hdtl Parse_shen.<formulae>) (shen.hdtl Parse_shen.<formula>))) (fail))) (fail)) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<formula> (shen.<formula> V1678) (if (not (= (fail) Parse_shen.<formula>)) (shen.pair (hd Parse_shen.<formula>) (shen.sequent () (shen.hdtl Parse_shen.<formula>))) (fail))) (if (= Result (fail)) (fail) Result)) Result)) Result)))
74
74
 
75
- (defun shen.<conclusion> (V1663) (let Result (let Parse_shen.<formulae> (shen.<formulae> V1663) (if (not (= (fail) Parse_shen.<formulae>)) (if (and (cons? (hd Parse_shen.<formulae>)) (= >> (hd (hd Parse_shen.<formulae>)))) (let Parse_shen.<formula> (shen.<formula> (shen.pair (tl (hd Parse_shen.<formulae>)) (shen.hdtl Parse_shen.<formulae>))) (if (not (= (fail) Parse_shen.<formula>)) (let Parse_shen.<semicolon-symbol> (shen.<semicolon-symbol> Parse_shen.<formula>) (if (not (= (fail) Parse_shen.<semicolon-symbol>)) (shen.pair (hd Parse_shen.<semicolon-symbol>) (shen.sequent (shen.hdtl Parse_shen.<formulae>) (shen.hdtl Parse_shen.<formula>))) (fail))) (fail))) (fail)) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<formula> (shen.<formula> V1663) (if (not (= (fail) Parse_shen.<formula>)) (let Parse_shen.<semicolon-symbol> (shen.<semicolon-symbol> Parse_shen.<formula>) (if (not (= (fail) Parse_shen.<semicolon-symbol>)) (shen.pair (hd Parse_shen.<semicolon-symbol>) (shen.sequent () (shen.hdtl Parse_shen.<formula>))) (fail))) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
75
+ (defun shen.<conclusion> (V1683) (let Result (let Parse_shen.<formulae> (shen.<formulae> V1683) (if (not (= (fail) Parse_shen.<formulae>)) (if (and (cons? (hd Parse_shen.<formulae>)) (= >> (hd (hd Parse_shen.<formulae>)))) (let Parse_shen.<formula> (shen.<formula> (shen.pair (tl (hd Parse_shen.<formulae>)) (shen.hdtl Parse_shen.<formulae>))) (if (not (= (fail) Parse_shen.<formula>)) (let Parse_shen.<semicolon-symbol> (shen.<semicolon-symbol> Parse_shen.<formula>) (if (not (= (fail) Parse_shen.<semicolon-symbol>)) (shen.pair (hd Parse_shen.<semicolon-symbol>) (shen.sequent (shen.hdtl Parse_shen.<formulae>) (shen.hdtl Parse_shen.<formula>))) (fail))) (fail))) (fail)) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<formula> (shen.<formula> V1683) (if (not (= (fail) Parse_shen.<formula>)) (let Parse_shen.<semicolon-symbol> (shen.<semicolon-symbol> Parse_shen.<formula>) (if (not (= (fail) Parse_shen.<semicolon-symbol>)) (shen.pair (hd Parse_shen.<semicolon-symbol>) (shen.sequent () (shen.hdtl Parse_shen.<formula>))) (fail))) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
76
76
 
77
- (defun shen.sequent (V1664 V1665) (@p V1664 V1665))
77
+ (defun shen.sequent (V1684 V1685) (@p V1684 V1685))
78
78
 
79
- (defun shen.<formulae> (V1670) (let Result (let Parse_shen.<formula> (shen.<formula> V1670) (if (not (= (fail) Parse_shen.<formula>)) (let Parse_shen.<comma-symbol> (shen.<comma-symbol> Parse_shen.<formula>) (if (not (= (fail) Parse_shen.<comma-symbol>)) (let Parse_shen.<formulae> (shen.<formulae> Parse_shen.<comma-symbol>) (if (not (= (fail) Parse_shen.<formulae>)) (shen.pair (hd Parse_shen.<formulae>) (cons (shen.hdtl Parse_shen.<formula>) (shen.hdtl Parse_shen.<formulae>))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<formula> (shen.<formula> V1670) (if (not (= (fail) Parse_shen.<formula>)) (shen.pair (hd Parse_shen.<formula>) (cons (shen.hdtl Parse_shen.<formula>) ())) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1670) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)) Result)))
79
+ (defun shen.<formulae> (V1690) (let Result (let Parse_shen.<formula> (shen.<formula> V1690) (if (not (= (fail) Parse_shen.<formula>)) (let Parse_shen.<comma-symbol> (shen.<comma-symbol> Parse_shen.<formula>) (if (not (= (fail) Parse_shen.<comma-symbol>)) (let Parse_shen.<formulae> (shen.<formulae> Parse_shen.<comma-symbol>) (if (not (= (fail) Parse_shen.<formulae>)) (shen.pair (hd Parse_shen.<formulae>) (cons (shen.hdtl Parse_shen.<formula>) (shen.hdtl Parse_shen.<formulae>))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<formula> (shen.<formula> V1690) (if (not (= (fail) Parse_shen.<formula>)) (shen.pair (hd Parse_shen.<formula>) (cons (shen.hdtl Parse_shen.<formula>) ())) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1690) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)) Result)))
80
80
 
81
- (defun shen.<comma-symbol> (V1675) (let Result (if (cons? (hd V1675)) (let Parse_X (hd (hd V1675)) (if (= Parse_X (intern ",")) (shen.pair (hd (shen.pair (tl (hd V1675)) (shen.hdtl V1675))) shen.skip) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
81
+ (defun shen.<comma-symbol> (V1695) (let Result (if (cons? (hd V1695)) (let Parse_X (hd (hd V1695)) (if (= Parse_X (intern ",")) (shen.pair (hd (shen.pair (tl (hd V1695)) (shen.hdtl V1695))) shen.skip) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
82
82
 
83
- (defun shen.<formula> (V1680) (let Result (let Parse_shen.<expr> (shen.<expr> V1680) (if (not (= (fail) Parse_shen.<expr>)) (if (and (cons? (hd Parse_shen.<expr>)) (= : (hd (hd Parse_shen.<expr>)))) (let Parse_shen.<type> (shen.<type> (shen.pair (tl (hd Parse_shen.<expr>)) (shen.hdtl Parse_shen.<expr>))) (if (not (= (fail) Parse_shen.<type>)) (shen.pair (hd Parse_shen.<type>) (cons (shen.curry (shen.hdtl Parse_shen.<expr>)) (cons : (cons (shen.demodulate (shen.hdtl Parse_shen.<type>)) ())))) (fail))) (fail)) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<expr> (shen.<expr> V1680) (if (not (= (fail) Parse_shen.<expr>)) (shen.pair (hd Parse_shen.<expr>) (shen.hdtl Parse_shen.<expr>)) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
83
+ (defun shen.<formula> (V1700) (let Result (let Parse_shen.<expr> (shen.<expr> V1700) (if (not (= (fail) Parse_shen.<expr>)) (if (and (cons? (hd Parse_shen.<expr>)) (= : (hd (hd Parse_shen.<expr>)))) (let Parse_shen.<type> (shen.<type> (shen.pair (tl (hd Parse_shen.<expr>)) (shen.hdtl Parse_shen.<expr>))) (if (not (= (fail) Parse_shen.<type>)) (shen.pair (hd Parse_shen.<type>) (cons (shen.curry (shen.hdtl Parse_shen.<expr>)) (cons : (cons (shen.demodulate (shen.hdtl Parse_shen.<type>)) ())))) (fail))) (fail)) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<expr> (shen.<expr> V1700) (if (not (= (fail) Parse_shen.<expr>)) (shen.pair (hd Parse_shen.<expr>) (shen.hdtl Parse_shen.<expr>)) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
84
84
 
85
- (defun shen.<type> (V1685) (let Result (let Parse_shen.<expr> (shen.<expr> V1685) (if (not (= (fail) Parse_shen.<expr>)) (shen.pair (hd Parse_shen.<expr>) (shen.curry-type (shen.hdtl Parse_shen.<expr>))) (fail))) (if (= Result (fail)) (fail) Result)))
85
+ (defun shen.<type> (V1705) (let Result (let Parse_shen.<expr> (shen.<expr> V1705) (if (not (= (fail) Parse_shen.<expr>)) (shen.pair (hd Parse_shen.<expr>) (shen.curry-type (shen.hdtl Parse_shen.<expr>))) (fail))) (if (= Result (fail)) (fail) Result)))
86
86
 
87
- (defun shen.<doubleunderline> (V1690) (let Result (if (cons? (hd V1690)) (let Parse_X (hd (hd V1690)) (if (shen.doubleunderline? Parse_X) (shen.pair (hd (shen.pair (tl (hd V1690)) (shen.hdtl V1690))) Parse_X) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
87
+ (defun shen.<doubleunderline> (V1710) (let Result (if (cons? (hd V1710)) (let Parse_X (hd (hd V1710)) (if (shen.doubleunderline? Parse_X) (shen.pair (hd (shen.pair (tl (hd V1710)) (shen.hdtl V1710))) Parse_X) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
88
88
 
89
- (defun shen.<singleunderline> (V1695) (let Result (if (cons? (hd V1695)) (let Parse_X (hd (hd V1695)) (if (shen.singleunderline? Parse_X) (shen.pair (hd (shen.pair (tl (hd V1695)) (shen.hdtl V1695))) Parse_X) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
89
+ (defun shen.<singleunderline> (V1715) (let Result (if (cons? (hd V1715)) (let Parse_X (hd (hd V1715)) (if (shen.singleunderline? Parse_X) (shen.pair (hd (shen.pair (tl (hd V1715)) (shen.hdtl V1715))) Parse_X) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
90
90
 
91
- (defun shen.singleunderline? (V1696) (and (symbol? V1696) (shen.sh? (str V1696))))
91
+ (defun shen.singleunderline? (V1716) (and (symbol? V1716) (shen.sh? (str V1716))))
92
92
 
93
- (defun shen.sh? (V1697) (cond ((= "_" V1697) true) (true (and (= (pos V1697 0) "_") (shen.sh? (tlstr V1697))))))
93
+ (defun shen.sh? (V1717) (cond ((= "_" V1717) true) (true (and (= (pos V1717 0) "_") (shen.sh? (tlstr V1717))))))
94
94
 
95
- (defun shen.doubleunderline? (V1698) (and (symbol? V1698) (shen.dh? (str V1698))))
95
+ (defun shen.doubleunderline? (V1718) (and (symbol? V1718) (shen.dh? (str V1718))))
96
96
 
97
- (defun shen.dh? (V1699) (cond ((= "=" V1699) true) (true (and (= (pos V1699 0) "=") (shen.dh? (tlstr V1699))))))
97
+ (defun shen.dh? (V1719) (cond ((= "=" V1719) true) (true (and (= (pos V1719 0) "=") (shen.dh? (tlstr V1719))))))
98
98
 
99
- (defun shen.process-datatype (V1700 V1701) (shen.remember-datatype (shen.s-prolog (shen.rules->horn-clauses V1700 V1701))))
99
+ (defun shen.process-datatype (V1720 V1721) (shen.remember-datatype (shen.s-prolog (shen.rules->horn-clauses V1720 V1721))))
100
100
 
101
- (defun shen.remember-datatype (V1706) (cond ((cons? V1706) (do (set shen.*datatypes* (adjoin (hd V1706) (value shen.*datatypes*))) (do (set shen.*alldatatypes* (adjoin (hd V1706) (value shen.*alldatatypes*))) (hd V1706)))) (true (shen.sys-error shen.remember-datatype))))
101
+ (defun shen.remember-datatype (V1726) (cond ((cons? V1726) (do (set shen.*datatypes* (adjoin (hd V1726) (value shen.*datatypes*))) (do (set shen.*alldatatypes* (adjoin (hd V1726) (value shen.*alldatatypes*))) (hd V1726)))) (true (shen.sys-error shen.remember-datatype))))
102
102
 
103
- (defun shen.rules->horn-clauses (V1709 V1710) (cond ((= () V1710) ()) ((and (cons? V1710) (and (tuple? (hd V1710)) (= shen.single (fst (hd V1710))))) (cons (shen.rule->horn-clause V1709 (snd (hd V1710))) (shen.rules->horn-clauses V1709 (tl V1710)))) ((and (cons? V1710) (and (tuple? (hd V1710)) (= shen.double (fst (hd V1710))))) (shen.rules->horn-clauses V1709 (append (shen.double->singles (snd (hd V1710))) (tl V1710)))) (true (shen.sys-error shen.rules->horn-clauses))))
103
+ (defun shen.rules->horn-clauses (V1729 V1730) (cond ((= () V1730) ()) ((and (cons? V1730) (and (tuple? (hd V1730)) (= shen.single (fst (hd V1730))))) (cons (shen.rule->horn-clause V1729 (snd (hd V1730))) (shen.rules->horn-clauses V1729 (tl V1730)))) ((and (cons? V1730) (and (tuple? (hd V1730)) (= shen.double (fst (hd V1730))))) (shen.rules->horn-clauses V1729 (append (shen.double->singles (snd (hd V1730))) (tl V1730)))) (true (shen.sys-error shen.rules->horn-clauses))))
104
104
 
105
- (defun shen.double->singles (V1711) (cons (shen.right-rule V1711) (cons (shen.left-rule V1711) ())))
105
+ (defun shen.double->singles (V1731) (cons (shen.right-rule V1731) (cons (shen.left-rule V1731) ())))
106
106
 
107
- (defun shen.right-rule (V1712) (@p shen.single V1712))
107
+ (defun shen.right-rule (V1732) (@p shen.single V1732))
108
108
 
109
- (defun shen.left-rule (V1713) (cond ((and (cons? V1713) (and (cons? (tl V1713)) (and (cons? (tl (tl V1713))) (and (tuple? (hd (tl (tl V1713)))) (and (= () (fst (hd (tl (tl V1713))))) (= () (tl (tl (tl V1713))))))))) (let Q (gensym Qv) (let NewConclusion (@p (cons (snd (hd (tl (tl V1713)))) ()) Q) (let NewPremises (cons (@p (map shen.right->left (hd (tl V1713))) Q) ()) (@p shen.single (cons (hd V1713) (cons NewPremises (cons NewConclusion ())))))))) (true (shen.sys-error shen.left-rule))))
109
+ (defun shen.left-rule (V1733) (cond ((and (cons? V1733) (and (cons? (tl V1733)) (and (cons? (tl (tl V1733))) (and (tuple? (hd (tl (tl V1733)))) (and (= () (fst (hd (tl (tl V1733))))) (= () (tl (tl (tl V1733))))))))) (let Q (gensym Qv) (let NewConclusion (@p (cons (snd (hd (tl (tl V1733)))) ()) Q) (let NewPremises (cons (@p (map shen.right->left (hd (tl V1733))) Q) ()) (@p shen.single (cons (hd V1733) (cons NewPremises (cons NewConclusion ())))))))) (true (shen.sys-error shen.left-rule))))
110
110
 
111
- (defun shen.right->left (V1718) (cond ((and (tuple? V1718) (= () (fst V1718))) (snd V1718)) (true (simple-error "syntax error with ==========
111
+ (defun shen.right->left (V1738) (cond ((and (tuple? V1738) (= () (fst V1738))) (snd V1738)) (true (simple-error "syntax error with ==========
112
112
  "))))
113
113
 
114
- (defun shen.rule->horn-clause (V1719 V1720) (cond ((and (cons? V1720) (and (cons? (tl V1720)) (and (cons? (tl (tl V1720))) (and (tuple? (hd (tl (tl V1720)))) (= () (tl (tl (tl V1720)))))))) (cons (shen.rule->horn-clause-head V1719 (snd (hd (tl (tl V1720))))) (cons :- (cons (shen.rule->horn-clause-body (hd V1720) (hd (tl V1720)) (fst (hd (tl (tl V1720))))) ())))) (true (shen.sys-error shen.rule->horn-clause))))
114
+ (defun shen.rule->horn-clause (V1739 V1740) (cond ((and (cons? V1740) (and (cons? (tl V1740)) (and (cons? (tl (tl V1740))) (and (tuple? (hd (tl (tl V1740)))) (= () (tl (tl (tl V1740)))))))) (cons (shen.rule->horn-clause-head V1739 (snd (hd (tl (tl V1740))))) (cons :- (cons (shen.rule->horn-clause-body (hd V1740) (hd (tl V1740)) (fst (hd (tl (tl V1740))))) ())))) (true (shen.sys-error shen.rule->horn-clause))))
115
115
 
116
- (defun shen.rule->horn-clause-head (V1721 V1722) (cons V1721 (cons (shen.mode-ify V1722) (cons Context_1957 ()))))
116
+ (defun shen.rule->horn-clause-head (V1741 V1742) (cons V1741 (cons (shen.mode-ify V1742) (cons Context_1957 ()))))
117
117
 
118
- (defun shen.mode-ify (V1723) (cond ((and (cons? V1723) (and (cons? (tl V1723)) (and (= : (hd (tl V1723))) (and (cons? (tl (tl V1723))) (= () (tl (tl (tl V1723)))))))) (cons mode (cons (cons (hd V1723) (cons : (cons (cons mode (cons (hd (tl (tl V1723))) (cons + ()))) ()))) (cons - ())))) (true V1723)))
118
+ (defun shen.mode-ify (V1743) (cond ((and (cons? V1743) (and (cons? (tl V1743)) (and (= : (hd (tl V1743))) (and (cons? (tl (tl V1743))) (= () (tl (tl (tl V1743)))))))) (cons mode (cons (cons (hd V1743) (cons : (cons (cons mode (cons (hd (tl (tl V1743))) (cons + ()))) ()))) (cons - ())))) (true V1743)))
119
119
 
120
- (defun shen.rule->horn-clause-body (V1724 V1725 V1726) (let Variables (map shen.extract_vars V1726) (let Predicates (map (lambda X (gensym shen.cl)) V1726) (let SearchLiterals (shen.construct-search-literals Predicates Variables Context_1957 Context1_1957) (let SearchClauses (shen.construct-search-clauses Predicates V1726 Variables) (let SideLiterals (shen.construct-side-literals V1724) (let PremissLiterals (map (lambda X (shen.construct-premiss-literal X (empty? V1726))) V1725) (append SearchLiterals (append SideLiterals PremissLiterals)))))))))
120
+ (defun shen.rule->horn-clause-body (V1744 V1745 V1746) (let Variables (map shen.extract_vars V1746) (let Predicates (map (lambda X (gensym shen.cl)) V1746) (let SearchLiterals (shen.construct-search-literals Predicates Variables Context_1957 Context1_1957) (let SearchClauses (shen.construct-search-clauses Predicates V1746 Variables) (let SideLiterals (shen.construct-side-literals V1744) (let PremissLiterals (map (lambda X (shen.construct-premiss-literal X (empty? V1746))) V1745) (append SearchLiterals (append SideLiterals PremissLiterals)))))))))
121
121
 
122
- (defun shen.construct-search-literals (V1731 V1732 V1733 V1734) (cond ((and (= () V1731) (= () V1732)) ()) (true (shen.csl-help V1731 V1732 V1733 V1734))))
122
+ (defun shen.construct-search-literals (V1751 V1752 V1753 V1754) (cond ((and (= () V1751) (= () V1752)) ()) (true (shen.csl-help V1751 V1752 V1753 V1754))))
123
123
 
124
- (defun shen.csl-help (V1737 V1738 V1739 V1740) (cond ((and (= () V1737) (= () V1738)) (cons (cons bind (cons ContextOut_1957 (cons V1739 ()))) ())) ((and (cons? V1737) (cons? V1738)) (cons (cons (hd V1737) (cons V1739 (cons V1740 (hd V1738)))) (shen.csl-help (tl V1737) (tl V1738) V1740 (gensym Context)))) (true (shen.sys-error shen.csl-help))))
124
+ (defun shen.csl-help (V1757 V1758 V1759 V1760) (cond ((and (= () V1757) (= () V1758)) (cons (cons bind (cons ContextOut_1957 (cons V1759 ()))) ())) ((and (cons? V1757) (cons? V1758)) (cons (cons (hd V1757) (cons V1759 (cons V1760 (hd V1758)))) (shen.csl-help (tl V1757) (tl V1758) V1760 (gensym Context)))) (true (shen.sys-error shen.csl-help))))
125
125
 
126
- (defun shen.construct-search-clauses (V1741 V1742 V1743) (cond ((and (= () V1741) (and (= () V1742) (= () V1743))) shen.skip) ((and (cons? V1741) (and (cons? V1742) (cons? V1743))) (do (shen.construct-search-clause (hd V1741) (hd V1742) (hd V1743)) (shen.construct-search-clauses (tl V1741) (tl V1742) (tl V1743)))) (true (shen.sys-error shen.construct-search-clauses))))
126
+ (defun shen.construct-search-clauses (V1761 V1762 V1763) (cond ((and (= () V1761) (and (= () V1762) (= () V1763))) shen.skip) ((and (cons? V1761) (and (cons? V1762) (cons? V1763))) (do (shen.construct-search-clause (hd V1761) (hd V1762) (hd V1763)) (shen.construct-search-clauses (tl V1761) (tl V1762) (tl V1763)))) (true (shen.sys-error shen.construct-search-clauses))))
127
127
 
128
- (defun shen.construct-search-clause (V1744 V1745 V1746) (shen.s-prolog (cons (shen.construct-base-search-clause V1744 V1745 V1746) (cons (shen.construct-recursive-search-clause V1744 V1745 V1746) ()))))
128
+ (defun shen.construct-search-clause (V1764 V1765 V1766) (shen.s-prolog (cons (shen.construct-base-search-clause V1764 V1765 V1766) (cons (shen.construct-recursive-search-clause V1764 V1765 V1766) ()))))
129
129
 
130
- (defun shen.construct-base-search-clause (V1747 V1748 V1749) (cons (cons V1747 (cons (cons (shen.mode-ify V1748) In_1957) (cons In_1957 V1749))) (cons :- (cons () ()))))
130
+ (defun shen.construct-base-search-clause (V1767 V1768 V1769) (cons (cons V1767 (cons (cons (shen.mode-ify V1768) In_1957) (cons In_1957 V1769))) (cons :- (cons () ()))))
131
131
 
132
- (defun shen.construct-recursive-search-clause (V1750 V1751 V1752) (cons (cons V1750 (cons (cons Assumption_1957 Assumptions_1957) (cons (cons Assumption_1957 Out_1957) V1752))) (cons :- (cons (cons (cons V1750 (cons Assumptions_1957 (cons Out_1957 V1752))) ()) ()))))
132
+ (defun shen.construct-recursive-search-clause (V1770 V1771 V1772) (cons (cons V1770 (cons (cons Assumption_1957 Assumptions_1957) (cons (cons Assumption_1957 Out_1957) V1772))) (cons :- (cons (cons (cons V1770 (cons Assumptions_1957 (cons Out_1957 V1772))) ()) ()))))
133
133
 
134
- (defun shen.construct-side-literals (V1757) (cond ((= () V1757) ()) ((and (cons? V1757) (and (cons? (hd V1757)) (and (= if (hd (hd V1757))) (and (cons? (tl (hd V1757))) (= () (tl (tl (hd V1757)))))))) (cons (cons when (tl (hd V1757))) (shen.construct-side-literals (tl V1757)))) ((and (cons? V1757) (and (cons? (hd V1757)) (and (= let (hd (hd V1757))) (and (cons? (tl (hd V1757))) (and (cons? (tl (tl (hd V1757)))) (= () (tl (tl (tl (hd V1757)))))))))) (cons (cons is (tl (hd V1757))) (shen.construct-side-literals (tl V1757)))) ((cons? V1757) (shen.construct-side-literals (tl V1757))) (true (shen.sys-error shen.construct-side-literals))))
134
+ (defun shen.construct-side-literals (V1777) (cond ((= () V1777) ()) ((and (cons? V1777) (and (cons? (hd V1777)) (and (= if (hd (hd V1777))) (and (cons? (tl (hd V1777))) (= () (tl (tl (hd V1777)))))))) (cons (cons when (tl (hd V1777))) (shen.construct-side-literals (tl V1777)))) ((and (cons? V1777) (and (cons? (hd V1777)) (and (= let (hd (hd V1777))) (and (cons? (tl (hd V1777))) (and (cons? (tl (tl (hd V1777)))) (= () (tl (tl (tl (hd V1777)))))))))) (cons (cons is (tl (hd V1777))) (shen.construct-side-literals (tl V1777)))) ((cons? V1777) (shen.construct-side-literals (tl V1777))) (true (shen.sys-error shen.construct-side-literals))))
135
135
 
136
- (defun shen.construct-premiss-literal (V1762 V1763) (cond ((tuple? V1762) (cons shen.t* (cons (shen.recursive_cons_form (snd V1762)) (cons (shen.construct-context V1763 (fst V1762)) ())))) ((= ! V1762) (cons cut (cons Throwcontrol ()))) (true (shen.sys-error shen.construct-premiss-literal))))
136
+ (defun shen.construct-premiss-literal (V1782 V1783) (cond ((tuple? V1782) (cons shen.t* (cons (shen.recursive_cons_form (snd V1782)) (cons (shen.construct-context V1783 (fst V1782)) ())))) ((= ! V1782) (cons cut (cons Throwcontrol ()))) (true (shen.sys-error shen.construct-premiss-literal))))
137
137
 
138
- (defun shen.construct-context (V1764 V1765) (cond ((and (= true V1764) (= () V1765)) Context_1957) ((and (= false V1764) (= () V1765)) ContextOut_1957) ((cons? V1765) (cons cons (cons (shen.recursive_cons_form (hd V1765)) (cons (shen.construct-context V1764 (tl V1765)) ())))) (true (shen.sys-error shen.construct-context))))
138
+ (defun shen.construct-context (V1784 V1785) (cond ((and (= true V1784) (= () V1785)) Context_1957) ((and (= false V1784) (= () V1785)) ContextOut_1957) ((cons? V1785) (cons cons (cons (shen.recursive_cons_form (hd V1785)) (cons (shen.construct-context V1784 (tl V1785)) ())))) (true (shen.sys-error shen.construct-context))))
139
139
 
140
- (defun shen.recursive_cons_form (V1766) (cond ((cons? V1766) (cons cons (cons (shen.recursive_cons_form (hd V1766)) (cons (shen.recursive_cons_form (tl V1766)) ())))) (true V1766)))
140
+ (defun shen.recursive_cons_form (V1786) (cond ((cons? V1786) (cons cons (cons (shen.recursive_cons_form (hd V1786)) (cons (shen.recursive_cons_form (tl V1786)) ())))) (true V1786)))
141
141
 
142
- (defun preclude (V1767) (shen.preclude-h (map shen.intern-type V1767)))
142
+ (defun preclude (V1787) (shen.preclude-h (map shen.intern-type V1787)))
143
143
 
144
- (defun shen.preclude-h (V1768) (let FilterDatatypes (set shen.*datatypes* (difference (value shen.*datatypes*) V1768)) (value shen.*datatypes*)))
144
+ (defun shen.preclude-h (V1788) (let FilterDatatypes (set shen.*datatypes* (difference (value shen.*datatypes*) V1788)) (value shen.*datatypes*)))
145
145
 
146
- (defun include (V1769) (shen.include-h (map shen.intern-type V1769)))
146
+ (defun include (V1789) (shen.include-h (map shen.intern-type V1789)))
147
147
 
148
- (defun shen.include-h (V1770) (let ValidTypes (intersection V1770 (value shen.*alldatatypes*)) (let NewDatatypes (set shen.*datatypes* (union ValidTypes (value shen.*datatypes*))) (value shen.*datatypes*))))
148
+ (defun shen.include-h (V1790) (let ValidTypes (intersection V1790 (value shen.*alldatatypes*)) (let NewDatatypes (set shen.*datatypes* (union ValidTypes (value shen.*datatypes*))) (value shen.*datatypes*))))
149
149
 
150
- (defun preclude-all-but (V1771) (shen.preclude-h (difference (value shen.*alldatatypes*) (map shen.intern-type V1771))))
150
+ (defun preclude-all-but (V1791) (shen.preclude-h (difference (value shen.*alldatatypes*) (map shen.intern-type V1791))))
151
151
 
152
- (defun include-all-but (V1772) (shen.include-h (difference (value shen.*alldatatypes*) (map shen.intern-type V1772))))
152
+ (defun include-all-but (V1792) (shen.include-h (difference (value shen.*alldatatypes*) (map shen.intern-type V1792))))
153
153
 
154
- (defun shen.synonyms-help (V1777) (cond ((= () V1777) synonyms) ((and (cons? V1777) (cons? (tl V1777))) (do (shen.pushnew (cons (hd V1777) (shen.curry-type (hd (tl V1777)))) shen.*synonyms*) (shen.synonyms-help (tl (tl V1777))))) (true (simple-error (cn "odd number of synonyms
154
+ (defun shen.synonyms-help (V1797) (cond ((= () V1797) synonyms) ((and (cons? V1797) (cons? (tl V1797))) (do (shen.pushnew (cons (hd V1797) (shen.curry-type (hd (tl V1797)))) shen.*synonyms*) (shen.synonyms-help (tl (tl V1797))))) (true (simple-error (cn "odd number of synonyms
155
155
  " "")))))
156
156
 
157
- (defun shen.pushnew (V1778 V1779) (if (element? V1778 (value V1779)) (value V1779) (set V1779 (cons V1778 (value V1779)))))
157
+ (defun shen.pushnew (V1798 V1799) (if (element? V1798 (value V1799)) (value V1799) (set V1799 (cons V1798 (value V1799)))))
158
158
 
159
159
 
160
160
 
data/shen/release/k_lambda/sys.kl CHANGED
@@ -47,211 +47,195 @@
47
47
  * explains this license in full. *
48
48
  * *
49
49
  *****************************************************************************************
50
- "(defun thaw (V1782) (V1782))
50
+ "(defun thaw (V1802) (V1802))
51
51
 
52
- (defun eval (V1783) (let Macroexpand (shen.walk (lambda V1780 (macroexpand V1780)) V1783) (if (shen.packaged? Macroexpand) (map shen.eval-without-macros (shen.package-contents Macroexpand)) (shen.eval-without-macros Macroexpand))))
52
+ (defun eval (V1803) (let Macroexpand (shen.walk (lambda V1800 (macroexpand V1800)) V1803) (if (shen.packaged? Macroexpand) (map shen.eval-without-macros (shen.package-contents Macroexpand)) (shen.eval-without-macros Macroexpand))))
53
53
 
54
- (defun shen.eval-without-macros (V1784) (eval-kl (shen.elim-def (shen.proc-input+ V1784))))
54
+ (defun shen.eval-without-macros (V1804) (eval-kl (shen.elim-def (shen.proc-input+ V1804))))
55
55
 
56
- (defun shen.proc-input+ (V1785) (cond ((and (cons? V1785) (and (= input+ (hd V1785)) (and (cons? (tl V1785)) (and (cons? (tl (tl V1785))) (= () (tl (tl (tl V1785)))))))) (cons input+ (cons (hd (tl V1785)) (cons (shen.rcons_form (hd (tl (tl V1785)))) ())))) ((and (cons? V1785) (and (= read+ (hd V1785)) (and (cons? (tl V1785)) (and (cons? (tl (tl V1785))) (= () (tl (tl (tl V1785)))))))) (cons read+ (cons (hd (tl V1785)) (cons (shen.rcons_form (hd (tl (tl V1785)))) ())))) ((cons? V1785) (map shen.proc-input+ V1785)) (true V1785)))
56
+ (defun shen.proc-input+ (V1805) (cond ((and (cons? V1805) (and (= input+ (hd V1805)) (and (cons? (tl V1805)) (and (cons? (tl (tl V1805))) (= () (tl (tl (tl V1805)))))))) (cons input+ (cons (shen.rcons_form (hd (tl V1805))) (tl (tl V1805))))) ((and (cons? V1805) (and (= read+ (hd V1805)) (and (cons? (tl V1805)) (and (cons? (tl (tl V1805))) (= () (tl (tl (tl V1805)))))))) (cons read+ (cons (shen.rcons_form (hd (tl V1805))) (tl (tl V1805))))) ((cons? V1805) (map shen.proc-input+ V1805)) (true V1805)))
57
57
 
58
- (defun shen.elim-def (V1786) (cond ((and (cons? V1786) (and (= define (hd V1786)) (cons? (tl V1786)))) (shen.shen->kl (hd (tl V1786)) (tl (tl V1786)))) ((and (cons? V1786) (and (= defmacro (hd V1786)) (cons? (tl V1786)))) (let Default (cons X (cons -> (cons X ()))) (let Def (shen.elim-def (cons define (cons (hd (tl V1786)) (append (tl (tl V1786)) Default)))) (let MacroAdd (shen.add-macro (hd (tl V1786))) Def)))) ((and (cons? V1786) (and (= defcc (hd V1786)) (cons? (tl V1786)))) (shen.elim-def (shen.yacc V1786))) ((cons? V1786) (map shen.elim-def V1786)) (true V1786)))
58
+ (defun shen.elim-def (V1806) (cond ((and (cons? V1806) (and (= define (hd V1806)) (cons? (tl V1806)))) (shen.shen->kl (hd (tl V1806)) (tl (tl V1806)))) ((and (cons? V1806) (and (= defmacro (hd V1806)) (cons? (tl V1806)))) (let Default (cons X (cons -> (cons X ()))) (let Def (shen.elim-def (cons define (cons (hd (tl V1806)) (append (tl (tl V1806)) Default)))) (let MacroAdd (shen.add-macro (hd (tl V1806))) Def)))) ((and (cons? V1806) (and (= defcc (hd V1806)) (cons? (tl V1806)))) (shen.elim-def (shen.yacc V1806))) ((cons? V1806) (map shen.elim-def V1806)) (true V1806)))
59
59
 
60
- (defun shen.add-macro (V1787) (set *macros* (adjoin V1787 (value *macros*))))
60
+ (defun shen.add-macro (V1807) (set *macros* (adjoin V1807 (value *macros*))))
61
61
 
62
- (defun shen.packaged? (V1794) (cond ((and (cons? V1794) (and (= package (hd V1794)) (and (cons? (tl V1794)) (cons? (tl (tl V1794)))))) true) (true false)))
62
+ (defun shen.packaged? (V1814) (cond ((and (cons? V1814) (and (= package (hd V1814)) (and (cons? (tl V1814)) (cons? (tl (tl V1814)))))) true) (true false)))
63
63
 
64
- (defun external (V1795) (trap-error (get V1795 shen.external-symbols (value *property-vector*)) (lambda E (simple-error (cn "package " (shen.app V1795 " has not been used.
64
+ (defun external (V1815) (trap-error (get V1815 shen.external-symbols (value *property-vector*)) (lambda E (simple-error (cn "package " (shen.app V1815 " has not been used.
65
65
  " shen.a))))))
66
66
 
67
- (defun shen.package-contents (V1798) (cond ((and (cons? V1798) (and (= package (hd V1798)) (and (cons? (tl V1798)) (and (= null (hd (tl V1798))) (cons? (tl (tl V1798))))))) (tl (tl (tl V1798)))) ((and (cons? V1798) (and (= package (hd V1798)) (and (cons? (tl V1798)) (cons? (tl (tl V1798)))))) (shen.packageh (hd (tl V1798)) (hd (tl (tl V1798))) (tl (tl (tl V1798))))) (true (shen.sys-error shen.package-contents))))
67
+ (defun shen.package-contents (V1818) (cond ((and (cons? V1818) (and (= package (hd V1818)) (and (cons? (tl V1818)) (and (= null (hd (tl V1818))) (cons? (tl (tl V1818))))))) (tl (tl (tl V1818)))) ((and (cons? V1818) (and (= package (hd V1818)) (and (cons? (tl V1818)) (cons? (tl (tl V1818)))))) (shen.packageh (hd (tl V1818)) (hd (tl (tl V1818))) (tl (tl (tl V1818))))) (true (shen.sys-error shen.package-contents))))
68
68
 
69
- (defun shen.walk (V1799 V1800) (cond ((cons? V1800) (V1799 (map (lambda Z (shen.walk V1799 Z)) V1800))) (true (V1799 V1800))))
69
+ (defun shen.walk (V1819 V1820) (cond ((cons? V1820) (V1819 (map (lambda Z (shen.walk V1819 Z)) V1820))) (true (V1819 V1820))))
70
70
 
71
- (defun compile (V1801 V1802 V1803) (let O (V1801 (cons V1802 (cons () ()))) (if (or (= (fail) O) (not (empty? (hd O)))) (V1803 O) (shen.hdtl O))))
71
+ (defun compile (V1821 V1822 V1823) (let O (V1821 (cons V1822 (cons () ()))) (if (or (= (fail) O) (not (empty? (hd O)))) (V1823 O) (shen.hdtl O))))
72
72
 
73
- (defun fail-if (V1804 V1805) (if (V1804 V1805) (fail) V1805))
73
+ (defun fail-if (V1824 V1825) (if (V1824 V1825) (fail) V1825))
74
74
 
75
- (defun @s (V1806 V1807) (cn V1806 V1807))
75
+ (defun @s (V1826 V1827) (cn V1826 V1827))
76
76
 
77
77
  (defun tc? () (value shen.*tc*))
78
78
 
79
- (defun ps (V1808) (trap-error (get V1808 shen.source (value *property-vector*)) (lambda E (simple-error (shen.app V1808 " not found.
79
+ (defun ps (V1828) (trap-error (get V1828 shen.source (value *property-vector*)) (lambda E (simple-error (shen.app V1828 " not found.
80
80
  " shen.a)))))
81
81
 
82
82
  (defun stinput () (value *stinput*))
83
83
 
84
- (defun shen.+vector? (V1809) (and (absvector? V1809) (> (<-address V1809 0) 0)))
84
+ (defun shen.+vector? (V1829) (and (absvector? V1829) (> (<-address V1829 0) 0)))
85
85
 
86
- (defun vector (V1810) (let Vector (absvector (+ V1810 1)) (let ZeroStamp (address-> Vector 0 V1810) (let Standard (if (= V1810 0) ZeroStamp (shen.fillvector ZeroStamp 1 V1810 (fail))) Standard))))
86
+ (defun vector (V1830) (let Vector (absvector (+ V1830 1)) (let ZeroStamp (address-> Vector 0 V1830) (let Standard (if (= V1830 0) ZeroStamp (shen.fillvector ZeroStamp 1 V1830 (fail))) Standard))))
87
87
 
88
- (defun shen.fillvector (V1811 V1812 V1813 V1814) (cond ((= V1813 V1812) (address-> V1811 V1813 V1814)) (true (shen.fillvector (address-> V1811 V1812 V1814) (+ 1 V1812) V1813 V1814))))
88
+ (defun shen.fillvector (V1831 V1832 V1833 V1834) (cond ((= V1833 V1832) (address-> V1831 V1833 V1834)) (true (shen.fillvector (address-> V1831 V1832 V1834) (+ 1 V1832) V1833 V1834))))
89
89
 
90
- (defun vector? (V1816) (and (absvector? V1816) (trap-error (>= (<-address V1816 0) 0) (lambda E false))))
90
+ (defun vector? (V1836) (and (absvector? V1836) (trap-error (>= (<-address V1836 0) 0) (lambda E false))))
91
91
 
92
- (defun vector-> (V1817 V1818 V1819) (if (= V1818 0) (simple-error "cannot access 0th element of a vector
93
- ") (address-> V1817 V1818 V1819)))
92
+ (defun vector-> (V1837 V1838 V1839) (if (= V1838 0) (simple-error "cannot access 0th element of a vector
93
+ ") (address-> V1837 V1838 V1839)))
94
94
 
95
- (defun <-vector (V1820 V1821) (if (= V1821 0) (simple-error "cannot access 0th element of a vector
96
- ") (let VectorElement (<-address V1820 V1821) (if (= VectorElement (fail)) (simple-error "vector element not found
95
+ (defun <-vector (V1840 V1841) (if (= V1841 0) (simple-error "cannot access 0th element of a vector
96
+ ") (let VectorElement (<-address V1840 V1841) (if (= VectorElement (fail)) (simple-error "vector element not found
97
97
  ") VectorElement))))
98
98
 
99
- (defun shen.posint? (V1822) (and (integer? V1822) (>= V1822 0)))
99
+ (defun shen.posint? (V1842) (and (integer? V1842) (>= V1842 0)))
100
100
 
101
- (defun limit (V1823) (<-address V1823 0))
101
+ (defun limit (V1843) (<-address V1843 0))
102
102
 
103
- (defun symbol? (V1824) (cond ((or (boolean? V1824) (or (number? V1824) (string? V1824))) false) (true (trap-error (let String (str V1824) (shen.analyse-symbol? String)) (lambda E false)))))
103
+ (defun symbol? (V1844) (cond ((or (boolean? V1844) (or (number? V1844) (string? V1844))) false) (true (trap-error (let String (str V1844) (shen.analyse-symbol? String)) (lambda E false)))))
104
104
 
105
- (defun shen.analyse-symbol? (V1825) (cond ((shen.+string? V1825) (and (shen.alpha? (pos V1825 0)) (shen.alphanums? (tlstr V1825)))) (true (shen.sys-error shen.analyse-symbol?))))
105
+ (defun shen.analyse-symbol? (V1845) (cond ((shen.+string? V1845) (and (shen.alpha? (pos V1845 0)) (shen.alphanums? (tlstr V1845)))) (true (shen.sys-error shen.analyse-symbol?))))
106
106
 
107
- (defun shen.alpha? (V1826) (element? V1826 (cons "A" (cons "B" (cons "C" (cons "D" (cons "E" (cons "F" (cons "G" (cons "H" (cons "I" (cons "J" (cons "K" (cons "L" (cons "M" (cons "N" (cons "O" (cons "P" (cons "Q" (cons "R" (cons "S" (cons "T" (cons "U" (cons "V" (cons "W" (cons "X" (cons "Y" (cons "Z" (cons "a" (cons "b" (cons "c" (cons "d" (cons "e" (cons "f" (cons "g" (cons "h" (cons "i" (cons "j" (cons "k" (cons "l" (cons "m" (cons "n" (cons "o" (cons "p" (cons "q" (cons "r" (cons "s" (cons "t" (cons "u" (cons "v" (cons "w" (cons "x" (cons "y" (cons "z" (cons "=" (cons "*" (cons "/" (cons "+" (cons "-" (cons "_" (cons "?" (cons "$" (cons "!" (cons "@" (cons "~" (cons ">" (cons "<" (cons "&" (cons "%" (cons "{" (cons "}" (cons ":" (cons ";" (cons "`" (cons "#" (cons "'" (cons "." ())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
107
+ (defun shen.alpha? (V1846) (element? V1846 (cons "A" (cons "B" (cons "C" (cons "D" (cons "E" (cons "F" (cons "G" (cons "H" (cons "I" (cons "J" (cons "K" (cons "L" (cons "M" (cons "N" (cons "O" (cons "P" (cons "Q" (cons "R" (cons "S" (cons "T" (cons "U" (cons "V" (cons "W" (cons "X" (cons "Y" (cons "Z" (cons "a" (cons "b" (cons "c" (cons "d" (cons "e" (cons "f" (cons "g" (cons "h" (cons "i" (cons "j" (cons "k" (cons "l" (cons "m" (cons "n" (cons "o" (cons "p" (cons "q" (cons "r" (cons "s" (cons "t" (cons "u" (cons "v" (cons "w" (cons "x" (cons "y" (cons "z" (cons "=" (cons "*" (cons "/" (cons "+" (cons "-" (cons "_" (cons "?" (cons "$" (cons "!" (cons "@" (cons "~" (cons ">" (cons "<" (cons "&" (cons "%" (cons "{" (cons "}" (cons ":" (cons ";" (cons "`" (cons "#" (cons "'" (cons "." ())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
108
108
 
109
- (defun shen.alphanums? (V1827) (cond ((= "" V1827) true) ((shen.+string? V1827) (and (shen.alphanum? (pos V1827 0)) (shen.alphanums? (tlstr V1827)))) (true (shen.sys-error shen.alphanums?))))
109
+ (defun shen.alphanums? (V1847) (cond ((= "" V1847) true) ((shen.+string? V1847) (and (shen.alphanum? (pos V1847 0)) (shen.alphanums? (tlstr V1847)))) (true (shen.sys-error shen.alphanums?))))
110
110
 
111
- (defun shen.alphanum? (V1828) (or (shen.alpha? V1828) (shen.digit? V1828)))
111
+ (defun shen.alphanum? (V1848) (or (shen.alpha? V1848) (shen.digit? V1848)))
112
112
 
113
- (defun shen.digit? (V1829) (element? V1829 (cons "1" (cons "2" (cons "3" (cons "4" (cons "5" (cons "6" (cons "7" (cons "8" (cons "9" (cons "0" ()))))))))))))
113
+ (defun shen.digit? (V1849) (element? V1849 (cons "1" (cons "2" (cons "3" (cons "4" (cons "5" (cons "6" (cons "7" (cons "8" (cons "9" (cons "0" ()))))))))))))
114
114
 
115
- (defun variable? (V1830) (cond ((or (boolean? V1830) (or (number? V1830) (string? V1830))) false) (true (trap-error (let String (str V1830) (shen.analyse-variable? String)) (lambda E false)))))
115
+ (defun variable? (V1850) (cond ((or (boolean? V1850) (or (number? V1850) (string? V1850))) false) (true (trap-error (let String (str V1850) (shen.analyse-variable? String)) (lambda E false)))))
116
116
 
117
- (defun shen.analyse-variable? (V1831) (cond ((shen.+string? V1831) (and (shen.uppercase? (pos V1831 0)) (shen.alphanums? (tlstr V1831)))) (true (shen.sys-error shen.analyse-variable?))))
117
+ (defun shen.analyse-variable? (V1851) (cond ((shen.+string? V1851) (and (shen.uppercase? (pos V1851 0)) (shen.alphanums? (tlstr V1851)))) (true (shen.sys-error shen.analyse-variable?))))
118
118
 
119
- (defun shen.uppercase? (V1832) (element? V1832 (cons "A" (cons "B" (cons "C" (cons "D" (cons "E" (cons "F" (cons "G" (cons "H" (cons "I" (cons "J" (cons "K" (cons "L" (cons "M" (cons "N" (cons "O" (cons "P" (cons "Q" (cons "R" (cons "S" (cons "T" (cons "U" (cons "V" (cons "W" (cons "X" (cons "Y" (cons "Z" ()))))))))))))))))))))))))))))
119
+ (defun shen.uppercase? (V1852) (element? V1852 (cons "A" (cons "B" (cons "C" (cons "D" (cons "E" (cons "F" (cons "G" (cons "H" (cons "I" (cons "J" (cons "K" (cons "L" (cons "M" (cons "N" (cons "O" (cons "P" (cons "Q" (cons "R" (cons "S" (cons "T" (cons "U" (cons "V" (cons "W" (cons "X" (cons "Y" (cons "Z" ()))))))))))))))))))))))))))))
120
120
 
121
- (defun gensym (V1833) (concat V1833 (set shen.*gensym* (+ 1 (value shen.*gensym*)))))
121
+ (defun gensym (V1853) (concat V1853 (set shen.*gensym* (+ 1 (value shen.*gensym*)))))
122
122
 
123
- (defun concat (V1834 V1835) (intern (cn (str V1834) (str V1835))))
123
+ (defun concat (V1854 V1855) (intern (cn (str V1854) (str V1855))))
124
124
 
125
- (defun @p (V1836 V1837) (let Vector (absvector 3) (let Tag (address-> Vector 0 shen.tuple) (let Fst (address-> Vector 1 V1836) (let Snd (address-> Vector 2 V1837) Vector)))))
125
+ (defun @p (V1856 V1857) (let Vector (absvector 3) (let Tag (address-> Vector 0 shen.tuple) (let Fst (address-> Vector 1 V1856) (let Snd (address-> Vector 2 V1857) Vector)))))
126
126
 
127
- (defun fst (V1838) (<-address V1838 1))
127
+ (defun fst (V1858) (<-address V1858 1))
128
128
 
129
- (defun snd (V1839) (<-address V1839 2))
129
+ (defun snd (V1859) (<-address V1859 2))
130
130
 
131
- (defun tuple? (V1840) (trap-error (and (absvector? V1840) (= shen.tuple (<-address V1840 0))) (lambda E false)))
131
+ (defun tuple? (V1860) (trap-error (and (absvector? V1860) (= shen.tuple (<-address V1860 0))) (lambda E false)))
132
132
 
133
- (defun append (V1841 V1842) (cond ((= () V1841) V1842) ((cons? V1841) (cons (hd V1841) (append (tl V1841) V1842))) (true (shen.sys-error append))))
133
+ (defun append (V1861 V1862) (cond ((= () V1861) V1862) ((cons? V1861) (cons (hd V1861) (append (tl V1861) V1862))) (true (shen.sys-error append))))
134
134
 
135
- (defun @v (V1843 V1844) (let Limit (limit V1844) (let NewVector (vector (+ Limit 1)) (let X+NewVector (vector-> NewVector 1 V1843) (if (= Limit 0) X+NewVector (shen.@v-help V1844 1 Limit X+NewVector))))))
135
+ (defun @v (V1863 V1864) (let Limit (limit V1864) (let NewVector (vector (+ Limit 1)) (let X+NewVector (vector-> NewVector 1 V1863) (if (= Limit 0) X+NewVector (shen.@v-help V1864 1 Limit X+NewVector))))))
136
136
 
137
- (defun shen.@v-help (V1845 V1846 V1847 V1848) (cond ((= V1847 V1846) (shen.copyfromvector V1845 V1848 V1847 (+ V1847 1))) (true (shen.@v-help V1845 (+ V1846 1) V1847 (shen.copyfromvector V1845 V1848 V1846 (+ V1846 1))))))
137
+ (defun shen.@v-help (V1865 V1866 V1867 V1868) (cond ((= V1867 V1866) (shen.copyfromvector V1865 V1868 V1867 (+ V1867 1))) (true (shen.@v-help V1865 (+ V1866 1) V1867 (shen.copyfromvector V1865 V1868 V1866 (+ V1866 1))))))
138
138
 
139
- (defun shen.copyfromvector (V1850 V1851 V1852 V1853) (trap-error (vector-> V1851 V1853 (<-vector V1850 V1852)) (lambda E V1851)))
139
+ (defun shen.copyfromvector (V1870 V1871 V1872 V1873) (trap-error (vector-> V1871 V1873 (<-vector V1870 V1872)) (lambda E V1871)))
140
140
 
141
- (defun hdv (V1854) (trap-error (<-vector V1854 1) (lambda E (simple-error (cn "hdv needs a non-empty vector as an argument; not " (shen.app V1854 "
141
+ (defun hdv (V1874) (trap-error (<-vector V1874 1) (lambda E (simple-error (cn "hdv needs a non-empty vector as an argument; not " (shen.app V1874 "
142
142
  " shen.s))))))
143
143
 
144
- (defun tlv (V1855) (let Limit (limit V1855) (if (= Limit 0) (simple-error "cannot take the tail of the empty vector
145
- ") (if (= Limit 1) (vector 0) (let NewVector (vector (- Limit 1)) (shen.tlv-help V1855 2 Limit (vector (- Limit 1))))))))
144
+ (defun tlv (V1875) (let Limit (limit V1875) (if (= Limit 0) (simple-error "cannot take the tail of the empty vector
145
+ ") (if (= Limit 1) (vector 0) (let NewVector (vector (- Limit 1)) (shen.tlv-help V1875 2 Limit (vector (- Limit 1))))))))
146
146
 
147
- (defun shen.tlv-help (V1856 V1857 V1858 V1859) (cond ((= V1858 V1857) (shen.copyfromvector V1856 V1859 V1858 (- V1858 1))) (true (shen.tlv-help V1856 (+ V1857 1) V1858 (shen.copyfromvector V1856 V1859 V1857 (- V1857 1))))))
147
+ (defun shen.tlv-help (V1876 V1877 V1878 V1879) (cond ((= V1878 V1877) (shen.copyfromvector V1876 V1879 V1878 (- V1878 1))) (true (shen.tlv-help V1876 (+ V1877 1) V1878 (shen.copyfromvector V1876 V1879 V1877 (- V1877 1))))))
148
148
 
149
- (defun assoc (V1869 V1870) (cond ((= () V1870) ()) ((and (cons? V1870) (and (cons? (hd V1870)) (= (hd (hd V1870)) V1869))) (hd V1870)) ((cons? V1870) (assoc V1869 (tl V1870))) (true (shen.sys-error assoc))))
149
+ (defun assoc (V1889 V1890) (cond ((= () V1890) ()) ((and (cons? V1890) (and (cons? (hd V1890)) (= (hd (hd V1890)) V1889))) (hd V1890)) ((cons? V1890) (assoc V1889 (tl V1890))) (true (shen.sys-error assoc))))
150
150
 
151
- (defun boolean? (V1876) (cond ((= true V1876) true) ((= false V1876) true) (true false)))
151
+ (defun boolean? (V1896) (cond ((= true V1896) true) ((= false V1896) true) (true false)))
152
152
 
153
- (defun nl (V1877) (cond ((= 0 V1877) 0) (true (do (shen.prhush "
154
- " (stoutput)) (nl (- V1877 1))))))
153
+ (defun nl (V1897) (cond ((= 0 V1897) 0) (true (do (shen.prhush "
154
+ " (stoutput)) (nl (- V1897 1))))))
155
155
 
156
- (defun difference (V1880 V1881) (cond ((= () V1880) ()) ((cons? V1880) (if (element? (hd V1880) V1881) (difference (tl V1880) V1881) (cons (hd V1880) (difference (tl V1880) V1881)))) (true (shen.sys-error difference))))
156
+ (defun difference (V1900 V1901) (cond ((= () V1900) ()) ((cons? V1900) (if (element? (hd V1900) V1901) (difference (tl V1900) V1901) (cons (hd V1900) (difference (tl V1900) V1901)))) (true (shen.sys-error difference))))
157
157
 
158
- (defun do (V1882 V1883) V1883)
158
+ (defun do (V1902 V1903) V1903)
159
159
 
160
- (defun element? (V1892 V1893) (cond ((= () V1893) false) ((and (cons? V1893) (= (hd V1893) V1892)) true) ((cons? V1893) (element? V1892 (tl V1893))) (true (shen.sys-error element?))))
160
+ (defun element? (V1912 V1913) (cond ((= () V1913) false) ((and (cons? V1913) (= (hd V1913) V1912)) true) ((cons? V1913) (element? V1912 (tl V1913))) (true (shen.sys-error element?))))
161
161
 
162
- (defun empty? (V1899) (cond ((= () V1899) true) (true false)))
162
+ (defun empty? (V1919) (cond ((= () V1919) true) (true false)))
163
163
 
164
- (defun fix (V1900 V1901) (shen.fix-help V1900 V1901 (V1900 V1901)))
164
+ (defun fix (V1920 V1921) (shen.fix-help V1920 V1921 (V1920 V1921)))
165
165
 
166
- (defun shen.fix-help (V1908 V1909 V1910) (cond ((= V1910 V1909) V1910) (true (shen.fix-help V1908 V1910 (V1908 V1910)))))
166
+ (defun shen.fix-help (V1928 V1929 V1930) (cond ((= V1930 V1929) V1930) (true (shen.fix-help V1928 V1930 (V1928 V1930)))))
167
167
 
168
- (defun put (V1912 V1913 V1914 V1915) (let N (hash V1912 (limit V1915)) (let Entry (trap-error (<-vector V1915 N) (lambda E ())) (let Change (vector-> V1915 N (shen.change-pointer-value V1912 V1913 V1914 Entry)) V1914))))
168
+ (defun put (V1932 V1933 V1934 V1935) (let N (hash V1932 (limit V1935)) (let Entry (trap-error (<-vector V1935 N) (lambda E ())) (let Change (vector-> V1935 N (shen.change-pointer-value V1932 V1933 V1934 Entry)) V1934))))
169
169
 
170
- (defun shen.change-pointer-value (V1918 V1919 V1920 V1921) (cond ((= () V1921) (cons (cons (cons V1918 (cons V1919 ())) V1920) ())) ((and (cons? V1921) (and (cons? (hd V1921)) (and (cons? (hd (hd V1921))) (and (cons? (tl (hd (hd V1921)))) (and (= () (tl (tl (hd (hd V1921))))) (and (= (hd (tl (hd (hd V1921)))) V1919) (= (hd (hd (hd V1921))) V1918))))))) (cons (cons (hd (hd V1921)) V1920) (tl V1921))) ((cons? V1921) (cons (hd V1921) (shen.change-pointer-value V1918 V1919 V1920 (tl V1921)))) (true (shen.sys-error shen.change-pointer-value))))
170
+ (defun shen.change-pointer-value (V1938 V1939 V1940 V1941) (cond ((= () V1941) (cons (cons (cons V1938 (cons V1939 ())) V1940) ())) ((and (cons? V1941) (and (cons? (hd V1941)) (and (cons? (hd (hd V1941))) (and (cons? (tl (hd (hd V1941)))) (and (= () (tl (tl (hd (hd V1941))))) (and (= (hd (tl (hd (hd V1941)))) V1939) (= (hd (hd (hd V1941))) V1938))))))) (cons (cons (hd (hd V1941)) V1940) (tl V1941))) ((cons? V1941) (cons (hd V1941) (shen.change-pointer-value V1938 V1939 V1940 (tl V1941)))) (true (shen.sys-error shen.change-pointer-value))))
171
171
 
172
- (defun get (V1924 V1925 V1926) (let N (hash V1924 (limit V1926)) (let Entry (trap-error (<-vector V1926 N) (lambda E (simple-error "pointer not found
173
- "))) (let Result (assoc (cons V1924 (cons V1925 ())) Entry) (if (empty? Result) (simple-error "value not found
172
+ (defun get (V1944 V1945 V1946) (let N (hash V1944 (limit V1946)) (let Entry (trap-error (<-vector V1946 N) (lambda E (simple-error "pointer not found
173
+ "))) (let Result (assoc (cons V1944 (cons V1945 ())) Entry) (if (empty? Result) (simple-error "value not found
174
174
  ") (tl Result))))))
175
175
 
176
- (defun hash (V1927 V1928) (let Hash (shen.mod (shen.sum (map (lambda V1781 (string->n V1781)) (explode V1927))) V1928) (if (= 0 Hash) 1 Hash)))
176
+ (defun hash (V1947 V1948) (let Hash (shen.mod (shen.sum (map (lambda V1801 (string->n V1801)) (explode V1947))) V1948) (if (= 0 Hash) 1 Hash)))
177
177
 
178
- (defun shen.mod (V1929 V1930) (shen.modh V1929 (shen.multiples V1929 (cons V1930 ()))))
178
+ (defun shen.mod (V1949 V1950) (shen.modh V1949 (shen.multiples V1949 (cons V1950 ()))))
179
179
 
180
- (defun shen.multiples (V1931 V1932) (cond ((and (cons? V1932) (> (hd V1932) V1931)) (tl V1932)) ((cons? V1932) (shen.multiples V1931 (cons (* 2 (hd V1932)) V1932))) (true (shen.sys-error shen.multiples))))
180
+ (defun shen.multiples (V1951 V1952) (cond ((and (cons? V1952) (> (hd V1952) V1951)) (tl V1952)) ((cons? V1952) (shen.multiples V1951 (cons (* 2 (hd V1952)) V1952))) (true (shen.sys-error shen.multiples))))
181
181
 
182
- (defun shen.modh (V1935 V1936) (cond ((= 0 V1935) 0) ((= () V1936) V1935) ((and (cons? V1936) (> (hd V1936) V1935)) (if (empty? (tl V1936)) V1935 (shen.modh V1935 (tl V1936)))) ((cons? V1936) (shen.modh (- V1935 (hd V1936)) V1936)) (true (shen.sys-error shen.modh))))
182
+ (defun shen.modh (V1955 V1956) (cond ((= 0 V1955) 0) ((= () V1956) V1955) ((and (cons? V1956) (> (hd V1956) V1955)) (if (empty? (tl V1956)) V1955 (shen.modh V1955 (tl V1956)))) ((cons? V1956) (shen.modh (- V1955 (hd V1956)) V1956)) (true (shen.sys-error shen.modh))))
183
183
 
184
- (defun shen.sum (V1937) (cond ((= () V1937) 0) ((cons? V1937) (+ (hd V1937) (shen.sum (tl V1937)))) (true (shen.sys-error shen.sum))))
184
+ (defun shen.sum (V1957) (cond ((= () V1957) 0) ((cons? V1957) (+ (hd V1957) (shen.sum (tl V1957)))) (true (shen.sys-error shen.sum))))
185
185
 
186
- (defun head (V1944) (cond ((cons? V1944) (hd V1944)) (true (simple-error "head expects a non-empty list"))))
186
+ (defun head (V1964) (cond ((cons? V1964) (hd V1964)) (true (simple-error "head expects a non-empty list"))))
187
187
 
188
- (defun tail (V1951) (cond ((cons? V1951) (tl V1951)) (true (simple-error "tail expects a non-empty list"))))
188
+ (defun tail (V1971) (cond ((cons? V1971) (tl V1971)) (true (simple-error "tail expects a non-empty list"))))
189
189
 
190
- (defun hdstr (V1952) (pos V1952 0))
190
+ (defun hdstr (V1972) (pos V1972 0))
191
191
 
192
- (defun intersection (V1955 V1956) (cond ((= () V1955) ()) ((cons? V1955) (if (element? (hd V1955) V1956) (cons (hd V1955) (intersection (tl V1955) V1956)) (intersection (tl V1955) V1956))) (true (shen.sys-error intersection))))
192
+ (defun intersection (V1975 V1976) (cond ((= () V1975) ()) ((cons? V1975) (if (element? (hd V1975) V1976) (cons (hd V1975) (intersection (tl V1975) V1976)) (intersection (tl V1975) V1976))) (true (shen.sys-error intersection))))
193
193
 
194
- (defun reverse (V1957) (shen.reverse_help V1957 ()))
194
+ (defun reverse (V1977) (shen.reverse_help V1977 ()))
195
195
 
196
- (defun shen.reverse_help (V1958 V1959) (cond ((= () V1958) V1959) ((cons? V1958) (shen.reverse_help (tl V1958) (cons (hd V1958) V1959))) (true (shen.sys-error shen.reverse_help))))
196
+ (defun shen.reverse_help (V1978 V1979) (cond ((= () V1978) V1979) ((cons? V1978) (shen.reverse_help (tl V1978) (cons (hd V1978) V1979))) (true (shen.sys-error shen.reverse_help))))
197
197
 
198
- (defun union (V1960 V1961) (cond ((= () V1960) V1961) ((cons? V1960) (if (element? (hd V1960) V1961) (union (tl V1960) V1961) (cons (hd V1960) (union (tl V1960) V1961)))) (true (shen.sys-error union))))
198
+ (defun union (V1980 V1981) (cond ((= () V1980) V1981) ((cons? V1980) (if (element? (hd V1980) V1981) (union (tl V1980) V1981) (cons (hd V1980) (union (tl V1980) V1981)))) (true (shen.sys-error union))))
199
199
 
200
- (defun y-or-n? (V1962) (let Message (shen.prhush (shen.proc-nl V1962) (stoutput)) (let Y-or-N (shen.prhush " (y/n) " (stoutput)) (let Input (shen.app (input) "" shen.s) (if (= "y" Input) true (if (= "n" Input) false (do (shen.prhush "please answer y or n
201
- " (stoutput)) (y-or-n? V1962))))))))
200
+ (defun y-or-n? (V1982) (let Message (shen.prhush (shen.proc-nl V1982) (stoutput)) (let Y-or-N (shen.prhush " (y/n) " (stoutput)) (let Input (shen.app (read (stinput)) "" shen.s) (if (= "y" Input) true (if (= "n" Input) false (do (shen.prhush "please answer y or n
201
+ " (stoutput)) (y-or-n? V1982))))))))
202
202
 
203
- (defun not (V1963) (if V1963 false true))
203
+ (defun not (V1983) (if V1983 false true))
204
204
 
205
- (defun subst (V1972 V1973 V1974) (cond ((= V1974 V1973) V1972) ((cons? V1974) (cons (subst V1972 V1973 (hd V1974)) (subst V1972 V1973 (tl V1974)))) (true V1974)))
205
+ (defun subst (V1992 V1993 V1994) (cond ((= V1994 V1993) V1992) ((cons? V1994) (cons (subst V1992 V1993 (hd V1994)) (subst V1992 V1993 (tl V1994)))) (true V1994)))
206
206
 
207
- (defun explode (V1976) (shen.explode-h (shen.app V1976 "" shen.a)))
207
+ (defun explode (V1996) (shen.explode-h (shen.app V1996 "" shen.a)))
208
208
 
209
- (defun shen.explode-h (V1977) (cond ((= "" V1977) ()) ((shen.+string? V1977) (cons (pos V1977 0) (shen.explode-h (tlstr V1977)))) (true (shen.sys-error shen.explode-h))))
209
+ (defun shen.explode-h (V1997) (cond ((= "" V1997) ()) ((shen.+string? V1997) (cons (pos V1997 0) (shen.explode-h (tlstr V1997)))) (true (shen.sys-error shen.explode-h))))
210
210
 
211
- (defun cd (V1978) (set *home-directory* (if (= V1978 "") "" (shen.app V1978 "/" shen.a))))
211
+ (defun cd (V1998) (set *home-directory* (if (= V1998 "") "" (shen.app V1998 "/" shen.a))))
212
212
 
213
- (defun map (V1979 V1980) (shen.map-h V1979 V1980 ()))
213
+ (defun map (V1999 V2000) (shen.map-h V1999 V2000 ()))
214
214
 
215
- (defun shen.map-h (V1983 V1984 V1985) (cond ((= () V1984) (reverse V1985)) ((cons? V1984) (shen.map-h V1983 (tl V1984) (cons (V1983 (hd V1984)) V1985))) (true (shen.sys-error shen.map-h))))
215
+ (defun shen.map-h (V2003 V2004 V2005) (cond ((= () V2004) (reverse V2005)) ((cons? V2004) (shen.map-h V2003 (tl V2004) (cons (V2003 (hd V2004)) V2005))) (true (shen.sys-error shen.map-h))))
216
216
 
217
- (defun length (V1986) (shen.length-h V1986 0))
217
+ (defun length (V2006) (shen.length-h V2006 0))
218
218
 
219
- (defun shen.length-h (V1987 V1988) (cond ((= () V1987) V1988) (true (shen.length-h (tl V1987) (+ V1988 1)))))
219
+ (defun shen.length-h (V2007 V2008) (cond ((= () V2007) V2008) (true (shen.length-h (tl V2007) (+ V2008 1)))))
220
220
 
221
- (defun occurrences (V1997 V1998) (cond ((= V1998 V1997) 1) ((cons? V1998) (+ (occurrences V1997 (hd V1998)) (occurrences V1997 (tl V1998)))) (true 0)))
221
+ (defun occurrences (V2017 V2018) (cond ((= V2018 V2017) 1) ((cons? V2018) (+ (occurrences V2017 (hd V2018)) (occurrences V2017 (tl V2018)))) (true 0)))
222
222
 
223
- (defun nth (V2006 V2007) (cond ((and (= 1 V2006) (cons? V2007)) (hd V2007)) ((cons? V2007) (nth (- V2006 1) (tl V2007))) (true (shen.sys-error nth))))
223
+ (defun nth (V2026 V2027) (cond ((and (= 1 V2026) (cons? V2027)) (hd V2027)) ((cons? V2027) (nth (- V2026 1) (tl V2027))) (true (shen.sys-error nth))))
224
224
 
225
- (defun integer? (V2008) (and (number? V2008) (let Abs (shen.abs V2008) (shen.integer-test? Abs (shen.magless Abs 1)))))
225
+ (defun integer? (V2028) (and (number? V2028) (let Abs (shen.abs V2028) (shen.integer-test? Abs (shen.magless Abs 1)))))
226
226
 
227
- (defun shen.abs (V2009) (if (> V2009 0) V2009 (- 0 V2009)))
227
+ (defun shen.abs (V2029) (if (> V2029 0) V2029 (- 0 V2029)))
228
228
 
229
- (defun shen.magless (V2010 V2011) (let Nx2 (* V2011 2) (if (> Nx2 V2010) V2011 (shen.magless V2010 Nx2))))
229
+ (defun shen.magless (V2030 V2031) (let Nx2 (* V2031 2) (if (> Nx2 V2030) V2031 (shen.magless V2030 Nx2))))
230
230
 
231
- (defun shen.integer-test? (V2015 V2016) (cond ((= 0 V2015) true) ((> 1 V2015) false) (true (let Abs-N (- V2015 V2016) (if (> 0 Abs-N) (integer? V2015) (shen.integer-test? Abs-N V2016))))))
231
+ (defun shen.integer-test? (V2035 V2036) (cond ((= 0 V2035) true) ((> 1 V2035) false) (true (let Abs-N (- V2035 V2036) (if (> 0 Abs-N) (integer? V2035) (shen.integer-test? Abs-N V2036))))))
232
232
 
233
- (defun mapcan (V2019 V2020) (cond ((= () V2020) ()) ((cons? V2020) (append (V2019 (hd V2020)) (mapcan V2019 (tl V2020)))) (true (shen.sys-error mapcan))))
233
+ (defun mapcan (V2039 V2040) (cond ((= () V2040) ()) ((cons? V2040) (append (V2039 (hd V2040)) (mapcan V2039 (tl V2040)))) (true (shen.sys-error mapcan))))
234
234
 
235
- (defun read-file-as-bytelist (V2021) (let Stream (open file V2021 in) (let Byte (read-byte Stream) (let Bytes (shen.read-file-as-bytelist-help Stream Byte ()) (let Close (close Stream) (reverse Bytes))))))
236
-
237
- (defun shen.read-file-as-bytelist-help (V2022 V2023 V2024) (cond ((= -1 V2023) V2024) (true (shen.read-file-as-bytelist-help V2022 (read-byte V2022) (cons V2023 V2024)))))
238
-
239
- (defun read-file-as-string (V2025) (let Stream (open file V2025 in) (shen.rfas-h Stream (read-byte Stream) "")))
240
-
241
- (defun shen.rfas-h (V2026 V2027 V2028) (cond ((= -1 V2027) (do (close V2026) V2028)) (true (shen.rfas-h V2026 (read-byte V2026) (cn V2028 (n->string V2027))))))
242
-
243
- (defun == (V2037 V2038) (cond ((= V2038 V2037) true) (true false)))
235
+ (defun == (V2049 V2050) (cond ((= V2050 V2049) true) (true false)))
244
236
 
245
237
  (defun abort () (simple-error ""))
246
238
 
247
- (defun read () (hd (lineread)))
248
-
249
- (defun input () (eval (read)))
250
-
251
- (defun input+ (V2044 V2045) (let Input (read) (let Check (shen.typecheck Input V2045) (if (= false Check) (do (shen.prhush (cn "input is not of type " (shen.app V2045 ": please re-enter " shen.r)) (stoutput)) (input+ : V2045)) (eval Input)))))
252
-
253
- (defun read+ (V2050 V2051) (let Input (read) (let Check (shen.typecheck (shen.rcons_form Input) V2051) (if (= false Check) (do (shen.prhush (cn "input is not of type " (shen.app V2051 ": please re-enter " shen.r)) (stoutput)) (read+ : V2051)) Input))))
254
-
255
239
  (defun bound? (V2052) (and (symbol? V2052) (let Val (trap-error (value V2052) (lambda E shen.this-symbol-is-unbound)) (if (= Val shen.this-symbol-is-unbound) false true))))
256
240
 
257
241
  (defun shen.string->bytes (V2053) (cond ((= "" V2053) ()) (true (cons (string->n (pos V2053 0)) (shen.string->bytes (tlstr V2053))))))