shen-ruby 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 223aeb7a04b4a6b3edf327821e84ee5db52768e3
-  data.tar.gz: 526e3feee2e48f50879d1d81c42b33c76cb9a8bf
+  metadata.gz: 4388a5a344cbc54d04a341a42a341cf05aae8ebc
+  data.tar.gz: 2777d3e71e1f2f90a953487007f4c6b4fdcaf97a
 SHA512:
-  metadata.gz: ef6c2bfa79b0b51ecc78ca90d8130a1b2dd93de958d7d20445bf17c8ca9d23d355bfe37b4c718d9506c461e6f781314a97ca4744e76507653d20ac1845455d81
-  data.tar.gz: 179ad578053aaddb675bacdf305501845b84ebe123ba4d33b70def82df598f157daae862d87ca59b3f78b90ef670bd35c08e9e673594a88fa34fac76fd4e4245
+  metadata.gz: 1655075e45839d973a8a5bc310cc7a8399ac155960261e968785932a1cb733082a15d084dd3ea669cfe28fbc64ec19b6af54c59e46542fef0b99489290a8491f
+  data.tar.gz: be259a2837137dd278a3d8c6a9912df4051ed953a82805b5b138b72e1c7e7cd1e4dea991f0655ca63793ae68532025371a65ee67cdca8e276e8a551729b078b3

data/HISTORY.md

@@ -1,5 +1,9 @@
 # ShenRuby Release History
 
+## 0.10.0 - September 19, 2014
+### Features
+- Upgrade to Shen 16
+
 ## 0.9.0 - February 11, 2014
 ### Features
 - Upgrade to Shen 15

data/README.md

@@ -1,9 +1,9 @@
 # ShenRuby
 ShenRuby is a Ruby port of the [Shen](http://shenlanguage.org/) programming language. Shen is a modern, functional Lisp that supports pattern matching, currying, and optional static type checking.
 
-ShenRuby supports Shen version 15, which was released in February, 2014.
+ShenRuby supports Shen version 16, which was released in September, 2014.
 
-The ShenRuby project has two primary goals. The first is to be a low barrier-to-entry means for Rubyists to explore Shen. To someone with a working installation of Ruby 1.9.3, a Shen REPL is only a gem install away.
+The ShenRuby project has two primary goals. The first is to be a low barrier-to-entry means for Rubyists to explore Shen. To someone with a working installation of Ruby 1.9.3 or greater, a Shen REPL is only a gem install away.
 
 Second, ShenRuby aims to enable hybrid applications implemented using a combination of Ruby and Shen. Ruby methods should be able to invoke functions written in Shen and vice versa. Performance is a secondary part of this goal. It should be good enough that, for most tasks, the choice between Ruby and Shen is based primarily on which language is best suited for solving the problem at hand.
 
@@ -14,7 +14,7 @@ ShenRuby 0.1.0 began to satisfy the first goal by providing a Shen REPL accessib
 ## Installation
 NOTE: ShenRuby requires Ruby 1.9 language features. It has been tested with Ruby 1.9.3 and Ruby 2.0.0. It has been lightly tested with JRuby 1.7.8.
 
-ShenRuby 0.9.0 is the current release. To install it as a gem, use the following command:
+ShenRuby 0.10.0 is the current release. To install it as a gem, use the following command:
 
     gem install shen-ruby
 
@@ -23,18 +23,18 @@ ShenRuby 0.9.0 is the current release. To install it as a gem, use the following
 Once the gem has been installed, the Shen REPL can be launched via the `srrepl` (short for ShenRuby REPL) command. For example:
 
     % srrepl
-    Loading.... Completed in 6.32 seconds.
+    Loading.... Completed in 7.04 seconds.
 
     Shen 2010, copyright (C) 2010 Mark Tarver
     released under the Shen license
-    www.shenlanguage.org, version 15
+    www.shenlanguage.org, version 16
     running under Ruby, implementation: ruby 2.0.0
-    port 0.9.0 ported by Greg Spurrier
+    port 0.10.0 ported by Greg Spurrier
 
 
     (0-)
 
-Please be patient: the Shen REPL takes a while to load (about 6 seconds on a 2.66 GHz MacBook Pro). This will be addressed in future releases.
+Please be patient: the Shen REPL takes a while to load (about 7 seconds on a 2.66 GHz MacBook Pro). This will be addressed in future releases.
 
 The `(0-)` seen above is the Shen REPL prompt. The number in the prompt increases after each expression that is entered.
 
@@ -140,7 +140,7 @@ The following resources may be helpful for those wanting to learn more about the
 - [Learn Shen](http://www.shenlanguage.org/learn-shen/index.html) -- The Shen Website's suggested resources for--and approaches to--learning Shen, including the [Shen in 15 Minutes](http://www.shenlanguage.org/learn-shen/tutorials/shen_in_15mins.html) tutorial for experienced functional programmers.
 - [The Shen Official Standard](http://www.shenlanguage.org/Documentation/shendoc.htm)
 - [System Functions and their Types in Shen](http://www.shenlanguage.org/learn-shen/system.pdf) -- A reference for all of the standard Shen functions and their types.
-- [The Book of Shen](http://www.fast-print.net/bookshop/1278/the-book-of-shen) -- The official guide to the Shen programming language.
+- [The Book of Shen (Second Edition)](http://www.fast-print.net/bookshop/1506/the-book-of-shen-second-edition) -- The official guide to the Shen programming language.
 - [Shen Google Group](https://groups.google.com/group/qilang?hl=en) -- This is the online forum for discussions related to Shen.
 
 ## Road Map to 1.0

data/lib/shen_ruby/version.rb

@@ -1,3 +1,3 @@
 module ShenRuby
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

data/shen-ruby.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.email       = ["greg@sourcematters.org"]
   s.homepage    = "https://github.com/gregspurrier/shen-ruby"
   s.summary     = %q{ShenRuby is a Ruby port of the Shen programming language}
-  s.description = %q{ShenRuby is a port of the Shen programming language to Ruby. It currently supports Shen version 15.}
+  s.description = %q{ShenRuby is a port of the Shen programming language to Ruby. It currently supports Shen version 16.}
 
   s.required_ruby_version     = ">= 1.9.3"
 

data/shen/release/benchmarks/jnk.shen

@@ -0,0 +1,194 @@
+(define kl-to-lisp
+   Params Param -> Param    where (element? Param Params)
+   Params [type X _] -> (kl-to-lisp Params X)
+   Params [lambda X Y] -> [FUNCTION [LAMBDA [X] (kl-to-lisp [X | Params] Y)]] 
+   Params [let X Y Z] -> [LET [[X (kl-to-lisp Params Y)]] 
+                                 (kl-to-lisp [X | Params] Z)]
+   _ [defun F Params Code] -> [DEFUN F Params (kl-to-lisp Params Code)]
+   Params [cond | Cond] -> [COND | (map (/. C (cond_code Params C)) (insert-default Cond))]  
+   Params [Param | X] -> (higher-order-code Param
+                                (map (/. Y (kl-to-lisp Params Y)) X))
+                                        where (element? Param Params)
+   Params [[X | Y] | Z] -> (higher-order-code (kl-to-lisp Params [X | Y])
+                                               (map (/. W (kl-to-lisp Params W)) Z))   
+   Params [F | X] -> (assemble-application F 
+                                     (map (/. Y (kl-to-lisp Params Y)) X))
+                                 where (symbol? F)
+   _ [] -> []                              
+   _ S -> [QUOTE S]  where (or (symbol? S) (boolean? S))
+   _ X -> X)
+
+(define insert-default
+  [] -> [[true [ERROR "error: cond failure~%"]]]
+  [[true X] | Y] -> [[true X] | Y] 
+  [Case | Cases] -> [Case | (insert-default Cases)])    
+   
+(define higher-order-code 
+   F X -> [let Args [LIST | X]
+            [let NewF [maplispsym F]
+               [trap-error [APPLY NewF Args] 
+                           [lambda E [COND [[arity-error? F Args] 
+                                            [funcall [EVAL [nest-lambda F NewF]] Args]]
+                                           [[EQ NewF [QUOTE or]]
+                                            [funcall [lambda X1 [lambda X2 [or X1 X2]]] Args]]
+                                           [[EQ NewF [QUOTE and]]
+                                            [funcall [lambda X1 [lambda X2 [and X1 X2]]] Args]]
+                                           [[EQ NewF [QUOTE trap-error]]
+                                            [funcall [lambda X1 [lambda X2 [trap-error X1 X2]]] Args]]
+                                           [[bad-lambda-call? NewF Args] 
+                                            [funcall NewF Args]]
+                                           [T [relay-error E]]]]]]])
+                                           
+(define bad-lambda-call?
+  F Args -> (AND (FUNCTIONP F) (NOT (= (LIST-LENGTH Args) 1))))
+                                         
+(define relay-error
+  E -> (ERROR (error-to-string E)))
+                                         
+(define funcall
+  Lambda [] -> Lambda
+  Lambda [X | Y] -> (funcall (FUNCALL Lambda X) Y))   
+  
+(define arity-error?
+   F Args -> (AND (SYMBOLP F)
+                  (> (trap-error (arity F) (/. E -1)) (LIST-LENGTH Args)))       
+   
+(define nest-lambda
+   F NewF -> (nest-lambda-help NewF (trap-error (arity F) (/. E -1))))
+   
+(define nest-lambda-help
+  F -1 -> F
+  F 0 -> F
+  F N -> (let X (gensym (protect Y))
+                 [lambda X (nest-lambda-help (add-p F X) (- N 1))]))
+  
+(define add-p
+  [F | X] Y -> (append [F | X] [Y])
+  F X -> [F X])           
+ 
+(define cond_code
+   Params [Test Result] -> [(lisp_test Params Test) 
+                             (kl-to-lisp Params Result)])
+                             
+(define lisp_test
+   _ true -> T
+   Params [and | Tests] -> [AND | (map (/. X (wrap (kl-to-lisp Params X))) Tests)]
+   Params Test -> (wrap (kl-to-lisp Params Test))) 
+   
+ (define wrap 
+    [cons? X] -> [CONSP X]
+    [string? X] -> [STRINGP X]
+    [number? X] -> [NUMBERP X]
+    [empty? X] -> [NULL X]
+    [and P Q] -> [AND (wrap P) (wrap Q)]
+    [or P Q] -> [OR (wrap P) (wrap Q)] 
+    [not P] -> [NOT (wrap P)] 
+    [equal? X []] -> [NULL X]
+    [equal? [] X] -> [NULL X]
+    [equal? X [Quote Y]] -> [EQ X [Quote Y]]    
+                              where (and (= (SYMBOLP Y) T) (= Quote QUOTE))
+    [equal? [Quote Y] X] -> [EQ [Quote Y] X]    
+                                where (and (= (SYMBOLP Y) T) (= Quote QUOTE)) 
+    [equal? [fail] X] -> [EQ [fail] X]
+    [equal? X [fail]] -> [EQ X [fail]]
+    [equal? S X] -> [EQUAL S X]  where (string? S)
+    [equal? X S] -> [EQUAL X S]  where (string? S)
+    [equal? X Y] -> [shen-ABSEQUAL X Y]
+    [shen-+string? [tlstr X]] -> [NOT [STRING-EQUAL [tlstr X] ""]]
+    [shen-pvar? X] -> [AND [ARRAYP X] [NOT [STRINGP X]] [EQ [AREF X 0] [QUOTE shen-pvar]]] 
+    [tuple? X] -> [AND [ARRAYP X] [NOT [STRINGP X]] [EQ [AREF X 0] [QUOTE shen-tuple]]]
+    [greater? X Y] -> [> X Y]
+    [greater-than-or-equal-to? X Y] -> [>= X Y]
+    [less? X Y] -> [< X Y]
+    [less-than-or-equal-to? X Y] -> [<= X Y]
+    X -> [wrapper X])
+
+ (define wrapper
+   true -> T
+   false -> []
+   X -> (error "boolean expected: not ~S~%" X)) 
+   
+ (define assemble-application
+   hd [X] -> (protect [CAR X])
+   tl [X] -> (protect [CDR X])
+   cons [X Y] -> (protect [CONS X Y])
+   append [X Y] -> (protect [APPEND X Y])
+   reverse [X] -> (protect [REVERSE X])
+   if [P Q R] -> (protect [IF (wrap P) Q R])
+   + [1 X] -> [1+ X]
+   + [X 1] -> [1+ X]
+   - [X 1] -> [1- X]
+   value [[Quote X]] -> X  where (= Quote (protect QUOTE))
+   set [[Quote X] [1+ X]] -> [INCF X]  where (= Quote (protect QUOTE))
+   set [[Quote X] [1- X]] -> [DECF X]  where (= Quote (protect QUOTE))
+   F X -> (let NewF (maplispsym F)
+               Arity (trap-error (arity F) (/. E -1))
+               (if (or (= Arity (length X)) (= Arity -1))
+                   [NewF | X]
+                   [funcall (nest-lambda F NewF) [(protect LIST) | X]])))
+                   
+(define maplispsym  
+    = -> equal?
+    > -> greater?
+    < -> less?
+    >= -> greater-than-or-equal-to?
+    <= -> less-than-or-equal-to?
+    + -> add
+    - -> subtract
+    / -> divide
+    * -> multiply
+    F -> F)
+    
+ (define factorh
+  [Defun F Params [Cond | Code]] -> [Defun F Params [BLOCK [] (process-tree (tree (map returns Code)))]]
+                                       where (and (= Cond COND) (= Defun DEFUN))
+  Code -> Code)
+  
+(define returns
+  [Test Result] -> [Test [RETURN Result]]) 
+    
+(define process-tree
+   (@p P Q R no-tag) -> [IF P (optimise-selectors P (process-tree Q)) (process-tree R)]
+   (@p P Q R Tag) -> [TAGBODY [IF P (optimise-selectors P (process-tree Q))] Tag (process-tree R)]
+   Q -> Q    where (not (tuple? Q))) 
+   
+(define optimise-selectors 
+  Test Code -> (optimise-selectors-help (selectors-from Test) Code))                       
+
+(define selectors-from
+  [Consp X] -> [[CAR X] [CDR X]]    where (= Consp CONSP)
+  [tuple? X] -> [[fst X] [snd X]]  
+  _ -> [])    
+  
+(define optimise-selectors-help 
+   [] Code -> Code
+   [S1 S2] Code -> (let O1 (occurrences S1 Code)  
+                        O2 (occurrences S2 Code) 
+                        V1 (gensym V)
+                        V2 (gensym V)
+                        (if (and (> O1 1) (> O2 1))
+                            [LET [[V1 S1] [V2 S2]]  
+                                 (subst V1 S1 (subst V2 S2 Code))]
+                            (if (> O1 1)
+                                 [LET [[V1 S1]] (subst V1 S1 Code)] 
+                                 (if (> O2 1)
+                                      [LET [[V2 S2]] (subst V2 S2 Code)]
+                                      Code)))))        
+
+(define tree
+  [[[And P Q] R] | S] ->  (let Tag (gensym tag)
+                                Left (tree (append (branch-by P [[[And P Q] R] | S]) [[T [GO Tag]]]))
+                                Right (tree (branch-by-not P [[[And P Q] R] | S]))                                
+                                (@p P Left Right Tag))     where (= And AND)                 
+  [[True Q] | _] -> Q     where (= True T)                         
+  [[P Q] | R] -> (@p P Q (tree R) no-tag))
+  
+(define branch-by
+  P [[[And P Q] R] | S] -> [[Q R] | (branch-by P S)]   where (= And AND)
+  P [[P R] | S] -> [[T R]]
+  _ Code -> [])
+  
+(define branch-by-not
+  P [[[And P Q] R] | S] -> (branch-by-not P S)  where (= And AND)
+  P [[P R] | S] -> S
+  _ Code -> Code)   

data/shen/release/k_lambda/declarations.kl

@@ -109,19 +109,19 @@
 
 (set shen.*optimise* false)
 
-(set *version* "version 15")
+(set *version* "version 16")
 
 (defun shen.initialise_arity_table (V827) (cond ((= () V827) ()) ((and (cons? V827) (cons? (tl V827))) (let DecArity (put (hd V827) arity (hd (tl V827)) (value *property-vector*)) (shen.initialise_arity_table (tl (tl V827))))) (true (shen.sys-error shen.initialise_arity_table))))
 
 (defun arity (V828) (trap-error (get V828 arity (value *property-vector*)) (lambda E -1)))
 
-(shen.initialise_arity_table (cons absvector (cons 1 (cons adjoin (cons 2 (cons and (cons 2 (cons append (cons 2 (cons arity (cons 1 (cons assoc (cons 2 (cons boolean? (cons 1 (cons cd (cons 1 (cons compile (cons 3 (cons concat (cons 2 (cons cons (cons 2 (cons cons? (cons 1 (cons cn (cons 2 (cons declare (cons 2 (cons destroy (cons 1 (cons difference (cons 2 (cons do (cons 2 (cons element? (cons 2 (cons empty? (cons 1 (cons enable-type-theory (cons 1 (cons interror (cons 2 (cons eval (cons 1 (cons eval-kl (cons 1 (cons explode (cons 1 (cons external (cons 1 (cons fail-if (cons 2 (cons fail (cons 0 (cons fix (cons 2 (cons findall (cons 5 (cons freeze (cons 1 (cons fst (cons 1 (cons gensym (cons 1 (cons get (cons 3 (cons get-time (cons 1 (cons address-> (cons 3 (cons <-address (cons 2 (cons <-vector (cons 2 (cons > (cons 2 (cons >= (cons 2 (cons = (cons 2 (cons hd (cons 1 (cons hdv (cons 1 (cons hdstr (cons 1 (cons head (cons 1 (cons if (cons 3 (cons integer? (cons 1 (cons intern (cons 1 (cons identical (cons 4 (cons inferences (cons 0 (cons input (cons 1 (cons input+ (cons 2 (cons implementation (cons 0 (cons intersection (cons 2 (cons kill (cons 0 (cons language (cons 0 (cons length (cons 1 (cons lineread (cons 1 (cons load (cons 1 (cons < (cons 2 (cons <= (cons 2 (cons vector (cons 1 (cons macroexpand (cons 1 (cons map (cons 2 (cons mapcan (cons 2 (cons maxinferences (cons 1 (cons not (cons 1 (cons nth (cons 2 (cons n->string (cons 1 (cons number? (cons 1 (cons occurs-check (cons 1 (cons occurrences (cons 2 (cons occurs-check (cons 1 (cons optimise (cons 1 (cons or (cons 2 (cons os (cons 0 (cons package (cons 3 (cons port (cons 0 (cons porters (cons 0 (cons pos (cons 2 (cons print (cons 1 (cons profile (cons 1 (cons profile-results (cons 1 (cons pr (cons 2 (cons ps (cons 1 (cons preclude (cons 1 (cons preclude-all-but (cons 1 (cons protect (cons 1 (cons address-> (cons 3 (cons put (cons 4 (cons shen.reassemble (cons 2 (cons read-file-as-string (cons 1 (cons read-file (cons 1 (cons read (cons 1 (cons read-byte (cons 1 (cons read-from-string (cons 1 (cons release (cons 0 (cons remove (cons 2 (cons reverse (cons 1 (cons set (cons 2 (cons simple-error (cons 1 (cons snd (cons 1 (cons specialise (cons 1 (cons spy (cons 1 (cons step (cons 1 (cons stinput (cons 0 (cons stoutput (cons 0 (cons string->n (cons 1 (cons string->symbol (cons 1 (cons string? (cons 1 (cons shen.strong-warning (cons 1 (cons subst (cons 3 (cons sum (cons 1 (cons symbol? (cons 1 (cons tail (cons 1 (cons tl (cons 1 (cons tc (cons 1 (cons tc? (cons 0 (cons thaw (cons 1 (cons tlstr (cons 1 (cons track (cons 1 (cons trap-error (cons 2 (cons tuple? (cons 1 (cons type (cons 1 (cons return (cons 3 (cons undefmacro (cons 1 (cons unprofile (cons 1 (cons unify (cons 4 (cons unify! (cons 4 (cons union (cons 2 (cons untrack (cons 1 (cons unspecialise (cons 1 (cons undefmacro (cons 1 (cons vector (cons 1 (cons vector-> (cons 3 (cons value (cons 1 (cons variable? (cons 1 (cons version (cons 0 (cons warn (cons 1 (cons write-byte (cons 2 (cons write-to-file (cons 2 (cons y-or-n? (cons 1 (cons + (cons 2 (cons * (cons 2 (cons / (cons 2 (cons - (cons 2 (cons == (cons 2 (cons <e> (cons 1 (cons @p (cons 2 (cons @v (cons 2 (cons @s (cons 2 (cons preclude (cons 1 (cons include (cons 1 (cons preclude-all-but (cons 1 (cons include-all-but (cons 1 (cons where (cons 2 ())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(shen.initialise_arity_table (cons absvector (cons 1 (cons adjoin (cons 2 (cons and (cons 2 (cons append (cons 2 (cons arity (cons 1 (cons assoc (cons 2 (cons boolean? (cons 1 (cons cd (cons 1 (cons compile (cons 3 (cons concat (cons 2 (cons cons (cons 2 (cons cons? (cons 1 (cons cn (cons 2 (cons declare (cons 2 (cons destroy (cons 1 (cons difference (cons 2 (cons do (cons 2 (cons element? (cons 2 (cons empty? (cons 1 (cons enable-type-theory (cons 1 (cons interror (cons 2 (cons eval (cons 1 (cons eval-kl (cons 1 (cons explode (cons 1 (cons external (cons 1 (cons fail-if (cons 2 (cons fail (cons 0 (cons fix (cons 2 (cons findall (cons 5 (cons freeze (cons 1 (cons fst (cons 1 (cons gensym (cons 1 (cons get (cons 3 (cons get-time (cons 1 (cons address-> (cons 3 (cons <-address (cons 2 (cons <-vector (cons 2 (cons > (cons 2 (cons >= (cons 2 (cons = (cons 2 (cons hd (cons 1 (cons hdv (cons 1 (cons hdstr (cons 1 (cons head (cons 1 (cons if (cons 3 (cons integer? (cons 1 (cons intern (cons 1 (cons identical (cons 4 (cons inferences (cons 0 (cons input (cons 1 (cons input+ (cons 2 (cons implementation (cons 0 (cons intersection (cons 2 (cons it (cons 0 (cons kill (cons 0 (cons language (cons 0 (cons length (cons 1 (cons lineread (cons 1 (cons load (cons 1 (cons < (cons 2 (cons <= (cons 2 (cons vector (cons 1 (cons macroexpand (cons 1 (cons map (cons 2 (cons mapcan (cons 2 (cons maxinferences (cons 1 (cons not (cons 1 (cons nth (cons 2 (cons n->string (cons 1 (cons number? (cons 1 (cons occurs-check (cons 1 (cons occurrences (cons 2 (cons occurs-check (cons 1 (cons optimise (cons 1 (cons or (cons 2 (cons os (cons 0 (cons package (cons 3 (cons port (cons 0 (cons porters (cons 0 (cons pos (cons 2 (cons print (cons 1 (cons profile (cons 1 (cons profile-results (cons 1 (cons pr (cons 2 (cons ps (cons 1 (cons preclude (cons 1 (cons preclude-all-but (cons 1 (cons protect (cons 1 (cons address-> (cons 3 (cons put (cons 4 (cons shen.reassemble (cons 2 (cons read-file-as-string (cons 1 (cons read-file (cons 1 (cons read (cons 1 (cons read-byte (cons 1 (cons read-from-string (cons 1 (cons release (cons 0 (cons remove (cons 2 (cons reverse (cons 1 (cons set (cons 2 (cons simple-error (cons 1 (cons snd (cons 1 (cons specialise (cons 1 (cons spy (cons 1 (cons step (cons 1 (cons stinput (cons 0 (cons stoutput (cons 0 (cons string->n (cons 1 (cons string->symbol (cons 1 (cons string? (cons 1 (cons shen.strong-warning (cons 1 (cons subst (cons 3 (cons sum (cons 1 (cons symbol? (cons 1 (cons tail (cons 1 (cons tl (cons 1 (cons tc (cons 1 (cons tc? (cons 0 (cons thaw (cons 1 (cons tlstr (cons 1 (cons track (cons 1 (cons trap-error (cons 2 (cons tuple? (cons 1 (cons type (cons 2 (cons return (cons 3 (cons undefmacro (cons 1 (cons unprofile (cons 1 (cons unify (cons 4 (cons unify! (cons 4 (cons union (cons 2 (cons untrack (cons 1 (cons unspecialise (cons 1 (cons undefmacro (cons 1 (cons vector (cons 1 (cons vector-> (cons 3 (cons value (cons 1 (cons variable? (cons 1 (cons version (cons 0 (cons warn (cons 1 (cons write-byte (cons 2 (cons write-to-file (cons 2 (cons y-or-n? (cons 1 (cons + (cons 2 (cons * (cons 2 (cons / (cons 2 (cons - (cons 2 (cons == (cons 2 (cons <e> (cons 1 (cons @p (cons 2 (cons @v (cons 2 (cons @s (cons 2 (cons preclude (cons 1 (cons include (cons 1 (cons preclude-all-but (cons 1 (cons include-all-but (cons 1 (cons where (cons 2 ())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
 (defun systemf (V829) (let Shen (intern "shen") (let External (get Shen shen.external-symbols (value *property-vector*)) (put Shen shen.external-symbols (adjoin V829 External) (value *property-vector*)))))
 
 (defun adjoin (V830 V831) (if (element? V830 V831) V831 (cons V830 V831)))
 
-(put (intern "shen") shen.external-symbols (cons ! (cons } (cons { (cons --> (cons <-- (cons && (cons : (cons ; (cons :- (cons := (cons _ (cons *language* (cons *implementation* (cons *stinput* (cons *home-directory* (cons *version* (cons *maximum-print-sequence-size* (cons *macros* (cons *os* (cons *release* (cons *property-vector* (cons @v (cons @p (cons @s (cons *port* (cons *porters* (cons *hush* (cons <- (cons -> (cons <e> (cons == (cons = (cons >= (cons > (cons /. (cons =! (cons $ (cons - (cons / (cons * (cons + (cons <= (cons < (cons >> (cons (vector 0) (cons ==> (cons y-or-n? (cons write-to-file (cons write-byte (cons where (cons when (cons warn (cons version (cons verified (cons variable? (cons value (cons vector-> (cons <-vector (cons vector (cons vector? (cons unspecialise (cons untrack (cons unit (cons shen.unix (cons union (cons unify (cons unify! (cons unprofile (cons undefmacro (cons return (cons type (cons tuple? (cons true (cons trap-error (cons track (cons time (cons thaw (cons tc? (cons tc (cons tl (cons tlstr (cons tlv (cons tail (cons systemf (cons synonyms (cons symbol (cons symbol? (cons string->symbol (cons subst (cons string? (cons string->n (cons stream (cons string (cons stinput (cons stoutput (cons step (cons spy (cons specialise (cons snd (cons simple-error (cons set (cons save (cons str (cons run (cons reverse (cons remove (cons release (cons read (cons read+ (cons read-file (cons read-file-as-bytelist (cons read-file-as-string (cons read-byte (cons read-from-string (cons quit (cons put (cons preclude (cons preclude-all-but (cons ps (cons prolog? (cons protect (cons profile-results (cons profile (cons print (cons pr (cons pos (cons porters (cons port (cons package (cons output (cons out (cons os (cons or (cons open (cons occurrences (cons occurs-check (cons n->string (cons number? (cons number (cons null (cons nth (cons not (cons nl (cons mode (cons macro (cons macroexpand (cons maxinferences (cons mapcan (cons map (cons make-string (cons load (cons loaded (cons list (cons lineread (cons limit (cons length (cons let (cons lazy (cons lambda (cons language (cons kill (cons is (cons intersection (cons inferences (cons intern (cons integer? (cons input (cons input+ (cons include (cons include-all-but (cons in (cons implementation (cons if (cons identical (cons head (cons hd (cons hdv (cons hdstr (cons hash (cons get (cons get-time (cons gensym (cons function (cons fst (cons freeze (cons fix (cons file (cons fail (cons fail-if (cons fwhen (cons findall (cons false (cons enable-type-theory (cons explode (cons external (cons exception (cons eval-kl (cons eval (cons error-to-string (cons error (cons empty? (cons element? (cons do (cons difference (cons destroy (cons defun (cons define (cons defmacro (cons defcc (cons defprolog (cons declare (cons datatype (cons cut (cons cn (cons cons? (cons cons (cons cond (cons concat (cons compile (cons cd (cons cases (cons call (cons close (cons bind (cons bound? (cons boolean? (cons boolean (cons bar! (cons assoc (cons arity (cons append (cons and (cons adjoin (cons <-address (cons address-> (cons absvector? (cons absvector (cons abort ())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) (value *property-vector*))
+(put (intern "shen") shen.external-symbols (cons ! (cons } (cons { (cons --> (cons <-- (cons && (cons : (cons ; (cons :- (cons := (cons _ (cons *language* (cons *implementation* (cons *stinput* (cons *home-directory* (cons *version* (cons *maximum-print-sequence-size* (cons *macros* (cons *os* (cons *release* (cons *property-vector* (cons @v (cons @p (cons @s (cons *port* (cons *porters* (cons *hush* (cons <- (cons -> (cons <e> (cons == (cons = (cons >= (cons > (cons /. (cons =! (cons $ (cons - (cons / (cons * (cons + (cons <= (cons < (cons >> (cons (vector 0) (cons ==> (cons y-or-n? (cons write-to-file (cons write-byte (cons where (cons when (cons warn (cons version (cons verified (cons variable? (cons value (cons vector-> (cons <-vector (cons vector (cons vector? (cons unspecialise (cons untrack (cons unit (cons shen.unix (cons union (cons unify (cons unify! (cons unprofile (cons undefmacro (cons return (cons type (cons tuple? (cons true (cons trap-error (cons track (cons time (cons thaw (cons tc? (cons tc (cons tl (cons tlstr (cons tlv (cons tail (cons systemf (cons synonyms (cons symbol (cons symbol? (cons string->symbol (cons subst (cons string? (cons string->n (cons stream (cons string (cons stinput (cons stoutput (cons step (cons spy (cons specialise (cons snd (cons simple-error (cons set (cons save (cons str (cons run (cons reverse (cons remove (cons release (cons read (cons read-file (cons read-file-as-bytelist (cons read-file-as-string (cons read-byte (cons read-from-string (cons quit (cons put (cons preclude (cons preclude-all-but (cons ps (cons prolog? (cons protect (cons profile-results (cons profile (cons print (cons pr (cons pos (cons porters (cons port (cons package (cons output (cons out (cons os (cons or (cons optimise (cons open (cons occurrences (cons occurs-check (cons n->string (cons number? (cons number (cons null (cons nth (cons not (cons nl (cons mode (cons macro (cons macroexpand (cons maxinferences (cons mapcan (cons map (cons make-string (cons load (cons loaded (cons list (cons lineread (cons limit (cons length (cons let (cons lazy (cons lambda (cons language (cons kill (cons is (cons intersection (cons inferences (cons intern (cons integer? (cons input (cons input+ (cons include (cons include-all-but (cons it (cons in (cons implementation (cons if (cons identical (cons head (cons hd (cons hdv (cons hdstr (cons hash (cons get (cons get-time (cons gensym (cons function (cons fst (cons freeze (cons fix (cons file (cons fail (cons fail-if (cons fwhen (cons findall (cons false (cons enable-type-theory (cons explode (cons external (cons exception (cons eval-kl (cons eval (cons error-to-string (cons error (cons empty? (cons element? (cons do (cons difference (cons destroy (cons defun (cons define (cons defmacro (cons defcc (cons defprolog (cons declare (cons datatype (cons cut (cons cn (cons cons? (cons cons (cons cond (cons concat (cons compile (cons cd (cons cases (cons call (cons close (cons bind (cons bound? (cons boolean? (cons boolean (cons bar! (cons assoc (cons arity (cons append (cons and (cons adjoin (cons <-address (cons address-> (cons absvector? (cons absvector (cons abort ()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) (value *property-vector*))
 
 (defun specialise (V832) (do (set shen.*special* (cons V832 (value shen.*special*))) V832))
 

data/shen/release/k_lambda/macros.kl

@@ -75,22 +75,6 @@
 
 (defun shen.intern-type (V901) (intern (cn "type#" (str V901))))
 
-"(defcc <defmacro>
- <name> <macrorules> := [define <name> | <macrorules>];)
-
-(defcc <macrorules>
-  <macrorule> <macrorules>;
-  <macrorule> := (append <macrorule> [(protect X) -> (protect X)]);)
-
-(defcc <macrorule>
-  <patterns> -> <macroaction> where <guard>;
-  <patterns> -> <macroaction>;
-  <patterns> <- <macroaction> where <guard>;
-  <patterns> <- <macroaction>;)
-
-(defcc <macroaction>
-  <action> := [[walk [function macroexpand] <action>]];)"
-
 (defun shen.@s-macro (V902) (cond ((and (cons? V902) (and (= @s (hd V902)) (and (cons? (tl V902)) (and (cons? (tl (tl V902))) (cons? (tl (tl (tl V902)))))))) (cons @s (cons (hd (tl V902)) (cons (shen.@s-macro (cons @s (tl (tl V902)))) ())))) ((and (cons? V902) (and (= @s (hd V902)) (and (cons? (tl V902)) (and (cons? (tl (tl V902))) (and (= () (tl (tl (tl V902)))) (string? (hd (tl V902)))))))) (let E (explode (hd (tl V902))) (if (> (length E) 1) (shen.@s-macro (cons @s (append E (tl (tl V902))))) V902))) (true V902)))
 
 (defun shen.synonyms-macro (V903) (cond ((and (cons? V903) (= synonyms (hd V903))) (cons shen.synonyms-help (cons (shen.rcons_form (shen.curry-synonyms (tl V903))) ()))) (true V903)))

data/shen/release/k_lambda/prolog.kl

@@ -185,7 +185,7 @@
 
 (defun shen.mk-pvar (V1155) (address-> (address-> (absvector 2) 0 shen.pvar) 1 V1155))
 
-(defun shen.pvar? (V1156) (and (absvector? V1156) (= (<-address V1156 0) shen.pvar)))
+(defun shen.pvar? (V1156) (trap-error (and (absvector? V1156) (= (<-address V1156 0) shen.pvar)) (lambda E false)))
 
 (defun shen.bindv (V1157 V1158 V1159) (let Vector (<-address (value shen.*prologvectors*) V1159) (address-> Vector (<-address V1157 1) V1158)))
 

data/shen/release/k_lambda/reader.kl

@@ -47,166 +47,176 @@
 * explains this license in full.                                                        *
 *				 						                                                                    *
 *****************************************************************************************
-"(defun read-file-as-bytelist (V1347) (let Stream (open V1347 in) (let Byte (read-byte Stream) (let Bytes (shen.read-file-as-bytelist-help Stream Byte ()) (let Close (close Stream) (reverse Bytes))))))
+"(defun read-file-as-bytelist (V1348) (let Stream (open V1348 in) (let Byte (read-byte Stream) (let Bytes (shen.read-file-as-bytelist-help Stream Byte ()) (let Close (close Stream) (reverse Bytes))))))
 
-(defun shen.read-file-as-bytelist-help (V1348 V1349 V1350) (cond ((= -1 V1349) V1350) (true (shen.read-file-as-bytelist-help V1348 (read-byte V1348) (cons V1349 V1350)))))
+(defun shen.read-file-as-bytelist-help (V1349 V1350 V1351) (cond ((= -1 V1350) V1351) (true (shen.read-file-as-bytelist-help V1349 (read-byte V1349) (cons V1350 V1351)))))
 
-(defun read-file-as-string (V1351) (let Stream (open V1351 in) (shen.rfas-h Stream (read-byte Stream) "")))
+(defun read-file-as-string (V1352) (let Stream (open V1352 in) (shen.rfas-h Stream (read-byte Stream) "")))
 
-(defun shen.rfas-h (V1352 V1353 V1354) (cond ((= -1 V1353) (do (close V1352) V1354)) (true (shen.rfas-h V1352 (read-byte V1352) (cn V1354 (n->string V1353))))))
+(defun shen.rfas-h (V1353 V1354 V1355) (cond ((= -1 V1354) (do (close V1353) V1355)) (true (shen.rfas-h V1353 (read-byte V1353) (cn V1355 (n->string V1354))))))
 
-(defun input (V1355) (eval-kl (read V1355)))
+(defun input (V1356) (eval-kl (read V1356)))
 
-(defun input+ (V1356 V1357) (let Mono? (shen.monotype V1356) (let Input (read V1357) (if (= false (shen.typecheck Input V1356)) (simple-error (cn "type error: " (shen.app Input (cn " is not of type " (shen.app V1356 "
+(defun input+ (V1357 V1358) (let Mono? (shen.monotype V1357) (let Input (read V1358) (if (= false (shen.typecheck Input (shen.demodulate V1357))) (simple-error (cn "type error: " (shen.app Input (cn " is not of type " (shen.app V1357 "
 " shen.r)) shen.r))) (eval-kl Input)))))
 
-(defun shen.monotype (V1358) (cond ((cons? V1358) (map (lambda X1337 (shen.monotype X1337)) V1358)) (true (if (variable? V1358) (simple-error (cn "input+ expects a monotype: not " (shen.app V1358 "
-" shen.a))) V1358))))
+(defun shen.monotype (V1359) (cond ((cons? V1359) (map (lambda X1337 (shen.monotype X1337)) V1359)) (true (if (variable? V1359) (simple-error (cn "input+ expects a monotype: not " (shen.app V1359 "
+" shen.a))) V1359))))
 
-(defun read (V1359) (hd (shen.read-loop V1359 (read-byte V1359) ())))
+(defun read (V1360) (hd (shen.read-loop V1360 (read-byte V1360) ())))
 
-(defun shen.read-loop (V1362 V1363 V1364) (cond ((= -1 V1363) (if (empty? V1364) (simple-error "error: empty stream") (compile (lambda X1338 (shen.<st_input> X1338)) V1364 (lambda E E)))) ((shen.terminator? V1363) (let AllBytes (append V1364 (cons V1363 ())) (let Read (compile (lambda X1339 (shen.<st_input> X1339)) AllBytes (lambda E shen.nextbyte)) (if (or (= Read shen.nextbyte) (empty? Read)) (shen.read-loop V1362 (read-byte V1362) AllBytes) Read)))) (true (shen.read-loop V1362 (read-byte V1362) (append V1364 (cons V1363 ()))))))
+(defun it () (value shen.*it*))
 
-(defun shen.terminator? (V1365) (element? V1365 (cons 9 (cons 10 (cons 13 (cons 32 (cons 34 (cons 41 (cons 93 ())))))))))
+(defun shen.read-loop (V1365 V1366 V1367) (cond ((= 94 V1366) (simple-error "read aborted")) ((= -1 V1366) (if (empty? V1367) (simple-error "error: empty stream") (compile (lambda X1338 (shen.<st_input> X1338)) V1367 (lambda E E)))) ((shen.terminator? V1366) (let AllBytes (append V1367 (cons V1366 ())) (let It (shen.record-it AllBytes) (let Read (compile (lambda X1339 (shen.<st_input> X1339)) AllBytes (lambda E shen.nextbyte)) (if (or (= Read shen.nextbyte) (empty? Read)) (shen.read-loop V1365 (read-byte V1365) AllBytes) Read))))) (true (shen.read-loop V1365 (read-byte V1365) (append V1367 (cons V1366 ()))))))
 
-(defun lineread (V1366) (shen.lineread-loop (read-byte V1366) () V1366))
+(defun shen.terminator? (V1368) (element? V1368 (cons 9 (cons 10 (cons 13 (cons 32 (cons 34 (cons 41 (cons 93 ())))))))))
 
-(defun shen.lineread-loop (V1368 V1369 V1370) (cond ((= -1 V1368) (if (empty? V1369) (simple-error "empty stream") (compile (lambda X1340 (shen.<st_input> X1340)) V1369 (lambda E E)))) ((= V1368 (shen.hat)) (simple-error "line read aborted")) ((element? V1368 (cons (shen.newline) (cons (shen.carriage-return) ()))) (let Line (compile (lambda X1341 (shen.<st_input> X1341)) V1369 (lambda E shen.nextline)) (if (or (= Line shen.nextline) (empty? Line)) (shen.lineread-loop (read-byte V1370) (append V1369 (cons V1368 ())) V1370) Line))) (true (shen.lineread-loop (read-byte V1370) (append V1369 (cons V1368 ())) V1370))))
+(defun lineread (V1369) (shen.lineread-loop (read-byte V1369) () V1369))
 
-(defun read-file (V1371) (let Bytelist (read-file-as-bytelist V1371) (compile (lambda X1342 (shen.<st_input> X1342)) Bytelist (lambda X1343 (shen.read-error X1343)))))
+(defun shen.lineread-loop (V1371 V1372 V1373) (cond ((= -1 V1371) (if (empty? V1372) (simple-error "empty stream") (compile (lambda X1340 (shen.<st_input> X1340)) V1372 (lambda E E)))) ((= V1371 (shen.hat)) (simple-error "line read aborted")) ((element? V1371 (cons (shen.newline) (cons (shen.carriage-return) ()))) (let Line (compile (lambda X1341 (shen.<st_input> X1341)) V1372 (lambda E shen.nextline)) (let It (shen.record-it V1372) (if (or (= Line shen.nextline) (empty? Line)) (shen.lineread-loop (read-byte V1373) (append V1372 (cons V1371 ())) V1373) Line)))) (true (shen.lineread-loop (read-byte V1373) (append V1372 (cons V1371 ())) V1373))))
 
-(defun read-from-string (V1372) (let Ns (map (lambda X1344 (string->n X1344)) (explode V1372)) (compile (lambda X1345 (shen.<st_input> X1345)) Ns (lambda X1346 (shen.read-error X1346)))))
+(defun shen.record-it (V1374) (let TrimLeft (shen.trim-whitespace V1374) (let TrimRight (shen.trim-whitespace (reverse TrimLeft)) (let Trimmed (reverse TrimRight) (shen.record-it-h Trimmed)))))
 
-(defun shen.read-error (V1379) (cond ((and (cons? V1379) (and (cons? (hd V1379)) (and (cons? (tl V1379)) (= () (tl (tl V1379)))))) (simple-error (cn "read error here:
+(defun shen.trim-whitespace (V1375) (cond ((and (cons? V1375) (element? (hd V1375) (cons 9 (cons 10 (cons 13 (cons 32 ())))))) (shen.trim-whitespace (tl V1375))) (true V1375)))
 
- " (shen.app (shen.compress-50 50 (hd V1379)) "
+(defun shen.record-it-h (V1376) (do (set shen.*it* (shen.cn-all (map (lambda X1342 (n->string X1342)) V1376))) V1376))
+
+(defun shen.cn-all (V1377) (cond ((= () V1377) "") ((cons? V1377) (cn (hd V1377) (shen.cn-all (tl V1377)))) (true (shen.sys-error shen.cn-all))))
+
+(defun read-file (V1378) (let Bytelist (read-file-as-bytelist V1378) (compile (lambda X1343 (shen.<st_input> X1343)) Bytelist (lambda X1344 (shen.read-error X1344)))))
+
+(defun read-from-string (V1379) (let Ns (map (lambda X1345 (string->n X1345)) (explode V1379)) (compile (lambda X1346 (shen.<st_input> X1346)) Ns (lambda X1347 (shen.read-error X1347)))))
+
+(defun shen.read-error (V1386) (cond ((and (cons? V1386) (and (cons? (hd V1386)) (and (cons? (tl V1386)) (= () (tl (tl V1386)))))) (simple-error (cn "read error here:
+
+ " (shen.app (shen.compress-50 50 (hd V1386)) "
 " shen.a)))) (true (simple-error "read error
 "))))
 
-(defun shen.compress-50 (V1384 V1385) (cond ((= () V1385) "") ((= 0 V1384) "") ((cons? V1385) (cn (n->string (hd V1385)) (shen.compress-50 (- V1384 1) (tl V1385)))) (true (shen.sys-error shen.compress-50))))
+(defun shen.compress-50 (V1391 V1392) (cond ((= () V1392) "") ((= 0 V1391) "") ((cons? V1392) (cn (n->string (hd V1392)) (shen.compress-50 (- V1391 1) (tl V1392)))) (true (shen.sys-error shen.compress-50))))
 
-(defun shen.<st_input> (V1390) (let Result (let Parse_shen.<lsb> (shen.<lsb> V1390) (if (not (= (fail) Parse_shen.<lsb>)) (let Parse_shen.<st_input1> (shen.<st_input1> Parse_shen.<lsb>) (if (not (= (fail) Parse_shen.<st_input1>)) (let Parse_shen.<rsb> (shen.<rsb> Parse_shen.<st_input1>) (if (not (= (fail) Parse_shen.<rsb>)) (let Parse_shen.<st_input2> (shen.<st_input2> Parse_shen.<rsb>) (if (not (= (fail) Parse_shen.<st_input2>)) (shen.pair (hd Parse_shen.<st_input2>) (cons (macroexpand (shen.cons_form (shen.hdtl Parse_shen.<st_input1>))) (shen.hdtl Parse_shen.<st_input2>))) (fail))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<lrb> (shen.<lrb> V1390) (if (not (= (fail) Parse_shen.<lrb>)) (let Parse_shen.<st_input1> (shen.<st_input1> Parse_shen.<lrb>) (if (not (= (fail) Parse_shen.<st_input1>)) (let Parse_shen.<rrb> (shen.<rrb> Parse_shen.<st_input1>) (if (not (= (fail) Parse_shen.<rrb>)) (let Parse_shen.<st_input2> (shen.<st_input2> Parse_shen.<rrb>) (if (not (= (fail) Parse_shen.<st_input2>)) (shen.pair (hd Parse_shen.<st_input2>) (shen.package-macro (macroexpand (shen.hdtl Parse_shen.<st_input1>)) (shen.hdtl Parse_shen.<st_input2>))) (fail))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<lcurly> (shen.<lcurly> V1390) (if (not (= (fail) Parse_shen.<lcurly>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<lcurly>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons { (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<rcurly> (shen.<rcurly> V1390) (if (not (= (fail) Parse_shen.<rcurly>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<rcurly>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons } (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<bar> (shen.<bar> V1390) (if (not (= (fail) Parse_shen.<bar>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<bar>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons bar! (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<semicolon> (shen.<semicolon> V1390) (if (not (= (fail) Parse_shen.<semicolon>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<semicolon>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons ; (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<colon> (shen.<colon> V1390) (if (not (= (fail) Parse_shen.<colon>)) (let Parse_shen.<equal> (shen.<equal> Parse_shen.<colon>) (if (not (= (fail) Parse_shen.<equal>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<equal>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons := (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<colon> (shen.<colon> V1390) (if (not (= (fail) Parse_shen.<colon>)) (let Parse_shen.<minus> (shen.<minus> Parse_shen.<colon>) (if (not (= (fail) Parse_shen.<minus>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<minus>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons :- (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<colon> (shen.<colon> V1390) (if (not (= (fail) Parse_shen.<colon>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<colon>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons : (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<comma> (shen.<comma> V1390) (if (not (= (fail) Parse_shen.<comma>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<comma>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons (intern ",") (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<comment> (shen.<comment> V1390) (if (not (= (fail) Parse_shen.<comment>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<comment>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (shen.hdtl Parse_shen.<st_input>)) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<atom> (shen.<atom> V1390) (if (not (= (fail) Parse_shen.<atom>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<atom>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons (macroexpand (shen.hdtl Parse_shen.<atom>)) (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<whitespaces> (shen.<whitespaces> V1390) (if (not (= (fail) Parse_shen.<whitespaces>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<whitespaces>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (shen.hdtl Parse_shen.<st_input>)) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1390) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)))
+(defun shen.<st_input> (V1397) (let Result (let Parse_shen.<lsb> (shen.<lsb> V1397) (if (not (= (fail) Parse_shen.<lsb>)) (let Parse_shen.<st_input1> (shen.<st_input1> Parse_shen.<lsb>) (if (not (= (fail) Parse_shen.<st_input1>)) (let Parse_shen.<rsb> (shen.<rsb> Parse_shen.<st_input1>) (if (not (= (fail) Parse_shen.<rsb>)) (let Parse_shen.<st_input2> (shen.<st_input2> Parse_shen.<rsb>) (if (not (= (fail) Parse_shen.<st_input2>)) (shen.pair (hd Parse_shen.<st_input2>) (cons (macroexpand (shen.cons_form (shen.hdtl Parse_shen.<st_input1>))) (shen.hdtl Parse_shen.<st_input2>))) (fail))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<lrb> (shen.<lrb> V1397) (if (not (= (fail) Parse_shen.<lrb>)) (let Parse_shen.<st_input1> (shen.<st_input1> Parse_shen.<lrb>) (if (not (= (fail) Parse_shen.<st_input1>)) (let Parse_shen.<rrb> (shen.<rrb> Parse_shen.<st_input1>) (if (not (= (fail) Parse_shen.<rrb>)) (let Parse_shen.<st_input2> (shen.<st_input2> Parse_shen.<rrb>) (if (not (= (fail) Parse_shen.<st_input2>)) (shen.pair (hd Parse_shen.<st_input2>) (shen.package-macro (macroexpand (shen.hdtl Parse_shen.<st_input1>)) (shen.hdtl Parse_shen.<st_input2>))) (fail))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<lcurly> (shen.<lcurly> V1397) (if (not (= (fail) Parse_shen.<lcurly>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<lcurly>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons { (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<rcurly> (shen.<rcurly> V1397) (if (not (= (fail) Parse_shen.<rcurly>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<rcurly>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons } (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<bar> (shen.<bar> V1397) (if (not (= (fail) Parse_shen.<bar>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<bar>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons bar! (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<semicolon> (shen.<semicolon> V1397) (if (not (= (fail) Parse_shen.<semicolon>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<semicolon>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons ; (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<colon> (shen.<colon> V1397) (if (not (= (fail) Parse_shen.<colon>)) (let Parse_shen.<equal> (shen.<equal> Parse_shen.<colon>) (if (not (= (fail) Parse_shen.<equal>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<equal>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons := (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<colon> (shen.<colon> V1397) (if (not (= (fail) Parse_shen.<colon>)) (let Parse_shen.<minus> (shen.<minus> Parse_shen.<colon>) (if (not (= (fail) Parse_shen.<minus>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<minus>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons :- (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<colon> (shen.<colon> V1397) (if (not (= (fail) Parse_shen.<colon>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<colon>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons : (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<comma> (shen.<comma> V1397) (if (not (= (fail) Parse_shen.<comma>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<comma>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons (intern ",") (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<comment> (shen.<comment> V1397) (if (not (= (fail) Parse_shen.<comment>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<comment>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (shen.hdtl Parse_shen.<st_input>)) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<atom> (shen.<atom> V1397) (if (not (= (fail) Parse_shen.<atom>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<atom>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (cons (macroexpand (shen.hdtl Parse_shen.<atom>)) (shen.hdtl Parse_shen.<st_input>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<whitespaces> (shen.<whitespaces> V1397) (if (not (= (fail) Parse_shen.<whitespaces>)) (let Parse_shen.<st_input> (shen.<st_input> Parse_shen.<whitespaces>) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (shen.hdtl Parse_shen.<st_input>)) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1397) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)) Result)))
 
-(defun shen.<lsb> (V1395) (let Result (if (and (cons? (hd V1395)) (= 91 (hd (hd V1395)))) (shen.pair (hd (shen.pair (tl (hd V1395)) (shen.hdtl V1395))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<lsb> (V1402) (let Result (if (and (cons? (hd V1402)) (= 91 (hd (hd V1402)))) (shen.pair (hd (shen.pair (tl (hd V1402)) (shen.hdtl V1402))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<rsb> (V1400) (let Result (if (and (cons? (hd V1400)) (= 93 (hd (hd V1400)))) (shen.pair (hd (shen.pair (tl (hd V1400)) (shen.hdtl V1400))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<rsb> (V1407) (let Result (if (and (cons? (hd V1407)) (= 93 (hd (hd V1407)))) (shen.pair (hd (shen.pair (tl (hd V1407)) (shen.hdtl V1407))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<lcurly> (V1405) (let Result (if (and (cons? (hd V1405)) (= 123 (hd (hd V1405)))) (shen.pair (hd (shen.pair (tl (hd V1405)) (shen.hdtl V1405))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<lcurly> (V1412) (let Result (if (and (cons? (hd V1412)) (= 123 (hd (hd V1412)))) (shen.pair (hd (shen.pair (tl (hd V1412)) (shen.hdtl V1412))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<rcurly> (V1410) (let Result (if (and (cons? (hd V1410)) (= 125 (hd (hd V1410)))) (shen.pair (hd (shen.pair (tl (hd V1410)) (shen.hdtl V1410))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<rcurly> (V1417) (let Result (if (and (cons? (hd V1417)) (= 125 (hd (hd V1417)))) (shen.pair (hd (shen.pair (tl (hd V1417)) (shen.hdtl V1417))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<bar> (V1415) (let Result (if (and (cons? (hd V1415)) (= 124 (hd (hd V1415)))) (shen.pair (hd (shen.pair (tl (hd V1415)) (shen.hdtl V1415))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<bar> (V1422) (let Result (if (and (cons? (hd V1422)) (= 124 (hd (hd V1422)))) (shen.pair (hd (shen.pair (tl (hd V1422)) (shen.hdtl V1422))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<semicolon> (V1420) (let Result (if (and (cons? (hd V1420)) (= 59 (hd (hd V1420)))) (shen.pair (hd (shen.pair (tl (hd V1420)) (shen.hdtl V1420))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<semicolon> (V1427) (let Result (if (and (cons? (hd V1427)) (= 59 (hd (hd V1427)))) (shen.pair (hd (shen.pair (tl (hd V1427)) (shen.hdtl V1427))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<colon> (V1425) (let Result (if (and (cons? (hd V1425)) (= 58 (hd (hd V1425)))) (shen.pair (hd (shen.pair (tl (hd V1425)) (shen.hdtl V1425))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<colon> (V1432) (let Result (if (and (cons? (hd V1432)) (= 58 (hd (hd V1432)))) (shen.pair (hd (shen.pair (tl (hd V1432)) (shen.hdtl V1432))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<comma> (V1430) (let Result (if (and (cons? (hd V1430)) (= 44 (hd (hd V1430)))) (shen.pair (hd (shen.pair (tl (hd V1430)) (shen.hdtl V1430))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<comma> (V1437) (let Result (if (and (cons? (hd V1437)) (= 44 (hd (hd V1437)))) (shen.pair (hd (shen.pair (tl (hd V1437)) (shen.hdtl V1437))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<equal> (V1435) (let Result (if (and (cons? (hd V1435)) (= 61 (hd (hd V1435)))) (shen.pair (hd (shen.pair (tl (hd V1435)) (shen.hdtl V1435))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<equal> (V1442) (let Result (if (and (cons? (hd V1442)) (= 61 (hd (hd V1442)))) (shen.pair (hd (shen.pair (tl (hd V1442)) (shen.hdtl V1442))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<minus> (V1440) (let Result (if (and (cons? (hd V1440)) (= 45 (hd (hd V1440)))) (shen.pair (hd (shen.pair (tl (hd V1440)) (shen.hdtl V1440))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<minus> (V1447) (let Result (if (and (cons? (hd V1447)) (= 45 (hd (hd V1447)))) (shen.pair (hd (shen.pair (tl (hd V1447)) (shen.hdtl V1447))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<lrb> (V1445) (let Result (if (and (cons? (hd V1445)) (= 40 (hd (hd V1445)))) (shen.pair (hd (shen.pair (tl (hd V1445)) (shen.hdtl V1445))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<lrb> (V1452) (let Result (if (and (cons? (hd V1452)) (= 40 (hd (hd V1452)))) (shen.pair (hd (shen.pair (tl (hd V1452)) (shen.hdtl V1452))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<rrb> (V1450) (let Result (if (and (cons? (hd V1450)) (= 41 (hd (hd V1450)))) (shen.pair (hd (shen.pair (tl (hd V1450)) (shen.hdtl V1450))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<rrb> (V1457) (let Result (if (and (cons? (hd V1457)) (= 41 (hd (hd V1457)))) (shen.pair (hd (shen.pair (tl (hd V1457)) (shen.hdtl V1457))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<atom> (V1455) (let Result (let Parse_shen.<str> (shen.<str> V1455) (if (not (= (fail) Parse_shen.<str>)) (shen.pair (hd Parse_shen.<str>) (shen.control-chars (shen.hdtl Parse_shen.<str>))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<number> (shen.<number> V1455) (if (not (= (fail) Parse_shen.<number>)) (shen.pair (hd Parse_shen.<number>) (shen.hdtl Parse_shen.<number>)) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<sym> (shen.<sym> V1455) (if (not (= (fail) Parse_shen.<sym>)) (shen.pair (hd Parse_shen.<sym>) (if (= (shen.hdtl Parse_shen.<sym>) "<>") (cons vector (cons 0 ())) (intern (shen.hdtl Parse_shen.<sym>)))) (fail))) (if (= Result (fail)) (fail) Result)) Result)) Result)))
+(defun shen.<atom> (V1462) (let Result (let Parse_shen.<str> (shen.<str> V1462) (if (not (= (fail) Parse_shen.<str>)) (shen.pair (hd Parse_shen.<str>) (shen.control-chars (shen.hdtl Parse_shen.<str>))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<number> (shen.<number> V1462) (if (not (= (fail) Parse_shen.<number>)) (shen.pair (hd Parse_shen.<number>) (shen.hdtl Parse_shen.<number>)) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<sym> (shen.<sym> V1462) (if (not (= (fail) Parse_shen.<sym>)) (shen.pair (hd Parse_shen.<sym>) (if (= (shen.hdtl Parse_shen.<sym>) "<>") (cons vector (cons 0 ())) (intern (shen.hdtl Parse_shen.<sym>)))) (fail))) (if (= Result (fail)) (fail) Result)) Result)) Result)))
 
-(defun shen.control-chars (V1456) (cond ((= () V1456) "") ((and (cons? V1456) (and (= "c" (hd V1456)) (and (cons? (tl V1456)) (= "#" (hd (tl V1456)))))) (let CodePoint (shen.code-point (tl (tl V1456))) (let AfterCodePoint (shen.after-codepoint (tl (tl V1456))) (@s (n->string (shen.decimalise CodePoint)) (shen.control-chars AfterCodePoint))))) ((cons? V1456) (@s (hd V1456) (shen.control-chars (tl V1456)))) (true (shen.sys-error shen.control-chars))))
+(defun shen.control-chars (V1463) (cond ((= () V1463) "") ((and (cons? V1463) (and (= "c" (hd V1463)) (and (cons? (tl V1463)) (= "#" (hd (tl V1463)))))) (let CodePoint (shen.code-point (tl (tl V1463))) (let AfterCodePoint (shen.after-codepoint (tl (tl V1463))) (@s (n->string (shen.decimalise CodePoint)) (shen.control-chars AfterCodePoint))))) ((cons? V1463) (@s (hd V1463) (shen.control-chars (tl V1463)))) (true (shen.sys-error shen.control-chars))))
 
-(defun shen.code-point (V1459) (cond ((and (cons? V1459) (= ";" (hd V1459))) "") ((and (cons? V1459) (element? (hd V1459) (cons "0" (cons "1" (cons "2" (cons "3" (cons "4" (cons "5" (cons "6" (cons "7" (cons "8" (cons "9" (cons "0" ()))))))))))))) (cons (hd V1459) (shen.code-point (tl V1459)))) (true (simple-error (cn "code point parse error " (shen.app V1459 "
+(defun shen.code-point (V1466) (cond ((and (cons? V1466) (= ";" (hd V1466))) "") ((and (cons? V1466) (element? (hd V1466) (cons "0" (cons "1" (cons "2" (cons "3" (cons "4" (cons "5" (cons "6" (cons "7" (cons "8" (cons "9" (cons "0" ()))))))))))))) (cons (hd V1466) (shen.code-point (tl V1466)))) (true (simple-error (cn "code point parse error " (shen.app V1466 "
 " shen.a))))))
 
-(defun shen.after-codepoint (V1464) (cond ((= () V1464) ()) ((and (cons? V1464) (= ";" (hd V1464))) (tl V1464)) ((cons? V1464) (shen.after-codepoint (tl V1464))) (true (shen.sys-error shen.after-codepoint))))
+(defun shen.after-codepoint (V1471) (cond ((= () V1471) ()) ((and (cons? V1471) (= ";" (hd V1471))) (tl V1471)) ((cons? V1471) (shen.after-codepoint (tl V1471))) (true (shen.sys-error shen.after-codepoint))))
 
-(defun shen.decimalise (V1465) (shen.pre (reverse (shen.digits->integers V1465)) 0))
+(defun shen.decimalise (V1472) (shen.pre (reverse (shen.digits->integers V1472)) 0))
 
-(defun shen.digits->integers (V1470) (cond ((and (cons? V1470) (= "0" (hd V1470))) (cons 0 (shen.digits->integers (tl V1470)))) ((and (cons? V1470) (= "1" (hd V1470))) (cons 1 (shen.digits->integers (tl V1470)))) ((and (cons? V1470) (= "2" (hd V1470))) (cons 2 (shen.digits->integers (tl V1470)))) ((and (cons? V1470) (= "3" (hd V1470))) (cons 3 (shen.digits->integers (tl V1470)))) ((and (cons? V1470) (= "4" (hd V1470))) (cons 4 (shen.digits->integers (tl V1470)))) ((and (cons? V1470) (= "5" (hd V1470))) (cons 5 (shen.digits->integers (tl V1470)))) ((and (cons? V1470) (= "6" (hd V1470))) (cons 6 (shen.digits->integers (tl V1470)))) ((and (cons? V1470) (= "7" (hd V1470))) (cons 7 (shen.digits->integers (tl V1470)))) ((and (cons? V1470) (= "8" (hd V1470))) (cons 8 (shen.digits->integers (tl V1470)))) ((and (cons? V1470) (= "9" (hd V1470))) (cons 9 (shen.digits->integers (tl V1470)))) (true ())))
+(defun shen.digits->integers (V1477) (cond ((and (cons? V1477) (= "0" (hd V1477))) (cons 0 (shen.digits->integers (tl V1477)))) ((and (cons? V1477) (= "1" (hd V1477))) (cons 1 (shen.digits->integers (tl V1477)))) ((and (cons? V1477) (= "2" (hd V1477))) (cons 2 (shen.digits->integers (tl V1477)))) ((and (cons? V1477) (= "3" (hd V1477))) (cons 3 (shen.digits->integers (tl V1477)))) ((and (cons? V1477) (= "4" (hd V1477))) (cons 4 (shen.digits->integers (tl V1477)))) ((and (cons? V1477) (= "5" (hd V1477))) (cons 5 (shen.digits->integers (tl V1477)))) ((and (cons? V1477) (= "6" (hd V1477))) (cons 6 (shen.digits->integers (tl V1477)))) ((and (cons? V1477) (= "7" (hd V1477))) (cons 7 (shen.digits->integers (tl V1477)))) ((and (cons? V1477) (= "8" (hd V1477))) (cons 8 (shen.digits->integers (tl V1477)))) ((and (cons? V1477) (= "9" (hd V1477))) (cons 9 (shen.digits->integers (tl V1477)))) (true ())))
 
-(defun shen.<sym> (V1475) (let Result (let Parse_shen.<alpha> (shen.<alpha> V1475) (if (not (= (fail) Parse_shen.<alpha>)) (let Parse_shen.<alphanums> (shen.<alphanums> Parse_shen.<alpha>) (if (not (= (fail) Parse_shen.<alphanums>)) (shen.pair (hd Parse_shen.<alphanums>) (@s (shen.hdtl Parse_shen.<alpha>) (shen.hdtl Parse_shen.<alphanums>))) (fail))) (fail))) (if (= Result (fail)) (fail) Result)))
+(defun shen.<sym> (V1482) (let Result (let Parse_shen.<alpha> (shen.<alpha> V1482) (if (not (= (fail) Parse_shen.<alpha>)) (let Parse_shen.<alphanums> (shen.<alphanums> Parse_shen.<alpha>) (if (not (= (fail) Parse_shen.<alphanums>)) (shen.pair (hd Parse_shen.<alphanums>) (@s (shen.hdtl Parse_shen.<alpha>) (shen.hdtl Parse_shen.<alphanums>))) (fail))) (fail))) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<alphanums> (V1480) (let Result (let Parse_shen.<alphanum> (shen.<alphanum> V1480) (if (not (= (fail) Parse_shen.<alphanum>)) (let Parse_shen.<alphanums> (shen.<alphanums> Parse_shen.<alphanum>) (if (not (= (fail) Parse_shen.<alphanums>)) (shen.pair (hd Parse_shen.<alphanums>) (@s (shen.hdtl Parse_shen.<alphanum>) (shen.hdtl Parse_shen.<alphanums>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1480) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) "") (fail))) (if (= Result (fail)) (fail) Result)) Result)))
+(defun shen.<alphanums> (V1487) (let Result (let Parse_shen.<alphanum> (shen.<alphanum> V1487) (if (not (= (fail) Parse_shen.<alphanum>)) (let Parse_shen.<alphanums> (shen.<alphanums> Parse_shen.<alphanum>) (if (not (= (fail) Parse_shen.<alphanums>)) (shen.pair (hd Parse_shen.<alphanums>) (@s (shen.hdtl Parse_shen.<alphanum>) (shen.hdtl Parse_shen.<alphanums>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1487) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) "") (fail))) (if (= Result (fail)) (fail) Result)) Result)))
 
-(defun shen.<alphanum> (V1485) (let Result (let Parse_shen.<alpha> (shen.<alpha> V1485) (if (not (= (fail) Parse_shen.<alpha>)) (shen.pair (hd Parse_shen.<alpha>) (shen.hdtl Parse_shen.<alpha>)) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<num> (shen.<num> V1485) (if (not (= (fail) Parse_shen.<num>)) (shen.pair (hd Parse_shen.<num>) (shen.hdtl Parse_shen.<num>)) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
+(defun shen.<alphanum> (V1492) (let Result (let Parse_shen.<alpha> (shen.<alpha> V1492) (if (not (= (fail) Parse_shen.<alpha>)) (shen.pair (hd Parse_shen.<alpha>) (shen.hdtl Parse_shen.<alpha>)) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<num> (shen.<num> V1492) (if (not (= (fail) Parse_shen.<num>)) (shen.pair (hd Parse_shen.<num>) (shen.hdtl Parse_shen.<num>)) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
 
-(defun shen.<num> (V1490) (let Result (if (cons? (hd V1490)) (let Parse_Byte (hd (hd V1490)) (if (shen.numbyte? Parse_Byte) (shen.pair (hd (shen.pair (tl (hd V1490)) (shen.hdtl V1490))) (n->string Parse_Byte)) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<num> (V1497) (let Result (if (cons? (hd V1497)) (let Parse_Byte (hd (hd V1497)) (if (shen.numbyte? Parse_Byte) (shen.pair (hd (shen.pair (tl (hd V1497)) (shen.hdtl V1497))) (n->string Parse_Byte)) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.numbyte? (V1495) (cond ((= 48 V1495) true) ((= 49 V1495) true) ((= 50 V1495) true) ((= 51 V1495) true) ((= 52 V1495) true) ((= 53 V1495) true) ((= 54 V1495) true) ((= 55 V1495) true) ((= 56 V1495) true) ((= 57 V1495) true) (true false)))
+(defun shen.numbyte? (V1502) (cond ((= 48 V1502) true) ((= 49 V1502) true) ((= 50 V1502) true) ((= 51 V1502) true) ((= 52 V1502) true) ((= 53 V1502) true) ((= 54 V1502) true) ((= 55 V1502) true) ((= 56 V1502) true) ((= 57 V1502) true) (true false)))
 
-(defun shen.<alpha> (V1500) (let Result (if (cons? (hd V1500)) (let Parse_Byte (hd (hd V1500)) (if (shen.symbol-code? Parse_Byte) (shen.pair (hd (shen.pair (tl (hd V1500)) (shen.hdtl V1500))) (n->string Parse_Byte)) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<alpha> (V1507) (let Result (if (cons? (hd V1507)) (let Parse_Byte (hd (hd V1507)) (if (shen.symbol-code? Parse_Byte) (shen.pair (hd (shen.pair (tl (hd V1507)) (shen.hdtl V1507))) (n->string Parse_Byte)) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.symbol-code? (V1501) (or (= V1501 126) (or (and (> V1501 94) (< V1501 123)) (or (and (> V1501 59) (< V1501 91)) (or (and (> V1501 41) (and (< V1501 58) (not (= V1501 44)))) (or (and (> V1501 34) (< V1501 40)) (= V1501 33)))))))
+(defun shen.symbol-code? (V1508) (or (= V1508 126) (or (and (> V1508 94) (< V1508 123)) (or (and (> V1508 59) (< V1508 91)) (or (and (> V1508 41) (and (< V1508 58) (not (= V1508 44)))) (or (and (> V1508 34) (< V1508 40)) (= V1508 33)))))))
 
-(defun shen.<str> (V1506) (let Result (let Parse_shen.<dbq> (shen.<dbq> V1506) (if (not (= (fail) Parse_shen.<dbq>)) (let Parse_shen.<strcontents> (shen.<strcontents> Parse_shen.<dbq>) (if (not (= (fail) Parse_shen.<strcontents>)) (let Parse_shen.<dbq> (shen.<dbq> Parse_shen.<strcontents>) (if (not (= (fail) Parse_shen.<dbq>)) (shen.pair (hd Parse_shen.<dbq>) (shen.hdtl Parse_shen.<strcontents>)) (fail))) (fail))) (fail))) (if (= Result (fail)) (fail) Result)))
+(defun shen.<str> (V1513) (let Result (let Parse_shen.<dbq> (shen.<dbq> V1513) (if (not (= (fail) Parse_shen.<dbq>)) (let Parse_shen.<strcontents> (shen.<strcontents> Parse_shen.<dbq>) (if (not (= (fail) Parse_shen.<strcontents>)) (let Parse_shen.<dbq> (shen.<dbq> Parse_shen.<strcontents>) (if (not (= (fail) Parse_shen.<dbq>)) (shen.pair (hd Parse_shen.<dbq>) (shen.hdtl Parse_shen.<strcontents>)) (fail))) (fail))) (fail))) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<dbq> (V1511) (let Result (if (cons? (hd V1511)) (let Parse_Byte (hd (hd V1511)) (if (= Parse_Byte 34) (shen.pair (hd (shen.pair (tl (hd V1511)) (shen.hdtl V1511))) Parse_Byte) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<dbq> (V1518) (let Result (if (cons? (hd V1518)) (let Parse_Byte (hd (hd V1518)) (if (= Parse_Byte 34) (shen.pair (hd (shen.pair (tl (hd V1518)) (shen.hdtl V1518))) Parse_Byte) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<strcontents> (V1516) (let Result (let Parse_shen.<strc> (shen.<strc> V1516) (if (not (= (fail) Parse_shen.<strc>)) (let Parse_shen.<strcontents> (shen.<strcontents> Parse_shen.<strc>) (if (not (= (fail) Parse_shen.<strcontents>)) (shen.pair (hd Parse_shen.<strcontents>) (cons (shen.hdtl Parse_shen.<strc>) (shen.hdtl Parse_shen.<strcontents>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1516) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
+(defun shen.<strcontents> (V1523) (let Result (let Parse_shen.<strc> (shen.<strc> V1523) (if (not (= (fail) Parse_shen.<strc>)) (let Parse_shen.<strcontents> (shen.<strcontents> Parse_shen.<strc>) (if (not (= (fail) Parse_shen.<strcontents>)) (shen.pair (hd Parse_shen.<strcontents>) (cons (shen.hdtl Parse_shen.<strc>) (shen.hdtl Parse_shen.<strcontents>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1523) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
 
-(defun shen.<byte> (V1521) (let Result (if (cons? (hd V1521)) (let Parse_Byte (hd (hd V1521)) (shen.pair (hd (shen.pair (tl (hd V1521)) (shen.hdtl V1521))) (n->string Parse_Byte))) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<byte> (V1528) (let Result (if (cons? (hd V1528)) (let Parse_Byte (hd (hd V1528)) (shen.pair (hd (shen.pair (tl (hd V1528)) (shen.hdtl V1528))) (n->string Parse_Byte))) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<strc> (V1526) (let Result (if (cons? (hd V1526)) (let Parse_Byte (hd (hd V1526)) (if (not (= Parse_Byte 34)) (shen.pair (hd (shen.pair (tl (hd V1526)) (shen.hdtl V1526))) (n->string Parse_Byte)) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<strc> (V1533) (let Result (if (cons? (hd V1533)) (let Parse_Byte (hd (hd V1533)) (if (not (= Parse_Byte 34)) (shen.pair (hd (shen.pair (tl (hd V1533)) (shen.hdtl V1533))) (n->string Parse_Byte)) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<number> (V1531) (let Result (let Parse_shen.<minus> (shen.<minus> V1531) (if (not (= (fail) Parse_shen.<minus>)) (let Parse_shen.<number> (shen.<number> Parse_shen.<minus>) (if (not (= (fail) Parse_shen.<number>)) (shen.pair (hd Parse_shen.<number>) (- 0 (shen.hdtl Parse_shen.<number>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<plus> (shen.<plus> V1531) (if (not (= (fail) Parse_shen.<plus>)) (let Parse_shen.<number> (shen.<number> Parse_shen.<plus>) (if (not (= (fail) Parse_shen.<number>)) (shen.pair (hd Parse_shen.<number>) (shen.hdtl Parse_shen.<number>)) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<predigits> (shen.<predigits> V1531) (if (not (= (fail) Parse_shen.<predigits>)) (let Parse_shen.<stop> (shen.<stop> Parse_shen.<predigits>) (if (not (= (fail) Parse_shen.<stop>)) (let Parse_shen.<postdigits> (shen.<postdigits> Parse_shen.<stop>) (if (not (= (fail) Parse_shen.<postdigits>)) (let Parse_shen.<E> (shen.<E> Parse_shen.<postdigits>) (if (not (= (fail) Parse_shen.<E>)) (let Parse_shen.<log10> (shen.<log10> Parse_shen.<E>) (if (not (= (fail) Parse_shen.<log10>)) (shen.pair (hd Parse_shen.<log10>) (* (shen.expt 10 (shen.hdtl Parse_shen.<log10>)) (+ (shen.pre (reverse (shen.hdtl Parse_shen.<predigits>)) 0) (shen.post (shen.hdtl Parse_shen.<postdigits>) 1)))) (fail))) (fail))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<digits> (shen.<digits> V1531) (if (not (= (fail) Parse_shen.<digits>)) (let Parse_shen.<E> (shen.<E> Parse_shen.<digits>) (if (not (= (fail) Parse_shen.<E>)) (let Parse_shen.<log10> (shen.<log10> Parse_shen.<E>) (if (not (= (fail) Parse_shen.<log10>)) (shen.pair (hd Parse_shen.<log10>) (* (shen.expt 10 (shen.hdtl Parse_shen.<log10>)) (shen.pre (reverse (shen.hdtl Parse_shen.<digits>)) 0))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<predigits> (shen.<predigits> V1531) (if (not (= (fail) Parse_shen.<predigits>)) (let Parse_shen.<stop> (shen.<stop> Parse_shen.<predigits>) (if (not (= (fail) Parse_shen.<stop>)) (let Parse_shen.<postdigits> (shen.<postdigits> Parse_shen.<stop>) (if (not (= (fail) Parse_shen.<postdigits>)) (shen.pair (hd Parse_shen.<postdigits>) (+ (shen.pre (reverse (shen.hdtl Parse_shen.<predigits>)) 0) (shen.post (shen.hdtl Parse_shen.<postdigits>) 1))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<digits> (shen.<digits> V1531) (if (not (= (fail) Parse_shen.<digits>)) (shen.pair (hd Parse_shen.<digits>) (shen.pre (reverse (shen.hdtl Parse_shen.<digits>)) 0)) (fail))) (if (= Result (fail)) (fail) Result)) Result)) Result)) Result)) Result)) Result)))
+(defun shen.<number> (V1538) (let Result (let Parse_shen.<minus> (shen.<minus> V1538) (if (not (= (fail) Parse_shen.<minus>)) (let Parse_shen.<number> (shen.<number> Parse_shen.<minus>) (if (not (= (fail) Parse_shen.<number>)) (shen.pair (hd Parse_shen.<number>) (- 0 (shen.hdtl Parse_shen.<number>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<plus> (shen.<plus> V1538) (if (not (= (fail) Parse_shen.<plus>)) (let Parse_shen.<number> (shen.<number> Parse_shen.<plus>) (if (not (= (fail) Parse_shen.<number>)) (shen.pair (hd Parse_shen.<number>) (shen.hdtl Parse_shen.<number>)) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<predigits> (shen.<predigits> V1538) (if (not (= (fail) Parse_shen.<predigits>)) (let Parse_shen.<stop> (shen.<stop> Parse_shen.<predigits>) (if (not (= (fail) Parse_shen.<stop>)) (let Parse_shen.<postdigits> (shen.<postdigits> Parse_shen.<stop>) (if (not (= (fail) Parse_shen.<postdigits>)) (let Parse_shen.<E> (shen.<E> Parse_shen.<postdigits>) (if (not (= (fail) Parse_shen.<E>)) (let Parse_shen.<log10> (shen.<log10> Parse_shen.<E>) (if (not (= (fail) Parse_shen.<log10>)) (shen.pair (hd Parse_shen.<log10>) (* (shen.expt 10 (shen.hdtl Parse_shen.<log10>)) (+ (shen.pre (reverse (shen.hdtl Parse_shen.<predigits>)) 0) (shen.post (shen.hdtl Parse_shen.<postdigits>) 1)))) (fail))) (fail))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<digits> (shen.<digits> V1538) (if (not (= (fail) Parse_shen.<digits>)) (let Parse_shen.<E> (shen.<E> Parse_shen.<digits>) (if (not (= (fail) Parse_shen.<E>)) (let Parse_shen.<log10> (shen.<log10> Parse_shen.<E>) (if (not (= (fail) Parse_shen.<log10>)) (shen.pair (hd Parse_shen.<log10>) (* (shen.expt 10 (shen.hdtl Parse_shen.<log10>)) (shen.pre (reverse (shen.hdtl Parse_shen.<digits>)) 0))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<predigits> (shen.<predigits> V1538) (if (not (= (fail) Parse_shen.<predigits>)) (let Parse_shen.<stop> (shen.<stop> Parse_shen.<predigits>) (if (not (= (fail) Parse_shen.<stop>)) (let Parse_shen.<postdigits> (shen.<postdigits> Parse_shen.<stop>) (if (not (= (fail) Parse_shen.<postdigits>)) (shen.pair (hd Parse_shen.<postdigits>) (+ (shen.pre (reverse (shen.hdtl Parse_shen.<predigits>)) 0) (shen.post (shen.hdtl Parse_shen.<postdigits>) 1))) (fail))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<digits> (shen.<digits> V1538) (if (not (= (fail) Parse_shen.<digits>)) (shen.pair (hd Parse_shen.<digits>) (shen.pre (reverse (shen.hdtl Parse_shen.<digits>)) 0)) (fail))) (if (= Result (fail)) (fail) Result)) Result)) Result)) Result)) Result)) Result)))
 
-(defun shen.<E> (V1536) (let Result (if (and (cons? (hd V1536)) (= 101 (hd (hd V1536)))) (shen.pair (hd (shen.pair (tl (hd V1536)) (shen.hdtl V1536))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<E> (V1543) (let Result (if (and (cons? (hd V1543)) (= 101 (hd (hd V1543)))) (shen.pair (hd (shen.pair (tl (hd V1543)) (shen.hdtl V1543))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<log10> (V1541) (let Result (let Parse_shen.<minus> (shen.<minus> V1541) (if (not (= (fail) Parse_shen.<minus>)) (let Parse_shen.<digits> (shen.<digits> Parse_shen.<minus>) (if (not (= (fail) Parse_shen.<digits>)) (shen.pair (hd Parse_shen.<digits>) (- 0 (shen.pre (reverse (shen.hdtl Parse_shen.<digits>)) 0))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<digits> (shen.<digits> V1541) (if (not (= (fail) Parse_shen.<digits>)) (shen.pair (hd Parse_shen.<digits>) (shen.pre (reverse (shen.hdtl Parse_shen.<digits>)) 0)) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
+(defun shen.<log10> (V1548) (let Result (let Parse_shen.<minus> (shen.<minus> V1548) (if (not (= (fail) Parse_shen.<minus>)) (let Parse_shen.<digits> (shen.<digits> Parse_shen.<minus>) (if (not (= (fail) Parse_shen.<digits>)) (shen.pair (hd Parse_shen.<digits>) (- 0 (shen.pre (reverse (shen.hdtl Parse_shen.<digits>)) 0))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<digits> (shen.<digits> V1548) (if (not (= (fail) Parse_shen.<digits>)) (shen.pair (hd Parse_shen.<digits>) (shen.pre (reverse (shen.hdtl Parse_shen.<digits>)) 0)) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
 
-(defun shen.<plus> (V1546) (let Result (if (cons? (hd V1546)) (let Parse_Byte (hd (hd V1546)) (if (= Parse_Byte 43) (shen.pair (hd (shen.pair (tl (hd V1546)) (shen.hdtl V1546))) Parse_Byte) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<plus> (V1553) (let Result (if (cons? (hd V1553)) (let Parse_Byte (hd (hd V1553)) (if (= Parse_Byte 43) (shen.pair (hd (shen.pair (tl (hd V1553)) (shen.hdtl V1553))) Parse_Byte) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<stop> (V1551) (let Result (if (cons? (hd V1551)) (let Parse_Byte (hd (hd V1551)) (if (= Parse_Byte 46) (shen.pair (hd (shen.pair (tl (hd V1551)) (shen.hdtl V1551))) Parse_Byte) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<stop> (V1558) (let Result (if (cons? (hd V1558)) (let Parse_Byte (hd (hd V1558)) (if (= Parse_Byte 46) (shen.pair (hd (shen.pair (tl (hd V1558)) (shen.hdtl V1558))) Parse_Byte) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<predigits> (V1556) (let Result (let Parse_shen.<digits> (shen.<digits> V1556) (if (not (= (fail) Parse_shen.<digits>)) (shen.pair (hd Parse_shen.<digits>) (shen.hdtl Parse_shen.<digits>)) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1556) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
+(defun shen.<predigits> (V1563) (let Result (let Parse_shen.<digits> (shen.<digits> V1563) (if (not (= (fail) Parse_shen.<digits>)) (shen.pair (hd Parse_shen.<digits>) (shen.hdtl Parse_shen.<digits>)) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1563) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) ()) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
 
-(defun shen.<postdigits> (V1561) (let Result (let Parse_shen.<digits> (shen.<digits> V1561) (if (not (= (fail) Parse_shen.<digits>)) (shen.pair (hd Parse_shen.<digits>) (shen.hdtl Parse_shen.<digits>)) (fail))) (if (= Result (fail)) (fail) Result)))
+(defun shen.<postdigits> (V1568) (let Result (let Parse_shen.<digits> (shen.<digits> V1568) (if (not (= (fail) Parse_shen.<digits>)) (shen.pair (hd Parse_shen.<digits>) (shen.hdtl Parse_shen.<digits>)) (fail))) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<digits> (V1566) (let Result (let Parse_shen.<digit> (shen.<digit> V1566) (if (not (= (fail) Parse_shen.<digit>)) (let Parse_shen.<digits> (shen.<digits> Parse_shen.<digit>) (if (not (= (fail) Parse_shen.<digits>)) (shen.pair (hd Parse_shen.<digits>) (cons (shen.hdtl Parse_shen.<digit>) (shen.hdtl Parse_shen.<digits>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<digit> (shen.<digit> V1566) (if (not (= (fail) Parse_shen.<digit>)) (shen.pair (hd Parse_shen.<digit>) (cons (shen.hdtl Parse_shen.<digit>) ())) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
+(defun shen.<digits> (V1573) (let Result (let Parse_shen.<digit> (shen.<digit> V1573) (if (not (= (fail) Parse_shen.<digit>)) (let Parse_shen.<digits> (shen.<digits> Parse_shen.<digit>) (if (not (= (fail) Parse_shen.<digits>)) (shen.pair (hd Parse_shen.<digits>) (cons (shen.hdtl Parse_shen.<digit>) (shen.hdtl Parse_shen.<digits>))) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<digit> (shen.<digit> V1573) (if (not (= (fail) Parse_shen.<digit>)) (shen.pair (hd Parse_shen.<digit>) (cons (shen.hdtl Parse_shen.<digit>) ())) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
 
-(defun shen.<digit> (V1571) (let Result (if (cons? (hd V1571)) (let Parse_X (hd (hd V1571)) (if (shen.numbyte? Parse_X) (shen.pair (hd (shen.pair (tl (hd V1571)) (shen.hdtl V1571))) (shen.byte->digit Parse_X)) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<digit> (V1578) (let Result (if (cons? (hd V1578)) (let Parse_X (hd (hd V1578)) (if (shen.numbyte? Parse_X) (shen.pair (hd (shen.pair (tl (hd V1578)) (shen.hdtl V1578))) (shen.byte->digit Parse_X)) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.byte->digit (V1572) (cond ((= 48 V1572) 0) ((= 49 V1572) 1) ((= 50 V1572) 2) ((= 51 V1572) 3) ((= 52 V1572) 4) ((= 53 V1572) 5) ((= 54 V1572) 6) ((= 55 V1572) 7) ((= 56 V1572) 8) ((= 57 V1572) 9) (true (shen.sys-error shen.byte->digit))))
+(defun shen.byte->digit (V1579) (cond ((= 48 V1579) 0) ((= 49 V1579) 1) ((= 50 V1579) 2) ((= 51 V1579) 3) ((= 52 V1579) 4) ((= 53 V1579) 5) ((= 54 V1579) 6) ((= 55 V1579) 7) ((= 56 V1579) 8) ((= 57 V1579) 9) (true (shen.sys-error shen.byte->digit))))
 
-(defun shen.pre (V1575 V1576) (cond ((= () V1575) 0) ((cons? V1575) (+ (* (shen.expt 10 V1576) (hd V1575)) (shen.pre (tl V1575) (+ V1576 1)))) (true (shen.sys-error shen.pre))))
+(defun shen.pre (V1582 V1583) (cond ((= () V1582) 0) ((cons? V1582) (+ (* (shen.expt 10 V1583) (hd V1582)) (shen.pre (tl V1582) (+ V1583 1)))) (true (shen.sys-error shen.pre))))
 
-(defun shen.post (V1579 V1580) (cond ((= () V1579) 0) ((cons? V1579) (+ (* (shen.expt 10 (- 0 V1580)) (hd V1579)) (shen.post (tl V1579) (+ V1580 1)))) (true (shen.sys-error shen.post))))
+(defun shen.post (V1586 V1587) (cond ((= () V1586) 0) ((cons? V1586) (+ (* (shen.expt 10 (- 0 V1587)) (hd V1586)) (shen.post (tl V1586) (+ V1587 1)))) (true (shen.sys-error shen.post))))
 
-(defun shen.expt (V1583 V1584) (cond ((= 0 V1584) 1) ((> V1584 0) (* V1583 (shen.expt V1583 (- V1584 1)))) (true (* 1 (/ (shen.expt V1583 (+ V1584 1)) V1583)))))
+(defun shen.expt (V1590 V1591) (cond ((= 0 V1591) 1) ((> V1591 0) (* V1590 (shen.expt V1590 (- V1591 1)))) (true (* 1 (/ (shen.expt V1590 (+ V1591 1)) V1590)))))
 
-(defun shen.<st_input1> (V1589) (let Result (let Parse_shen.<st_input> (shen.<st_input> V1589) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (shen.hdtl Parse_shen.<st_input>)) (fail))) (if (= Result (fail)) (fail) Result)))
+(defun shen.<st_input1> (V1596) (let Result (let Parse_shen.<st_input> (shen.<st_input> V1596) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (shen.hdtl Parse_shen.<st_input>)) (fail))) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<st_input2> (V1594) (let Result (let Parse_shen.<st_input> (shen.<st_input> V1594) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (shen.hdtl Parse_shen.<st_input>)) (fail))) (if (= Result (fail)) (fail) Result)))
+(defun shen.<st_input2> (V1601) (let Result (let Parse_shen.<st_input> (shen.<st_input> V1601) (if (not (= (fail) Parse_shen.<st_input>)) (shen.pair (hd Parse_shen.<st_input>) (shen.hdtl Parse_shen.<st_input>)) (fail))) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<comment> (V1599) (let Result (let Parse_shen.<singleline> (shen.<singleline> V1599) (if (not (= (fail) Parse_shen.<singleline>)) (shen.pair (hd Parse_shen.<singleline>) shen.skip) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<multiline> (shen.<multiline> V1599) (if (not (= (fail) Parse_shen.<multiline>)) (shen.pair (hd Parse_shen.<multiline>) shen.skip) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
+(defun shen.<comment> (V1606) (let Result (let Parse_shen.<singleline> (shen.<singleline> V1606) (if (not (= (fail) Parse_shen.<singleline>)) (shen.pair (hd Parse_shen.<singleline>) shen.skip) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<multiline> (shen.<multiline> V1606) (if (not (= (fail) Parse_shen.<multiline>)) (shen.pair (hd Parse_shen.<multiline>) shen.skip) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
 
-(defun shen.<singleline> (V1604) (let Result (let Parse_shen.<backslash> (shen.<backslash> V1604) (if (not (= (fail) Parse_shen.<backslash>)) (let Parse_shen.<backslash> (shen.<backslash> Parse_shen.<backslash>) (if (not (= (fail) Parse_shen.<backslash>)) (let Parse_shen.<anysingle> (shen.<anysingle> Parse_shen.<backslash>) (if (not (= (fail) Parse_shen.<anysingle>)) (let Parse_shen.<return> (shen.<return> Parse_shen.<anysingle>) (if (not (= (fail) Parse_shen.<return>)) (shen.pair (hd Parse_shen.<return>) shen.skip) (fail))) (fail))) (fail))) (fail))) (if (= Result (fail)) (fail) Result)))
+(defun shen.<singleline> (V1611) (let Result (let Parse_shen.<backslash> (shen.<backslash> V1611) (if (not (= (fail) Parse_shen.<backslash>)) (let Parse_shen.<backslash> (shen.<backslash> Parse_shen.<backslash>) (if (not (= (fail) Parse_shen.<backslash>)) (let Parse_shen.<anysingle> (shen.<anysingle> Parse_shen.<backslash>) (if (not (= (fail) Parse_shen.<anysingle>)) (let Parse_shen.<return> (shen.<return> Parse_shen.<anysingle>) (if (not (= (fail) Parse_shen.<return>)) (shen.pair (hd Parse_shen.<return>) shen.skip) (fail))) (fail))) (fail))) (fail))) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<backslash> (V1609) (let Result (if (and (cons? (hd V1609)) (= 92 (hd (hd V1609)))) (shen.pair (hd (shen.pair (tl (hd V1609)) (shen.hdtl V1609))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<backslash> (V1616) (let Result (if (and (cons? (hd V1616)) (= 92 (hd (hd V1616)))) (shen.pair (hd (shen.pair (tl (hd V1616)) (shen.hdtl V1616))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<anysingle> (V1614) (let Result (let Parse_shen.<non-return> (shen.<non-return> V1614) (if (not (= (fail) Parse_shen.<non-return>)) (let Parse_shen.<anysingle> (shen.<anysingle> Parse_shen.<non-return>) (if (not (= (fail) Parse_shen.<anysingle>)) (shen.pair (hd Parse_shen.<anysingle>) shen.skip) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1614) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) shen.skip) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
+(defun shen.<anysingle> (V1621) (let Result (let Parse_shen.<non-return> (shen.<non-return> V1621) (if (not (= (fail) Parse_shen.<non-return>)) (let Parse_shen.<anysingle> (shen.<anysingle> Parse_shen.<non-return>) (if (not (= (fail) Parse_shen.<anysingle>)) (shen.pair (hd Parse_shen.<anysingle>) shen.skip) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_<e> (<e> V1621) (if (not (= (fail) Parse_<e>)) (shen.pair (hd Parse_<e>) shen.skip) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
 
-(defun shen.<non-return> (V1619) (let Result (if (cons? (hd V1619)) (let Parse_X (hd (hd V1619)) (if (not (element? Parse_X (cons 10 (cons 13 ())))) (shen.pair (hd (shen.pair (tl (hd V1619)) (shen.hdtl V1619))) shen.skip) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<non-return> (V1626) (let Result (if (cons? (hd V1626)) (let Parse_X (hd (hd V1626)) (if (not (element? Parse_X (cons 10 (cons 13 ())))) (shen.pair (hd (shen.pair (tl (hd V1626)) (shen.hdtl V1626))) shen.skip) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<return> (V1624) (let Result (if (cons? (hd V1624)) (let Parse_X (hd (hd V1624)) (if (element? Parse_X (cons 10 (cons 13 ()))) (shen.pair (hd (shen.pair (tl (hd V1624)) (shen.hdtl V1624))) shen.skip) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<return> (V1631) (let Result (if (cons? (hd V1631)) (let Parse_X (hd (hd V1631)) (if (element? Parse_X (cons 10 (cons 13 ()))) (shen.pair (hd (shen.pair (tl (hd V1631)) (shen.hdtl V1631))) shen.skip) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<multiline> (V1629) (let Result (let Parse_shen.<backslash> (shen.<backslash> V1629) (if (not (= (fail) Parse_shen.<backslash>)) (let Parse_shen.<times> (shen.<times> Parse_shen.<backslash>) (if (not (= (fail) Parse_shen.<times>)) (let Parse_shen.<anymulti> (shen.<anymulti> Parse_shen.<times>) (if (not (= (fail) Parse_shen.<anymulti>)) (shen.pair (hd Parse_shen.<anymulti>) shen.skip) (fail))) (fail))) (fail))) (if (= Result (fail)) (fail) Result)))
+(defun shen.<multiline> (V1636) (let Result (let Parse_shen.<backslash> (shen.<backslash> V1636) (if (not (= (fail) Parse_shen.<backslash>)) (let Parse_shen.<times> (shen.<times> Parse_shen.<backslash>) (if (not (= (fail) Parse_shen.<times>)) (let Parse_shen.<anymulti> (shen.<anymulti> Parse_shen.<times>) (if (not (= (fail) Parse_shen.<anymulti>)) (shen.pair (hd Parse_shen.<anymulti>) shen.skip) (fail))) (fail))) (fail))) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<times> (V1634) (let Result (if (and (cons? (hd V1634)) (= 42 (hd (hd V1634)))) (shen.pair (hd (shen.pair (tl (hd V1634)) (shen.hdtl V1634))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<times> (V1641) (let Result (if (and (cons? (hd V1641)) (= 42 (hd (hd V1641)))) (shen.pair (hd (shen.pair (tl (hd V1641)) (shen.hdtl V1641))) shen.skip) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.<anymulti> (V1639) (let Result (let Parse_shen.<comment> (shen.<comment> V1639) (if (not (= (fail) Parse_shen.<comment>)) (let Parse_shen.<anymulti> (shen.<anymulti> Parse_shen.<comment>) (if (not (= (fail) Parse_shen.<anymulti>)) (shen.pair (hd Parse_shen.<anymulti>) shen.skip) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<times> (shen.<times> V1639) (if (not (= (fail) Parse_shen.<times>)) (let Parse_shen.<backslash> (shen.<backslash> Parse_shen.<times>) (if (not (= (fail) Parse_shen.<backslash>)) (shen.pair (hd Parse_shen.<backslash>) shen.skip) (fail))) (fail))) (if (= Result (fail)) (let Result (if (cons? (hd V1639)) (let Parse_X (hd (hd V1639)) (let Parse_shen.<anymulti> (shen.<anymulti> (shen.pair (tl (hd V1639)) (shen.hdtl V1639))) (if (not (= (fail) Parse_shen.<anymulti>)) (shen.pair (hd Parse_shen.<anymulti>) shen.skip) (fail)))) (fail)) (if (= Result (fail)) (fail) Result)) Result)) Result)))
+(defun shen.<anymulti> (V1646) (let Result (let Parse_shen.<comment> (shen.<comment> V1646) (if (not (= (fail) Parse_shen.<comment>)) (let Parse_shen.<anymulti> (shen.<anymulti> Parse_shen.<comment>) (if (not (= (fail) Parse_shen.<anymulti>)) (shen.pair (hd Parse_shen.<anymulti>) shen.skip) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<times> (shen.<times> V1646) (if (not (= (fail) Parse_shen.<times>)) (let Parse_shen.<backslash> (shen.<backslash> Parse_shen.<times>) (if (not (= (fail) Parse_shen.<backslash>)) (shen.pair (hd Parse_shen.<backslash>) shen.skip) (fail))) (fail))) (if (= Result (fail)) (let Result (if (cons? (hd V1646)) (let Parse_X (hd (hd V1646)) (let Parse_shen.<anymulti> (shen.<anymulti> (shen.pair (tl (hd V1646)) (shen.hdtl V1646))) (if (not (= (fail) Parse_shen.<anymulti>)) (shen.pair (hd Parse_shen.<anymulti>) shen.skip) (fail)))) (fail)) (if (= Result (fail)) (fail) Result)) Result)) Result)))
 
-(defun shen.<whitespaces> (V1644) (let Result (let Parse_shen.<whitespace> (shen.<whitespace> V1644) (if (not (= (fail) Parse_shen.<whitespace>)) (let Parse_shen.<whitespaces> (shen.<whitespaces> Parse_shen.<whitespace>) (if (not (= (fail) Parse_shen.<whitespaces>)) (shen.pair (hd Parse_shen.<whitespaces>) shen.skip) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<whitespace> (shen.<whitespace> V1644) (if (not (= (fail) Parse_shen.<whitespace>)) (shen.pair (hd Parse_shen.<whitespace>) shen.skip) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
+(defun shen.<whitespaces> (V1651) (let Result (let Parse_shen.<whitespace> (shen.<whitespace> V1651) (if (not (= (fail) Parse_shen.<whitespace>)) (let Parse_shen.<whitespaces> (shen.<whitespaces> Parse_shen.<whitespace>) (if (not (= (fail) Parse_shen.<whitespaces>)) (shen.pair (hd Parse_shen.<whitespaces>) shen.skip) (fail))) (fail))) (if (= Result (fail)) (let Result (let Parse_shen.<whitespace> (shen.<whitespace> V1651) (if (not (= (fail) Parse_shen.<whitespace>)) (shen.pair (hd Parse_shen.<whitespace>) shen.skip) (fail))) (if (= Result (fail)) (fail) Result)) Result)))
 
-(defun shen.<whitespace> (V1649) (let Result (if (cons? (hd V1649)) (let Parse_X (hd (hd V1649)) (if (let Parse_Case Parse_X (or (= Parse_Case 32) (or (= Parse_Case 13) (or (= Parse_Case 10) (= Parse_Case 9))))) (shen.pair (hd (shen.pair (tl (hd V1649)) (shen.hdtl V1649))) shen.skip) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
+(defun shen.<whitespace> (V1656) (let Result (if (cons? (hd V1656)) (let Parse_X (hd (hd V1656)) (if (let Parse_Case Parse_X (or (= Parse_Case 32) (or (= Parse_Case 13) (or (= Parse_Case 10) (= Parse_Case 9))))) (shen.pair (hd (shen.pair (tl (hd V1656)) (shen.hdtl V1656))) shen.skip) (fail))) (fail)) (if (= Result (fail)) (fail) Result)))
 
-(defun shen.cons_form (V1650) (cond ((= () V1650) ()) ((and (cons? V1650) (and (cons? (tl V1650)) (and (cons? (tl (tl V1650))) (and (= () (tl (tl (tl V1650)))) (= (hd (tl V1650)) bar!))))) (cons cons (cons (hd V1650) (tl (tl V1650))))) ((cons? V1650) (cons cons (cons (hd V1650) (cons (shen.cons_form (tl V1650)) ())))) (true (shen.sys-error shen.cons_form))))
+(defun shen.cons_form (V1657) (cond ((= () V1657) ()) ((and (cons? V1657) (and (cons? (tl V1657)) (and (cons? (tl (tl V1657))) (and (= () (tl (tl (tl V1657)))) (= (hd (tl V1657)) bar!))))) (cons cons (cons (hd V1657) (tl (tl V1657))))) ((cons? V1657) (cons cons (cons (hd V1657) (cons (shen.cons_form (tl V1657)) ())))) (true (shen.sys-error shen.cons_form))))
 
-(defun shen.package-macro (V1653 V1654) (cond ((and (cons? V1653) (and (= $ (hd V1653)) (and (cons? (tl V1653)) (= () (tl (tl V1653)))))) (append (explode (hd (tl V1653))) V1654)) ((and (cons? V1653) (and (= package (hd V1653)) (and (cons? (tl V1653)) (and (= null (hd (tl V1653))) (cons? (tl (tl V1653))))))) (append (tl (tl (tl V1653))) V1654)) ((and (cons? V1653) (and (= package (hd V1653)) (and (cons? (tl V1653)) (cons? (tl (tl V1653)))))) (let ListofExceptions (shen.eval-without-macros (hd (tl (tl V1653)))) (let Record (shen.record-exceptions ListofExceptions (hd (tl V1653))) (let PackageNameDot (intern (cn (str (hd (tl V1653))) ".")) (append (shen.packageh PackageNameDot ListofExceptions (tl (tl (tl V1653)))) V1654))))) (true (cons V1653 V1654))))
+(defun shen.package-macro (V1660 V1661) (cond ((and (cons? V1660) (and (= $ (hd V1660)) (and (cons? (tl V1660)) (= () (tl (tl V1660)))))) (append (explode (hd (tl V1660))) V1661)) ((and (cons? V1660) (and (= package (hd V1660)) (and (cons? (tl V1660)) (and (= null (hd (tl V1660))) (cons? (tl (tl V1660))))))) (append (tl (tl (tl V1660))) V1661)) ((and (cons? V1660) (and (= package (hd V1660)) (and (cons? (tl V1660)) (cons? (tl (tl V1660)))))) (let ListofExceptions (shen.eval-without-macros (hd (tl (tl V1660)))) (let Record (shen.record-exceptions ListofExceptions (hd (tl V1660))) (let PackageNameDot (intern (cn (str (hd (tl V1660))) ".")) (append (shen.packageh PackageNameDot ListofExceptions (tl (tl (tl V1660)))) V1661))))) (true (cons V1660 V1661))))
 
-(defun shen.record-exceptions (V1655 V1656) (let CurrExceptions (trap-error (get V1656 shen.external-symbols (value *property-vector*)) (lambda E ())) (let AllExceptions (union V1655 CurrExceptions) (put V1656 shen.external-symbols AllExceptions (value *property-vector*)))))
+(defun shen.record-exceptions (V1662 V1663) (let CurrExceptions (trap-error (get V1663 shen.external-symbols (value *property-vector*)) (lambda E ())) (let AllExceptions (union V1662 CurrExceptions) (put V1663 shen.external-symbols AllExceptions (value *property-vector*)))))
 
-(defun shen.packageh (V1665 V1666 V1667) (cond ((cons? V1667) (cons (shen.packageh V1665 V1666 (hd V1667)) (shen.packageh V1665 V1666 (tl V1667)))) ((or (shen.sysfunc? V1667) (or (variable? V1667) (or (element? V1667 V1666) (or (shen.doubleunderline? V1667) (shen.singleunderline? V1667))))) V1667) ((and (symbol? V1667) (not (shen.prefix? (cons "s" (cons "h" (cons "e" (cons "n" (cons "." ()))))) (explode V1667)))) (concat V1665 V1667)) (true V1667)))
+(defun shen.packageh (V1672 V1673 V1674) (cond ((cons? V1674) (cons (shen.packageh V1672 V1673 (hd V1674)) (shen.packageh V1672 V1673 (tl V1674)))) ((or (shen.sysfunc? V1674) (or (variable? V1674) (or (element? V1674 V1673) (or (shen.doubleunderline? V1674) (shen.singleunderline? V1674))))) V1674) ((and (symbol? V1674) (not (shen.prefix? (cons "s" (cons "h" (cons "e" (cons "n" (cons "." ()))))) (explode V1674)))) (concat V1672 V1674)) (true V1674)))