shen-ruby 0.4.1 → 0.5.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (21) hide show
  1. data/HISTORY.md +8 -0
  2. data/MIT_LICENSE.txt +1 -1
  3. data/README.md +4 -3
  4. data/lib/kl/primitives/vectors.rb +1 -0
  5. data/lib/shen_ruby/version.rb +1 -1
  6. data/shen-ruby.gemspec +1 -1
  7. data/shen/release/k_lambda/core.kl +67 -59
  8. data/shen/release/k_lambda/declarations.kl +13 -9
  9. data/shen/release/k_lambda/load.kl +17 -15
  10. data/shen/release/k_lambda/macros.kl +33 -31
  11. data/shen/release/k_lambda/prolog.kl +97 -97
  12. data/shen/release/k_lambda/reader.kl +71 -63
  13. data/shen/release/k_lambda/sequent.kl +55 -51
  14. data/shen/release/k_lambda/sys.kl +107 -102
  15. data/shen/release/k_lambda/t-star.kl +51 -55
  16. data/shen/release/k_lambda/toplevel.kl +30 -29
  17. data/shen/release/k_lambda/track.kl +25 -25
  18. data/shen/release/k_lambda/types.kl +10 -6
  19. data/shen/release/k_lambda/writer.kl +24 -20
  20. data/shen/release/k_lambda/yacc.kl +28 -26
  21. metadata +3 -3
data/shen/release/k_lambda/sequent.kl CHANGED
@@ -47,110 +47,114 @@
47
47
  * explains this license in full. *
48
48
  * *
49
49
  *****************************************************************************************
50
- "(defun shen.datatype-error (V1591) (cond ((and (cons? V1591) (and (cons? (tl V1591)) (= () (tl (tl V1591))))) (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 V1591)) "
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> (V1596) (let Result (let Parse_shen.<datatype-rule> (shen.<datatype-rule> V1596) (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> V1596) (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> (V1601) (let Result (let Parse_shen.<side-conditions> (shen.<side-conditions> V1601) (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> V1601) (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> (V1606) (let Result (let Parse_shen.<side-condition> (shen.<side-condition> V1606) (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> V1606) (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> (V1611) (let Result (if (and (cons? (hd V1611)) (= if (hd (hd V1611)))) (let Parse_shen.<expr> (shen.<expr> (shen.pair (tl (hd V1611)) (shen.hdtl V1611))) (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 V1611)) (= let (hd (hd V1611)))) (let Parse_shen.<variable?> (shen.<variable?> (shen.pair (tl (hd V1611)) (shen.hdtl V1611))) (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?> (V1616) (let Result (if (cons? (hd V1616)) (let Parse_X (hd (hd V1616)) (if (variable? Parse_X) (shen.pair (hd (shen.pair (tl (hd V1616)) (shen.hdtl V1616))) 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> (V1621) (let Result (if (cons? (hd V1621)) (let Parse_X (hd (hd V1621)) (if (not (or (element? Parse_X (cons >> (cons ; ()))) (or (shen.singleunderline? Parse_X) (shen.doubleunderline? Parse_X)))) (shen.pair (hd (shen.pair (tl (hd V1621)) (shen.hdtl V1621))) (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 (V1622) (cond ((and (cons? V1622) (and (cons? (tl V1622)) (and (cons? (tl (tl V1622))) (and (= () (tl (tl (tl V1622)))) (= (hd (tl V1622)) bar!))))) (cons (hd V1622) (hd (tl (tl V1622))))) ((cons? V1622) (cons (shen.remove-bar (hd V1622)) (shen.remove-bar (tl V1622)))) (true V1622)))
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> (V1627) (let Result (let Parse_shen.<premise> (shen.<premise> V1627) (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> V1627) (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> (V1632) (let Result (if (cons? (hd V1632)) (let Parse_X (hd (hd V1632)) (if (= Parse_X ;) (shen.pair (hd (shen.pair (tl (hd V1632)) (shen.hdtl V1632))) 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> (V1637) (let Result (if (and (cons? (hd V1637)) (= ! (hd (hd V1637)))) (shen.pair (hd (shen.pair (tl (hd V1637)) (shen.hdtl V1637))) !) (fail)) (if (= Result (fail)) (let Result (let Parse_shen.<formulae> (shen.<formulae> V1637) (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> V1637) (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> (V1642) (let Result (let Parse_shen.<formulae> (shen.<formulae> V1642) (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> V1642) (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 (V1643 V1644) (@p V1643 V1644))
77
+ (defun shen.sequent (V1684 V1685) (@p V1684 V1685))
78
78
 
79
- (defun shen.<formulae> (V1649) (let Result (let Parse_shen.<formula> (shen.<formula> V1649) (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> V1649) (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> V1649) (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> (V1654) (let Result (if (cons? (hd V1654)) (let Parse_X (hd (hd V1654)) (if (= Parse_X (intern ",")) (shen.pair (hd (shen.pair (tl (hd V1654)) (shen.hdtl V1654))) 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> (V1659) (let Result (let Parse_shen.<expr> (shen.<expr> V1659) (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> V1659) (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> (V1664) (let Result (let Parse_shen.<expr> (shen.<expr> V1664) (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> (V1669) (let Result (if (cons? (hd V1669)) (let Parse_X (hd (hd V1669)) (if (shen.doubleunderline? Parse_X) (shen.pair (hd (shen.pair (tl (hd V1669)) (shen.hdtl V1669))) 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> (V1674) (let Result (if (cons? (hd V1674)) (let Parse_X (hd (hd V1674)) (if (shen.singleunderline? Parse_X) (shen.pair (hd (shen.pair (tl (hd V1674)) (shen.hdtl V1674))) 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? (V1675) (and (symbol? V1675) (shen.sh? (str V1675))))
91
+ (defun shen.singleunderline? (V1716) (and (symbol? V1716) (shen.sh? (str V1716))))
92
92
 
93
- (defun shen.sh? (V1676) (cond ((= "_" V1676) true) (true (and (= (pos V1676 0) "_") (shen.sh? (tlstr V1676))))))
93
+ (defun shen.sh? (V1717) (cond ((= "_" V1717) true) (true (and (= (pos V1717 0) "_") (shen.sh? (tlstr V1717))))))
94
94
 
95
- (defun shen.doubleunderline? (V1677) (and (symbol? V1677) (shen.dh? (str V1677))))
95
+ (defun shen.doubleunderline? (V1718) (and (symbol? V1718) (shen.dh? (str V1718))))
96
96
 
97
- (defun shen.dh? (V1678) (cond ((= "=" V1678) true) (true (and (= (pos V1678 0) "=") (shen.dh? (tlstr V1678))))))
97
+ (defun shen.dh? (V1719) (cond ((= "=" V1719) true) (true (and (= (pos V1719 0) "=") (shen.dh? (tlstr V1719))))))
98
98
 
99
- (defun shen.process-datatype (V1679 V1680) (shen.remember-datatype (shen.s-prolog (shen.rules->horn-clauses V1679 V1680))))
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 (V1685) (cond ((cons? V1685) (do (set shen.*datatypes* (adjoin (hd V1685) (value shen.*datatypes*))) (do (set shen.*alldatatypes* (adjoin (hd V1685) (value shen.*alldatatypes*))) (hd V1685)))) (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 (V1688 V1689) (cond ((= () V1689) ()) ((and (cons? V1689) (and (tuple? (hd V1689)) (= shen.single (fst (hd V1689))))) (cons (shen.rule->horn-clause V1688 (snd (hd V1689))) (shen.rules->horn-clauses V1688 (tl V1689)))) ((and (cons? V1689) (and (tuple? (hd V1689)) (= shen.double (fst (hd V1689))))) (shen.rules->horn-clauses V1688 (append (shen.double->singles (snd (hd V1689))) (tl V1689)))) (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 (V1690) (cons (shen.right-rule V1690) (cons (shen.left-rule V1690) ())))
105
+ (defun shen.double->singles (V1731) (cons (shen.right-rule V1731) (cons (shen.left-rule V1731) ())))
106
106
 
107
- (defun shen.right-rule (V1691) (@p shen.single V1691))
107
+ (defun shen.right-rule (V1732) (@p shen.single V1732))
108
108
 
109
- (defun shen.left-rule (V1692) (cond ((and (cons? V1692) (and (cons? (tl V1692)) (and (cons? (tl (tl V1692))) (and (tuple? (hd (tl (tl V1692)))) (and (= () (fst (hd (tl (tl V1692))))) (= () (tl (tl (tl V1692))))))))) (let Q (gensym Qv) (let NewConclusion (@p (cons (snd (hd (tl (tl V1692)))) ()) Q) (let NewPremises (cons (@p (map shen.right->left (hd (tl V1692))) Q) ()) (@p shen.single (cons (hd V1692) (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 (V1697) (cond ((and (tuple? V1697) (= () (fst V1697))) (snd V1697)) (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 (V1698 V1699) (cond ((and (cons? V1699) (and (cons? (tl V1699)) (and (cons? (tl (tl V1699))) (and (tuple? (hd (tl (tl V1699)))) (= () (tl (tl (tl V1699)))))))) (cons (shen.rule->horn-clause-head V1698 (snd (hd (tl (tl V1699))))) (cons :- (cons (shen.rule->horn-clause-body (hd V1699) (hd (tl V1699)) (fst (hd (tl (tl V1699))))) ())))) (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 (V1700 V1701) (cons V1700 (cons (shen.mode-ify V1701) (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 (V1702) (cond ((and (cons? V1702) (and (cons? (tl V1702)) (and (= : (hd (tl V1702))) (and (cons? (tl (tl V1702))) (= () (tl (tl (tl V1702)))))))) (cons mode (cons (cons (hd V1702) (cons : (cons (cons mode (cons (hd (tl (tl V1702))) (cons + ()))) ()))) (cons - ())))) (true V1702)))
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 (V1703 V1704 V1705) (let Variables (map shen.extract_vars V1705) (let Predicates (map (lambda X (gensym shen.cl)) V1705) (let SearchLiterals (shen.construct-search-literals Predicates Variables Context_1957 Context1_1957) (let SearchClauses (shen.construct-search-clauses Predicates V1705 Variables) (let SideLiterals (shen.construct-side-literals V1703) (let PremissLiterals (map (lambda X (shen.construct-premiss-literal X (empty? V1705))) V1704) (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 (V1710 V1711 V1712 V1713) (cond ((and (= () V1710) (= () V1711)) ()) (true (shen.csl-help V1710 V1711 V1712 V1713))))
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 (V1716 V1717 V1718 V1719) (cond ((and (= () V1716) (= () V1717)) (cons (cons bind (cons ContextOut_1957 (cons V1718 ()))) ())) ((and (cons? V1716) (cons? V1717)) (cons (cons (hd V1716) (cons V1718 (cons V1719 (hd V1717)))) (shen.csl-help (tl V1716) (tl V1717) V1719 (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 (V1720 V1721 V1722) (cond ((and (= () V1720) (and (= () V1721) (= () V1722))) shen.skip) ((and (cons? V1720) (and (cons? V1721) (cons? V1722))) (do (shen.construct-search-clause (hd V1720) (hd V1721) (hd V1722)) (shen.construct-search-clauses (tl V1720) (tl V1721) (tl V1722)))) (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 (V1723 V1724 V1725) (shen.s-prolog (cons (shen.construct-base-search-clause V1723 V1724 V1725) (cons (shen.construct-recursive-search-clause V1723 V1724 V1725) ()))))
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 (V1726 V1727 V1728) (cons (cons V1726 (cons (cons (shen.mode-ify V1727) In_1957) (cons In_1957 V1728))) (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 (V1729 V1730 V1731) (cons (cons V1729 (cons (cons Assumption_1957 Assumptions_1957) (cons (cons Assumption_1957 Out_1957) V1731))) (cons :- (cons (cons (cons V1729 (cons Assumptions_1957 (cons Out_1957 V1731))) ()) ()))))
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 (V1736) (cond ((= () V1736) ()) ((and (cons? V1736) (and (cons? (hd V1736)) (and (= if (hd (hd V1736))) (and (cons? (tl (hd V1736))) (= () (tl (tl (hd V1736)))))))) (cons (cons when (tl (hd V1736))) (shen.construct-side-literals (tl V1736)))) ((and (cons? V1736) (and (cons? (hd V1736)) (and (= let (hd (hd V1736))) (and (cons? (tl (hd V1736))) (and (cons? (tl (tl (hd V1736)))) (= () (tl (tl (tl (hd V1736)))))))))) (cons (cons is (tl (hd V1736))) (shen.construct-side-literals (tl V1736)))) ((cons? V1736) (shen.construct-side-literals (tl V1736))) (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 (V1741 V1742) (cond ((tuple? V1741) (cons shen.t* (cons (shen.recursive_cons_form (snd V1741)) (cons (shen.construct-context V1742 (fst V1741)) ())))) ((= ! V1741) (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 (V1743 V1744) (cond ((and (= true V1743) (= () V1744)) Context_1957) ((and (= false V1743) (= () V1744)) ContextOut_1957) ((cons? V1744) (cons cons (cons (shen.recursive_cons_form (hd V1744)) (cons (shen.construct-context V1743 (tl V1744)) ())))) (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 (V1745) (cond ((cons? V1745) (cons cons (cons (shen.recursive_cons_form (hd V1745)) (cons (shen.recursive_cons_form (tl V1745)) ())))) (true V1745)))
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 (V1746) (let FilterDatatypes (set shen.*datatypes* (difference (value shen.*datatypes*) V1746)) (value shen.*datatypes*)))
142
+ (defun preclude (V1787) (shen.preclude-h (map shen.intern-type V1787)))
143
143
 
144
- (defun include (V1747) (let ValidTypes (intersection V1747 (value shen.*alldatatypes*)) (let NewDatatypes (set shen.*datatypes* (union ValidTypes (value shen.*datatypes*))) (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 preclude-all-but (V1748) (preclude (difference (value shen.*alldatatypes*) V1748)))
146
+ (defun include (V1789) (shen.include-h (map shen.intern-type V1789)))
147
147
 
148
- (defun include-all-but (V1749) (include (difference (value shen.*alldatatypes*) V1749)))
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 shen.synonyms-help (V1754) (cond ((= () V1754) synonyms) ((and (cons? V1754) (cons? (tl V1754))) (do (shen.pushnew (cons (hd V1754) (shen.curry-type (hd (tl V1754)))) shen.*synonyms*) (shen.synonyms-help (tl (tl V1754))))) (true (simple-error (cn "odd number of synonyms
150
+ (defun preclude-all-but (V1791) (shen.preclude-h (difference (value shen.*alldatatypes*) (map shen.intern-type V1791))))
151
+
152
+ (defun include-all-but (V1792) (shen.include-h (difference (value shen.*alldatatypes*) (map shen.intern-type V1792))))
153
+
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
151
155
  " "")))))
152
156
 
153
- (defun shen.pushnew (V1755 V1756) (if (element? V1755 (value V1756)) (value V1756) (set V1756 (cons V1755 (value V1756)))))
157
+ (defun shen.pushnew (V1798 V1799) (if (element? V1798 (value V1799)) (value V1799) (set V1799 (cons V1798 (value V1799)))))
154
158
 
155
159
 
156
160
 
data/shen/release/k_lambda/sys.kl CHANGED
@@ -47,198 +47,198 @@
47
47
  * explains this license in full. *
48
48
  * *
49
49
  *****************************************************************************************
50
- "(defun thaw (V1759) (V1759))
50
+ "(defun thaw (V1802) (V1802))
51
51
 
52
- (defun eval (V1760) (let Macroexpand (shen.walk (lambda V1757 (macroexpand V1757)) V1760) (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 (V1761) (eval-kl (shen.elim-define (shen.proc-input+ V1761))))
54
+ (defun shen.eval-without-macros (V1804) (eval-kl (shen.elim-define (shen.proc-input+ V1804))))
55
55
 
56
- (defun shen.proc-input+ (V1762) (cond ((and (cons? V1762) (and (= input+ (hd V1762)) (and (cons? (tl V1762)) (and (cons? (tl (tl V1762))) (= () (tl (tl (tl V1762)))))))) (cons input+ (cons (hd (tl V1762)) (cons (shen.rcons_form (hd (tl (tl V1762)))) ())))) ((cons? V1762) (map shen.proc-input+ V1762)) (true V1762)))
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 (hd (tl V1805)) (cons (shen.rcons_form (hd (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 (hd (tl V1805)) (cons (shen.rcons_form (hd (tl (tl V1805)))) ())))) ((cons? V1805) (map shen.proc-input+ V1805)) (true V1805)))
57
57
 
58
- (defun shen.elim-define (V1763) (cond ((and (cons? V1763) (and (= define (hd V1763)) (cons? (tl V1763)))) (shen.shen->kl (hd (tl V1763)) (tl (tl V1763)))) ((and (cons? V1763) (and (= defcc (hd V1763)) (cons? (tl V1763)))) (shen.elim-define (shen.yacc V1763))) ((cons? V1763) (map shen.elim-define V1763)) (true V1763)))
58
+ (defun shen.elim-define (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 (= defcc (hd V1806)) (cons? (tl V1806)))) (shen.elim-define (shen.yacc V1806))) ((cons? V1806) (map shen.elim-define V1806)) (true V1806)))
59
59
 
60
- (defun shen.packaged? (V1770) (cond ((and (cons? V1770) (and (= package (hd V1770)) (and (cons? (tl V1770)) (cons? (tl (tl V1770)))))) true) (true false)))
60
+ (defun shen.packaged? (V1813) (cond ((and (cons? V1813) (and (= package (hd V1813)) (and (cons? (tl V1813)) (cons? (tl (tl V1813)))))) true) (true false)))
61
61
 
62
- (defun external (V1771) (trap-error (get V1771 shen.external-symbols (value *property-vector*)) (lambda E (simple-error (cn "package " (shen.app V1771 " has not been used.
62
+ (defun external (V1814) (trap-error (get V1814 shen.external-symbols (value *property-vector*)) (lambda E (simple-error (cn "package " (shen.app V1814 " has not been used.
63
63
  " shen.a))))))
64
64
 
65
- (defun shen.package-contents (V1774) (cond ((and (cons? V1774) (and (= package (hd V1774)) (and (cons? (tl V1774)) (and (= null (hd (tl V1774))) (cons? (tl (tl V1774))))))) (tl (tl (tl V1774)))) ((and (cons? V1774) (and (= package (hd V1774)) (and (cons? (tl V1774)) (cons? (tl (tl V1774)))))) (shen.packageh (hd (tl V1774)) (hd (tl (tl V1774))) (tl (tl (tl V1774))))) (true (shen.sys-error shen.package-contents))))
65
+ (defun shen.package-contents (V1817) (cond ((and (cons? V1817) (and (= package (hd V1817)) (and (cons? (tl V1817)) (and (= null (hd (tl V1817))) (cons? (tl (tl V1817))))))) (tl (tl (tl V1817)))) ((and (cons? V1817) (and (= package (hd V1817)) (and (cons? (tl V1817)) (cons? (tl (tl V1817)))))) (shen.packageh (hd (tl V1817)) (hd (tl (tl V1817))) (tl (tl (tl V1817))))) (true (shen.sys-error shen.package-contents))))
66
66
 
67
- (defun shen.walk (V1775 V1776) (cond ((cons? V1776) (V1775 (map (lambda Z (shen.walk V1775 Z)) V1776))) (true (V1775 V1776))))
67
+ (defun shen.walk (V1818 V1819) (cond ((cons? V1819) (V1818 (map (lambda Z (shen.walk V1818 Z)) V1819))) (true (V1818 V1819))))
68
68
 
69
- (defun compile (V1777 V1778 V1779) (let O (V1777 (cons V1778 (cons () ()))) (if (or (= (fail) O) (not (empty? (hd O)))) (V1779 O) (shen.hdtl O))))
69
+ (defun compile (V1820 V1821 V1822) (let O (V1820 (cons V1821 (cons () ()))) (if (or (= (fail) O) (not (empty? (hd O)))) (V1822 O) (shen.hdtl O))))
70
70
 
71
- (defun fail-if (V1780 V1781) (if (V1780 V1781) (fail) V1781))
71
+ (defun fail-if (V1823 V1824) (if (V1823 V1824) (fail) V1824))
72
72
 
73
- (defun @s (V1782 V1783) (cn V1782 V1783))
73
+ (defun @s (V1825 V1826) (cn V1825 V1826))
74
74
 
75
- (defun tc? (V1788) (value shen.*tc*))
75
+ (defun tc? (V1831) (value shen.*tc*))
76
76
 
77
- (defun ps (V1789) (trap-error (get V1789 shen.source (value *property-vector*)) (lambda E (simple-error (shen.app V1789 " not found.
77
+ (defun ps (V1832) (trap-error (get V1832 shen.source (value *property-vector*)) (lambda E (simple-error (shen.app V1832 " not found.
78
78
  " shen.a)))))
79
79
 
80
80
  (defun stinput () (value *stinput*))
81
81
 
82
- (defun shen.+vector? (V1790) (and (absvector? V1790) (> (<-address V1790 0) 0)))
82
+ (defun shen.+vector? (V1833) (and (absvector? V1833) (> (<-address V1833 0) 0)))
83
83
 
84
- (defun vector (V1791) (let Vector (absvector (+ V1791 1)) (let ZeroStamp (address-> Vector 0 V1791) (let Standard (if (= V1791 0) ZeroStamp (shen.fillvector ZeroStamp 1 V1791 (fail))) Standard))))
84
+ (defun vector (V1834) (let Vector (absvector (+ V1834 1)) (let ZeroStamp (address-> Vector 0 V1834) (let Standard (if (= V1834 0) ZeroStamp (shen.fillvector ZeroStamp 1 V1834 (fail))) Standard))))
85
85
 
86
- (defun shen.fillvector (V1792 V1793 V1794 V1795) (cond ((= V1794 V1793) (address-> V1792 V1794 V1795)) (true (shen.fillvector (address-> V1792 V1793 V1795) (+ 1 V1793) V1794 V1795))))
86
+ (defun shen.fillvector (V1835 V1836 V1837 V1838) (cond ((= V1837 V1836) (address-> V1835 V1837 V1838)) (true (shen.fillvector (address-> V1835 V1836 V1838) (+ 1 V1836) V1837 V1838))))
87
87
 
88
- (defun vector? (V1797) (and (absvector? V1797) (trap-error (>= (<-address V1797 0) 0) (lambda E false))))
88
+ (defun vector? (V1840) (and (absvector? V1840) (trap-error (>= (<-address V1840 0) 0) (lambda E false))))
89
89
 
90
- (defun vector-> (V1798 V1799 V1800) (if (= V1799 0) (simple-error "cannot access 0th element of a vector
91
- ") (address-> V1798 V1799 V1800)))
90
+ (defun vector-> (V1841 V1842 V1843) (if (= V1842 0) (simple-error "cannot access 0th element of a vector
91
+ ") (address-> V1841 V1842 V1843)))
92
92
 
93
- (defun <-vector (V1801 V1802) (if (= V1802 0) (simple-error "cannot access 0th element of a vector
94
- ") (let VectorElement (<-address V1801 V1802) (if (= VectorElement (fail)) (simple-error "vector element not found
93
+ (defun <-vector (V1844 V1845) (if (= V1845 0) (simple-error "cannot access 0th element of a vector
94
+ ") (let VectorElement (<-address V1844 V1845) (if (= VectorElement (fail)) (simple-error "vector element not found
95
95
  ") VectorElement))))
96
96
 
97
- (defun shen.posint? (V1803) (and (integer? V1803) (>= V1803 0)))
97
+ (defun shen.posint? (V1846) (and (integer? V1846) (>= V1846 0)))
98
98
 
99
- (defun limit (V1804) (<-address V1804 0))
99
+ (defun limit (V1847) (<-address V1847 0))
100
100
 
101
- (defun symbol? (V1805) (cond ((or (boolean? V1805) (or (number? V1805) (string? V1805))) false) (true (trap-error (let String (str V1805) (shen.analyse-symbol? String)) (lambda E false)))))
101
+ (defun symbol? (V1848) (cond ((or (boolean? V1848) (or (number? V1848) (string? V1848))) false) (true (trap-error (let String (str V1848) (shen.analyse-symbol? String)) (lambda E false)))))
102
102
 
103
- (defun shen.analyse-symbol? (V1806) (cond ((shen.+string? V1806) (and (shen.alpha? (pos V1806 0)) (shen.alphanums? (tlstr V1806)))) (true (shen.sys-error shen.analyse-symbol?))))
103
+ (defun shen.analyse-symbol? (V1849) (cond ((shen.+string? V1849) (and (shen.alpha? (pos V1849 0)) (shen.alphanums? (tlstr V1849)))) (true (shen.sys-error shen.analyse-symbol?))))
104
104
 
105
- (defun shen.alpha? (V1807) (element? V1807 (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 "." ())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
105
+ (defun shen.alpha? (V1850) (element? V1850 (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 "." ())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
106
106
 
107
- (defun shen.alphanums? (V1808) (cond ((= "" V1808) true) ((shen.+string? V1808) (and (shen.alphanum? (pos V1808 0)) (shen.alphanums? (tlstr V1808)))) (true (shen.sys-error shen.alphanums?))))
107
+ (defun shen.alphanums? (V1851) (cond ((= "" V1851) true) ((shen.+string? V1851) (and (shen.alphanum? (pos V1851 0)) (shen.alphanums? (tlstr V1851)))) (true (shen.sys-error shen.alphanums?))))
108
108
 
109
- (defun shen.alphanum? (V1809) (or (shen.alpha? V1809) (shen.digit? V1809)))
109
+ (defun shen.alphanum? (V1852) (or (shen.alpha? V1852) (shen.digit? V1852)))
110
110
 
111
- (defun shen.digit? (V1810) (element? V1810 (cons "1" (cons "2" (cons "3" (cons "4" (cons "5" (cons "6" (cons "7" (cons "8" (cons "9" (cons "0" ()))))))))))))
111
+ (defun shen.digit? (V1853) (element? V1853 (cons "1" (cons "2" (cons "3" (cons "4" (cons "5" (cons "6" (cons "7" (cons "8" (cons "9" (cons "0" ()))))))))))))
112
112
 
113
- (defun variable? (V1811) (cond ((or (boolean? V1811) (or (number? V1811) (string? V1811))) false) (true (trap-error (let String (str V1811) (shen.analyse-variable? String)) (lambda E false)))))
113
+ (defun variable? (V1854) (cond ((or (boolean? V1854) (or (number? V1854) (string? V1854))) false) (true (trap-error (let String (str V1854) (shen.analyse-variable? String)) (lambda E false)))))
114
114
 
115
- (defun shen.analyse-variable? (V1812) (cond ((shen.+string? V1812) (and (shen.uppercase? (pos V1812 0)) (shen.alphanums? (tlstr V1812)))) (true (shen.sys-error shen.analyse-variable?))))
115
+ (defun shen.analyse-variable? (V1855) (cond ((shen.+string? V1855) (and (shen.uppercase? (pos V1855 0)) (shen.alphanums? (tlstr V1855)))) (true (shen.sys-error shen.analyse-variable?))))
116
116
 
117
- (defun shen.uppercase? (V1813) (element? V1813 (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" ()))))))))))))))))))))))))))))
117
+ (defun shen.uppercase? (V1856) (element? V1856 (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" ()))))))))))))))))))))))))))))
118
118
 
119
- (defun gensym (V1814) (concat V1814 (set shen.*gensym* (+ 1 (value shen.*gensym*)))))
119
+ (defun gensym (V1857) (concat V1857 (set shen.*gensym* (+ 1 (value shen.*gensym*)))))
120
120
 
121
- (defun concat (V1815 V1816) (intern (cn (str V1815) (str V1816))))
121
+ (defun concat (V1858 V1859) (intern (cn (str V1858) (str V1859))))
122
122
 
123
- (defun @p (V1817 V1818) (let Vector (absvector 3) (let Tag (address-> Vector 0 shen.tuple) (let Fst (address-> Vector 1 V1817) (let Snd (address-> Vector 2 V1818) Vector)))))
123
+ (defun @p (V1860 V1861) (let Vector (absvector 3) (let Tag (address-> Vector 0 shen.tuple) (let Fst (address-> Vector 1 V1860) (let Snd (address-> Vector 2 V1861) Vector)))))
124
124
 
125
- (defun fst (V1819) (<-address V1819 1))
125
+ (defun fst (V1862) (<-address V1862 1))
126
126
 
127
- (defun snd (V1820) (<-address V1820 2))
127
+ (defun snd (V1863) (<-address V1863 2))
128
128
 
129
- (defun tuple? (V1821) (trap-error (and (absvector? V1821) (= shen.tuple (<-address V1821 0))) (lambda E false)))
129
+ (defun tuple? (V1864) (trap-error (and (absvector? V1864) (= shen.tuple (<-address V1864 0))) (lambda E false)))
130
130
 
131
- (defun append (V1822 V1823) (cond ((= () V1822) V1823) ((cons? V1822) (cons (hd V1822) (append (tl V1822) V1823))) (true (shen.sys-error append))))
131
+ (defun append (V1865 V1866) (cond ((= () V1865) V1866) ((cons? V1865) (cons (hd V1865) (append (tl V1865) V1866))) (true (shen.sys-error append))))
132
132
 
133
- (defun @v (V1824 V1825) (let Limit (limit V1825) (let NewVector (vector (+ Limit 1)) (let X+NewVector (vector-> NewVector 1 V1824) (if (= Limit 0) X+NewVector (shen.@v-help V1825 1 Limit X+NewVector))))))
133
+ (defun @v (V1867 V1868) (let Limit (limit V1868) (let NewVector (vector (+ Limit 1)) (let X+NewVector (vector-> NewVector 1 V1867) (if (= Limit 0) X+NewVector (shen.@v-help V1868 1 Limit X+NewVector))))))
134
134
 
135
- (defun shen.@v-help (V1826 V1827 V1828 V1829) (cond ((= V1828 V1827) (shen.copyfromvector V1826 V1829 V1828 (+ V1828 1))) (true (shen.@v-help V1826 (+ V1827 1) V1828 (shen.copyfromvector V1826 V1829 V1827 (+ V1827 1))))))
135
+ (defun shen.@v-help (V1869 V1870 V1871 V1872) (cond ((= V1871 V1870) (shen.copyfromvector V1869 V1872 V1871 (+ V1871 1))) (true (shen.@v-help V1869 (+ V1870 1) V1871 (shen.copyfromvector V1869 V1872 V1870 (+ V1870 1))))))
136
136
 
137
- (defun shen.copyfromvector (V1831 V1832 V1833 V1834) (trap-error (vector-> V1832 V1834 (<-vector V1831 V1833)) (lambda E V1832)))
137
+ (defun shen.copyfromvector (V1874 V1875 V1876 V1877) (trap-error (vector-> V1875 V1877 (<-vector V1874 V1876)) (lambda E V1875)))
138
138
 
139
- (defun hdv (V1835) (trap-error (<-vector V1835 1) (lambda E (simple-error (cn "hdv needs a non-empty vector as an argument; not " (shen.app V1835 "
139
+ (defun hdv (V1878) (trap-error (<-vector V1878 1) (lambda E (simple-error (cn "hdv needs a non-empty vector as an argument; not " (shen.app V1878 "
140
140
  " shen.s))))))
141
141
 
142
- (defun tlv (V1836) (let Limit (limit V1836) (if (= Limit 0) (simple-error "cannot take the tail of the empty vector
143
- ") (if (= Limit 1) (vector 0) (let NewVector (vector (- Limit 1)) (shen.tlv-help V1836 2 Limit (vector (- Limit 1))))))))
142
+ (defun tlv (V1879) (let Limit (limit V1879) (if (= Limit 0) (simple-error "cannot take the tail of the empty vector
143
+ ") (if (= Limit 1) (vector 0) (let NewVector (vector (- Limit 1)) (shen.tlv-help V1879 2 Limit (vector (- Limit 1))))))))
144
144
 
145
- (defun shen.tlv-help (V1837 V1838 V1839 V1840) (cond ((= V1839 V1838) (shen.copyfromvector V1837 V1840 V1839 (- V1839 1))) (true (shen.tlv-help V1837 (+ V1838 1) V1839 (shen.copyfromvector V1837 V1840 V1838 (- V1838 1))))))
145
+ (defun shen.tlv-help (V1880 V1881 V1882 V1883) (cond ((= V1882 V1881) (shen.copyfromvector V1880 V1883 V1882 (- V1882 1))) (true (shen.tlv-help V1880 (+ V1881 1) V1882 (shen.copyfromvector V1880 V1883 V1881 (- V1881 1))))))
146
146
 
147
- (defun assoc (V1850 V1851) (cond ((= () V1851) ()) ((and (cons? V1851) (and (cons? (hd V1851)) (= (hd (hd V1851)) V1850))) (hd V1851)) ((cons? V1851) (assoc V1850 (tl V1851))) (true (shen.sys-error assoc))))
147
+ (defun assoc (V1893 V1894) (cond ((= () V1894) ()) ((and (cons? V1894) (and (cons? (hd V1894)) (= (hd (hd V1894)) V1893))) (hd V1894)) ((cons? V1894) (assoc V1893 (tl V1894))) (true (shen.sys-error assoc))))
148
148
 
149
- (defun boolean? (V1857) (cond ((= true V1857) true) ((= false V1857) true) (true false)))
149
+ (defun boolean? (V1900) (cond ((= true V1900) true) ((= false V1900) true) (true false)))
150
150
 
151
- (defun nl (V1858) (cond ((= 0 V1858) 0) (true (do (pr "
152
- " (stoutput)) (nl (- V1858 1))))))
151
+ (defun nl (V1901) (cond ((= 0 V1901) 0) (true (do (shen.prhush "
152
+ " (stoutput)) (nl (- V1901 1))))))
153
153
 
154
- (defun difference (V1861 V1862) (cond ((= () V1861) ()) ((cons? V1861) (if (element? (hd V1861) V1862) (difference (tl V1861) V1862) (cons (hd V1861) (difference (tl V1861) V1862)))) (true (shen.sys-error difference))))
154
+ (defun difference (V1904 V1905) (cond ((= () V1904) ()) ((cons? V1904) (if (element? (hd V1904) V1905) (difference (tl V1904) V1905) (cons (hd V1904) (difference (tl V1904) V1905)))) (true (shen.sys-error difference))))
155
155
 
156
- (defun do (V1863 V1864) V1864)
156
+ (defun do (V1906 V1907) V1907)
157
157
 
158
- (defun element? (V1873 V1874) (cond ((= () V1874) false) ((and (cons? V1874) (= (hd V1874) V1873)) true) ((cons? V1874) (element? V1873 (tl V1874))) (true (shen.sys-error element?))))
158
+ (defun element? (V1916 V1917) (cond ((= () V1917) false) ((and (cons? V1917) (= (hd V1917) V1916)) true) ((cons? V1917) (element? V1916 (tl V1917))) (true (shen.sys-error element?))))
159
159
 
160
- (defun empty? (V1880) (cond ((= () V1880) true) (true false)))
160
+ (defun empty? (V1923) (cond ((= () V1923) true) (true false)))
161
161
 
162
- (defun fix (V1881 V1882) (shen.fix-help V1881 V1882 (V1881 V1882)))
162
+ (defun fix (V1924 V1925) (shen.fix-help V1924 V1925 (V1924 V1925)))
163
163
 
164
- (defun shen.fix-help (V1889 V1890 V1891) (cond ((= V1891 V1890) V1891) (true (shen.fix-help V1889 V1891 (V1889 V1891)))))
164
+ (defun shen.fix-help (V1932 V1933 V1934) (cond ((= V1934 V1933) V1934) (true (shen.fix-help V1932 V1934 (V1932 V1934)))))
165
165
 
166
- (defun put (V1893 V1894 V1895 V1896) (let N (hash V1893 (limit V1896)) (let Entry (trap-error (<-vector V1896 N) (lambda E ())) (let Change (vector-> V1896 N (shen.change-pointer-value V1893 V1894 V1895 Entry)) V1895))))
166
+ (defun put (V1936 V1937 V1938 V1939) (let N (hash V1936 (limit V1939)) (let Entry (trap-error (<-vector V1939 N) (lambda E ())) (let Change (vector-> V1939 N (shen.change-pointer-value V1936 V1937 V1938 Entry)) V1938))))
167
167
 
168
- (defun shen.change-pointer-value (V1899 V1900 V1901 V1902) (cond ((= () V1902) (cons (cons (cons V1899 (cons V1900 ())) V1901) ())) ((and (cons? V1902) (and (cons? (hd V1902)) (and (cons? (hd (hd V1902))) (and (cons? (tl (hd (hd V1902)))) (and (= () (tl (tl (hd (hd V1902))))) (and (= (hd (tl (hd (hd V1902)))) V1900) (= (hd (hd (hd V1902))) V1899))))))) (cons (cons (hd (hd V1902)) V1901) (tl V1902))) ((cons? V1902) (cons (hd V1902) (shen.change-pointer-value V1899 V1900 V1901 (tl V1902)))) (true (shen.sys-error shen.change-pointer-value))))
168
+ (defun shen.change-pointer-value (V1942 V1943 V1944 V1945) (cond ((= () V1945) (cons (cons (cons V1942 (cons V1943 ())) V1944) ())) ((and (cons? V1945) (and (cons? (hd V1945)) (and (cons? (hd (hd V1945))) (and (cons? (tl (hd (hd V1945)))) (and (= () (tl (tl (hd (hd V1945))))) (and (= (hd (tl (hd (hd V1945)))) V1943) (= (hd (hd (hd V1945))) V1942))))))) (cons (cons (hd (hd V1945)) V1944) (tl V1945))) ((cons? V1945) (cons (hd V1945) (shen.change-pointer-value V1942 V1943 V1944 (tl V1945)))) (true (shen.sys-error shen.change-pointer-value))))
169
169
 
170
- (defun get (V1905 V1906 V1907) (let N (hash V1905 (limit V1907)) (let Entry (trap-error (<-vector V1907 N) (lambda E (simple-error "pointer not found
171
- "))) (let Result (assoc (cons V1905 (cons V1906 ())) Entry) (if (empty? Result) (simple-error "value not found
170
+ (defun get (V1948 V1949 V1950) (let N (hash V1948 (limit V1950)) (let Entry (trap-error (<-vector V1950 N) (lambda E (simple-error "pointer not found
171
+ "))) (let Result (assoc (cons V1948 (cons V1949 ())) Entry) (if (empty? Result) (simple-error "value not found
172
172
  ") (tl Result))))))
173
173
 
174
- (defun hash (V1908 V1909) (let Hash (shen.mod (shen.sum (map (lambda V1758 (string->n V1758)) (explode V1908))) V1909) (if (= 0 Hash) 1 Hash)))
174
+ (defun hash (V1951 V1952) (let Hash (shen.mod (shen.sum (map (lambda V1801 (string->n V1801)) (explode V1951))) V1952) (if (= 0 Hash) 1 Hash)))
175
175
 
176
- (defun shen.mod (V1910 V1911) (shen.modh V1910 (shen.multiples V1910 (cons V1911 ()))))
176
+ (defun shen.mod (V1953 V1954) (shen.modh V1953 (shen.multiples V1953 (cons V1954 ()))))
177
177
 
178
- (defun shen.multiples (V1912 V1913) (cond ((and (cons? V1913) (> (hd V1913) V1912)) (tl V1913)) ((cons? V1913) (shen.multiples V1912 (cons (* 2 (hd V1913)) V1913))) (true (shen.sys-error shen.multiples))))
178
+ (defun shen.multiples (V1955 V1956) (cond ((and (cons? V1956) (> (hd V1956) V1955)) (tl V1956)) ((cons? V1956) (shen.multiples V1955 (cons (* 2 (hd V1956)) V1956))) (true (shen.sys-error shen.multiples))))
179
179
 
180
- (defun shen.modh (V1916 V1917) (cond ((= 0 V1916) 0) ((= () V1917) V1916) ((and (cons? V1917) (> (hd V1917) V1916)) (if (empty? (tl V1917)) V1916 (shen.modh V1916 (tl V1917)))) ((cons? V1917) (shen.modh (- V1916 (hd V1917)) V1917)) (true (shen.sys-error shen.modh))))
180
+ (defun shen.modh (V1959 V1960) (cond ((= 0 V1959) 0) ((= () V1960) V1959) ((and (cons? V1960) (> (hd V1960) V1959)) (if (empty? (tl V1960)) V1959 (shen.modh V1959 (tl V1960)))) ((cons? V1960) (shen.modh (- V1959 (hd V1960)) V1960)) (true (shen.sys-error shen.modh))))
181
181
 
182
- (defun shen.sum (V1918) (cond ((= () V1918) 0) ((cons? V1918) (+ (hd V1918) (shen.sum (tl V1918)))) (true (shen.sys-error shen.sum))))
182
+ (defun shen.sum (V1961) (cond ((= () V1961) 0) ((cons? V1961) (+ (hd V1961) (shen.sum (tl V1961)))) (true (shen.sys-error shen.sum))))
183
183
 
184
- (defun head (V1925) (cond ((cons? V1925) (hd V1925)) (true (simple-error "head expects a non-empty list"))))
184
+ (defun head (V1968) (cond ((cons? V1968) (hd V1968)) (true (simple-error "head expects a non-empty list"))))
185
185
 
186
- (defun tail (V1932) (cond ((cons? V1932) (tl V1932)) (true (simple-error "tail expects a non-empty list"))))
186
+ (defun tail (V1975) (cond ((cons? V1975) (tl V1975)) (true (simple-error "tail expects a non-empty list"))))
187
187
 
188
- (defun hdstr (V1933) (pos V1933 0))
188
+ (defun hdstr (V1976) (pos V1976 0))
189
189
 
190
- (defun intersection (V1936 V1937) (cond ((= () V1936) ()) ((cons? V1936) (if (element? (hd V1936) V1937) (cons (hd V1936) (intersection (tl V1936) V1937)) (intersection (tl V1936) V1937))) (true (shen.sys-error intersection))))
190
+ (defun intersection (V1979 V1980) (cond ((= () V1979) ()) ((cons? V1979) (if (element? (hd V1979) V1980) (cons (hd V1979) (intersection (tl V1979) V1980)) (intersection (tl V1979) V1980))) (true (shen.sys-error intersection))))
191
191
 
192
- (defun reverse (V1938) (shen.reverse_help V1938 ()))
192
+ (defun reverse (V1981) (shen.reverse_help V1981 ()))
193
193
 
194
- (defun shen.reverse_help (V1939 V1940) (cond ((= () V1939) V1940) ((cons? V1939) (shen.reverse_help (tl V1939) (cons (hd V1939) V1940))) (true (shen.sys-error shen.reverse_help))))
194
+ (defun shen.reverse_help (V1982 V1983) (cond ((= () V1982) V1983) ((cons? V1982) (shen.reverse_help (tl V1982) (cons (hd V1982) V1983))) (true (shen.sys-error shen.reverse_help))))
195
195
 
196
- (defun union (V1941 V1942) (cond ((= () V1941) V1942) ((cons? V1941) (if (element? (hd V1941) V1942) (union (tl V1941) V1942) (cons (hd V1941) (union (tl V1941) V1942)))) (true (shen.sys-error union))))
196
+ (defun union (V1984 V1985) (cond ((= () V1984) V1985) ((cons? V1984) (if (element? (hd V1984) V1985) (union (tl V1984) V1985) (cons (hd V1984) (union (tl V1984) V1985)))) (true (shen.sys-error union))))
197
197
 
198
- (defun y-or-n? (V1943) (let Message (pr (shen.proc-nl V1943) (stoutput)) (let Y-or-N (pr " (y/n) " (stoutput)) (let Input (shen.app (input) "" shen.s) (if (= "y" Input) true (if (= "n" Input) false (do (pr "please answer y or n
199
- " (stoutput)) (y-or-n? V1943))))))))
198
+ (defun y-or-n? (V1986) (let Message (shen.prhush (shen.proc-nl V1986) (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
199
+ " (stoutput)) (y-or-n? V1986))))))))
200
200
 
201
- (defun not (V1944) (if V1944 false true))
201
+ (defun not (V1987) (if V1987 false true))
202
202
 
203
- (defun subst (V1953 V1954 V1955) (cond ((= V1955 V1954) V1953) ((cons? V1955) (cons (subst V1953 V1954 (hd V1955)) (subst V1953 V1954 (tl V1955)))) (true V1955)))
203
+ (defun subst (V1996 V1997 V1998) (cond ((= V1998 V1997) V1996) ((cons? V1998) (cons (subst V1996 V1997 (hd V1998)) (subst V1996 V1997 (tl V1998)))) (true V1998)))
204
204
 
205
- (defun explode (V1957) (shen.explode-h (shen.app V1957 "" shen.a)))
205
+ (defun explode (V2000) (shen.explode-h (shen.app V2000 "" shen.a)))
206
206
 
207
- (defun shen.explode-h (V1958) (cond ((= "" V1958) ()) ((shen.+string? V1958) (cons (pos V1958 0) (shen.explode-h (tlstr V1958)))) (true (shen.sys-error shen.explode-h))))
207
+ (defun shen.explode-h (V2001) (cond ((= "" V2001) ()) ((shen.+string? V2001) (cons (pos V2001 0) (shen.explode-h (tlstr V2001)))) (true (shen.sys-error shen.explode-h))))
208
208
 
209
- (defun cd (V1959) (set *home-directory* (if (= V1959 "") "" (shen.app V1959 "/" shen.a))))
209
+ (defun cd (V2002) (set *home-directory* (if (= V2002 "") "" (shen.app V2002 "/" shen.a))))
210
210
 
211
- (defun map (V1960 V1961) (shen.map-h V1960 V1961 ()))
211
+ (defun map (V2003 V2004) (shen.map-h V2003 V2004 ()))
212
212
 
213
- (defun shen.map-h (V1964 V1965 V1966) (cond ((= () V1965) (reverse V1966)) ((cons? V1965) (shen.map-h V1964 (tl V1965) (cons (V1964 (hd V1965)) V1966))) (true (shen.sys-error shen.map-h))))
213
+ (defun shen.map-h (V2007 V2008 V2009) (cond ((= () V2008) (reverse V2009)) ((cons? V2008) (shen.map-h V2007 (tl V2008) (cons (V2007 (hd V2008)) V2009))) (true (shen.sys-error shen.map-h))))
214
214
 
215
- (defun length (V1967) (shen.length-h V1967 0))
215
+ (defun length (V2010) (shen.length-h V2010 0))
216
216
 
217
- (defun shen.length-h (V1968 V1969) (cond ((= () V1968) V1969) (true (shen.length-h (tl V1968) (+ V1969 1)))))
217
+ (defun shen.length-h (V2011 V2012) (cond ((= () V2011) V2012) (true (shen.length-h (tl V2011) (+ V2012 1)))))
218
218
 
219
- (defun occurrences (V1978 V1979) (cond ((= V1979 V1978) 1) ((cons? V1979) (+ (occurrences V1978 (hd V1979)) (occurrences V1978 (tl V1979)))) (true 0)))
219
+ (defun occurrences (V2021 V2022) (cond ((= V2022 V2021) 1) ((cons? V2022) (+ (occurrences V2021 (hd V2022)) (occurrences V2021 (tl V2022)))) (true 0)))
220
220
 
221
- (defun nth (V1987 V1988) (cond ((and (= 1 V1987) (cons? V1988)) (hd V1988)) ((cons? V1988) (nth (- V1987 1) (tl V1988))) (true (shen.sys-error nth))))
221
+ (defun nth (V2030 V2031) (cond ((and (= 1 V2030) (cons? V2031)) (hd V2031)) ((cons? V2031) (nth (- V2030 1) (tl V2031))) (true (shen.sys-error nth))))
222
222
 
223
- (defun integer? (V1989) (and (number? V1989) (let Abs (shen.abs V1989) (shen.integer-test? Abs (shen.magless Abs 1)))))
223
+ (defun integer? (V2032) (and (number? V2032) (let Abs (shen.abs V2032) (shen.integer-test? Abs (shen.magless Abs 1)))))
224
224
 
225
- (defun shen.abs (V1990) (if (> V1990 0) V1990 (- 0 V1990)))
225
+ (defun shen.abs (V2033) (if (> V2033 0) V2033 (- 0 V2033)))
226
226
 
227
- (defun shen.magless (V1991 V1992) (let Nx2 (* V1992 2) (if (> Nx2 V1991) V1992 (shen.magless V1991 Nx2))))
227
+ (defun shen.magless (V2034 V2035) (let Nx2 (* V2035 2) (if (> Nx2 V2034) V2035 (shen.magless V2034 Nx2))))
228
228
 
229
- (defun shen.integer-test? (V1996 V1997) (cond ((= 0 V1996) true) ((> 1 V1996) false) (true (let Abs-N (- V1996 V1997) (if (> 0 Abs-N) (integer? V1996) (shen.integer-test? Abs-N V1997))))))
229
+ (defun shen.integer-test? (V2039 V2040) (cond ((= 0 V2039) true) ((> 1 V2039) false) (true (let Abs-N (- V2039 V2040) (if (> 0 Abs-N) (integer? V2039) (shen.integer-test? Abs-N V2040))))))
230
230
 
231
- (defun mapcan (V2000 V2001) (cond ((= () V2001) ()) ((cons? V2001) (append (V2000 (hd V2001)) (mapcan V2000 (tl V2001)))) (true (shen.sys-error mapcan))))
231
+ (defun mapcan (V2043 V2044) (cond ((= () V2044) ()) ((cons? V2044) (append (V2043 (hd V2044)) (mapcan V2043 (tl V2044)))) (true (shen.sys-error mapcan))))
232
232
 
233
- (defun read-file-as-bytelist (V2002) (let Stream (open file V2002 in) (let Byte (read-byte Stream) (let Bytes (shen.read-file-as-bytelist-help Stream Byte ()) (let Close (close Stream) (reverse Bytes))))))
233
+ (defun read-file-as-bytelist (V2045) (let Stream (open file V2045 in) (let Byte (read-byte Stream) (let Bytes (shen.read-file-as-bytelist-help Stream Byte ()) (let Close (close Stream) (reverse Bytes))))))
234
234
 
235
- (defun shen.read-file-as-bytelist-help (V2003 V2004 V2005) (cond ((= -1 V2004) V2005) (true (shen.read-file-as-bytelist-help V2003 (read-byte V2003) (cons V2004 V2005)))))
235
+ (defun shen.read-file-as-bytelist-help (V2046 V2047 V2048) (cond ((= -1 V2047) V2048) (true (shen.read-file-as-bytelist-help V2046 (read-byte V2046) (cons V2047 V2048)))))
236
236
 
237
- (defun read-file-as-string (V2006) (let Stream (open file V2006 in) (shen.rfas-h Stream (read-byte Stream) "")))
237
+ (defun read-file-as-string (V2049) (let Stream (open file V2049 in) (shen.rfas-h Stream (read-byte Stream) "")))
238
238
 
239
- (defun shen.rfas-h (V2007 V2008 V2009) (cond ((= -1 V2008) (do (close V2007) V2009)) (true (shen.rfas-h V2007 (read-byte V2007) (cn V2009 (n->string V2008))))))
239
+ (defun shen.rfas-h (V2050 V2051 V2052) (cond ((= -1 V2051) (do (close V2050) V2052)) (true (shen.rfas-h V2050 (read-byte V2050) (cn V2052 (n->string V2051))))))
240
240
 
241
- (defun == (V2018 V2019) (cond ((= V2019 V2018) true) (true false)))
241
+ (defun == (V2061 V2062) (cond ((= V2062 V2061) true) (true false)))
242
242
 
243
243
  (defun abort () (simple-error ""))
244
244
 
@@ -246,21 +246,26 @@
246
246
 
247
247
  (defun input () (eval (read)))
248
248
 
249
- (defun input+ (V2025 V2026) (let Input (read) (let Check (shen.typecheck Input V2026) (if (= false Check) (do (pr (cn "input is not of type " (shen.app V2026 ": please re-enter " shen.r)) (stoutput)) (input+ : V2026)) (eval Input)))))
249
+ (defun input+ (V2068 V2069) (let Input (read) (let Check (shen.typecheck Input V2069) (if (= false Check) (do (shen.prhush (cn "input is not of type " (shen.app V2069 ": please re-enter " shen.r)) (stoutput)) (input+ : V2069)) (eval Input)))))
250
250
 
251
- (defun bound? (V2027) (and (symbol? V2027) (let Val (trap-error (value V2027) (lambda E shen.this-symbol-is-unbound)) (if (= Val shen.this-symbol-is-unbound) false true))))
251
+ (defun read+ (V2074 V2075) (let Input (read) (let Check (shen.typecheck (shen.rcons_form Input) V2075) (if (= false Check) (do (shen.prhush (cn "input is not of type " (shen.app V2075 ": please re-enter " shen.r)) (stoutput)) (read+ : V2075)) Input))))
252
252
 
253
- (defun shen.string->bytes (V2028) (cond ((= "" V2028) ()) (true (cons (string->n (pos V2028 0)) (shen.string->bytes (tlstr V2028))))))
253
+ (defun bound? (V2076) (and (symbol? V2076) (let Val (trap-error (value V2076) (lambda E shen.this-symbol-is-unbound)) (if (= Val shen.this-symbol-is-unbound) false true))))
254
254
 
255
- (defun maxinferences (V2029) (set shen.*maxinferences* V2029))
255
+ (defun shen.string->bytes (V2077) (cond ((= "" V2077) ()) (true (cons (string->n (pos V2077 0)) (shen.string->bytes (tlstr V2077))))))
256
+
257
+ (defun maxinferences (V2078) (set shen.*maxinferences* V2078))
256
258
 
257
259
  (defun inferences () (value shen.*infs*))
258
260
 
259
- (defun protect (V2030) V2030)
261
+ (defun protect (V2079) V2079)
260
262
 
261
263
  (defun stoutput () (value *stoutput*))
262
264
 
263
- (defun string->symbol (V2031) (let Symbol (intern V2031) (if (symbol? Symbol) Symbol (simple-error (cn "cannot intern " (shen.app V2031 " to a symbol" shen.s))))))
265
+ (defun string->symbol (V2080) (let Symbol (intern V2080) (if (symbol? Symbol) Symbol (simple-error (cn "cannot intern " (shen.app V2080 " to a symbol" shen.s))))))
266
+
267
+ (defun shen.optimise (V2085) (cond ((= + V2085) (set shen.*optimise* true)) ((= - V2085) (set shen.*optimise* false)) (true (simple-error "optimise expects a + or a -.
268
+ "))))
264
269
 
265
270
 
266
271