shen-ruby 0.1.0

data/shen/release/benchmarks/br.shen

@@ -0,0 +1,13 @@
+(defcc <br> 
+    40 <br> 41 <br$> := ok;
+    <item> <br> := ok;
+    <e> := ok;) 
+
+(defcc <br$> 
+    <br> := ok;) 
+
+(defcc <item> 
+    -*- := (if (element? -*- [40 41]) 
+            (fail) 
+            ok);) 
+

data/shen/release/benchmarks/einstein.shen

@@ -0,0 +1,33 @@
+(defprolog einsteins_riddle
+  Fish_Owner <-- (einstein Houses Fish_Owner);)
+
+(defprolog einstein
+   Houses Fish_Owner <-- (unify Houses [[house norwegian _ _ _ _] _ [house _ _ _ milk _] _ _])
+                         (member [house brit _ _ _ red] Houses)
+                         (member [house swede dog _ _ _] Houses)
+                         (member [house dane _ _ tea _] Houses)
+                         (iright [house _ _ _ _ green] [house _ _ _ _ white] Houses)
+                         (member [house _ _ _ coffee green] Houses)
+                         (member [house _ bird pallmall _ _] Houses)
+                         (member [house _ _ dunhill _ yellow] Houses)
+                         (next_to [house _ _ dunhill _ _] [house _ horse _ _ _] Houses)
+                         (member [house _ _ _ milk _] Houses)
+                         (next_to [house _ _ marlboro _ _] [house _ cat _ _ _] Houses)
+                         (next_to [house _ _ marlboro _ _] [house _ _ _ water _] Houses)
+                         (member [house _ _ winfield beer _] Houses)
+                         (member [house german _ rothmans _ _] Houses)
+                         (next_to [house norwegian _ _ _ _] [house _ _ _ _ blue] Houses)
+                         (unify Houses [[house norwegian _ _ _ _] _ [house _ _ _ milk _] _ _])
+                         (member [house Fish_Owner fish _ _ _] Houses);)
+
+(defprolog member
+ X [X | _] <--;
+ X [_ | Z] <-- (member X Z);)
+
+(defprolog next_to
+  X Y List <-- (iright X Y List);
+  X Y List <-- (iright Y X List);)
+
+(defprolog iright
+  L R [L | [R | _]] <--;
+  L R [_ | Rest] <-- (iright L R Rest);)

data/shen/release/benchmarks/interpreter.shen

@@ -0,0 +1,219 @@
+(datatype num
+
+ ____________________________________
+ (number? X)  : verified >> X : number;)
+
+(datatype primitive_object
+
+      if (variable? X)
+      _______________
+      X : variable;
+
+      X : variable;
+      _____________
+      X : primitive_object;
+     
+      X : symbol;
+      ___________
+      X : primitive_object;
+
+      X : string;
+      ___________
+      X : primitive_object;
+
+      X : boolean;
+      ___________
+      X : primitive_object;
+
+      X : number;
+      ___________
+      X : primitive_object;
+
+      _____________________
+      [] : primitive_object;)
+
+(datatype pattern
+
+   X : primitive_object;
+   ___________
+   X : pattern;
+      
+   P1 : pattern; P2 : pattern;
+   ===========================
+   [cons P1 P2] : pattern;
+    
+   P1 : pattern; P2 : pattern;
+   ===========================
+   [@p P1 P2] : pattern;)
+
+  (datatype l_formula
+
+   X : pattern;
+   _____________
+   X : l_formula;
+      
+   X : l_formula; Y : l_formula; Z : l_formula;
+   =================================
+   [if X Y Z] : l_formula;
+
+   X : variable; Y : l_formula; Z : l_formula;
+   ================================
+   [let X Y Z] : l_formula;
+      
+   X : l_formula; Y : l_formula;
+   ======================
+   [cons X Y] : l_formula;
+      
+   X : l_formula; Y : l_formula;
+   ======================
+   [@p X Y] : l_formula;
+   
+   X : l_formula; Y : l_formula;
+   ======================
+   [where X Y] : l_formula;
+      
+   X : l_formula; Y : l_formula;
+   ======================
+   [= X Y] : l_formula;
+      
+   X : l_formula; Y : l_formula;
+   ======================
+   [X Y] : l_formula;
+      
+   Xn : (list l_formula);
+   ===================
+   [cases | Xn] : l_formula;
+      
+   P : pattern; X : l_formula;
+   ===========================
+   [/. P X] : l_formula;)
+
+(define l_interpreter
+  {A --> B}
+  _ -> (read_eval_print_loop (output "~%L interpreter ~%~%~%~%l-interp --> ~A~%" 
+                                     (normal_form (input+ : l_formula)))))
+
+(define read_eval_print_loop
+  {string --> A}
+  _ -> (read_eval_print_loop 
+           (output "l-interp --> ~A~%"
+              (normal_form (input+ : l_formula))))) 
+
+(define normal_form
+  {l_formula --> l_formula}
+   X -> (fix ==> X))                 
+    
+(define ==>
+   {l_formula --> l_formula}
+   [= X Y] -> (let X* (normal_form X) 
+                   (let Y* (normal_form Y) 
+                        (if (or (eval_error? X*) (eval_error? Y*))
+                            "error!"
+                            (if (= X* Y*) true false))))
+   [[/. P X] Y] -> (let Match (match P (normal_form Y))
+                        (if (no_match? Match) 
+                            "no match"
+                            (sub Match X))) 
+   [if X Y Z] -> (let X* (normal_form X)
+                      (if (= X* true)
+                          Y
+                          (if (= X* false)
+                              Z
+                              "error!")))
+   [let X Y Z] -> [[/. X Z] Y]
+   [@p X Y] -> (let X* (normal_form X)
+                    (let Y* (normal_form Y)
+                         (if (or (eval_error? X*) (eval_error? Y*))
+                             "error!"
+                             [@p X* Y*])))
+   [cons X Y] -> (let X* (normal_form X)
+                      (let Y* (normal_form Y)
+                           (if (or (eval_error? X*) (eval_error? Y*))
+                               "error!"
+                               [cons X* Y*])))
+   [++ X] -> (successor (normal_form X))
+   [-- X] -> (predecessor (normal_form X))
+   \*[cases X1 | Xn] -> (let Case1 (normal_form X1)
+                           (if (= Case1 "no match")
+                               [cases | Xn]
+                               Case1))
+   [cases] -> "error!"            
+   [where X Y] -> [if X Y "no match"]
+   [y-combinator [/. X Y]] -> (replace X [y-combinator [/. X Y]] Y)
+   [X Y] -> (let X* (normal_form X)
+               (let Y* (normal_form Y)
+                  (if (or (eval_error? X*) (eval_error? Y*))
+                      "error!"
+                      [X* Y*])))*\
+    X -> X)
+
+(define eval_error?
+  {l_formula --> boolean}
+   "error!" -> true
+   "no match" -> true
+   _ -> false)  
+
+(define successor
+  {A --> l_formula}
+  X -> (+ 1 X) where (number? X)
+  _ -> "error!")
+
+(define predecessor
+  {A --> l_formula}
+  X -> (- X 1) where (number? X)
+  _ -> "error!")
+
+\* (spy +) *\
+
+(define sub
+  {[(pattern * l_formula)] --> l_formula --> l_formula}
+   [] X -> X
+   [(@p Var Val) | Assoc] X -> (sub Assoc (replace Var Val X)))
+
+(define match
+   {pattern --> l_formula --> (list (pattern * l_formula))}
+    P X -> [] where (== P X)
+    P X -> [(@p P X)]      where (variable? P)
+    [cons P1 P2] [cons X Y] -> (let Match1 (match P1 X)
+                                    (if (no_match? Match1)
+                                        Match1
+                                        (let Match2 (match P2 Y)
+                                            (if (no_match? Match2)
+                                                Match2
+						(append Match1 Match2)))))
+    [@p P1 P2] [@p X Y] -> (let Match1 (match P1 X)
+                                    (if (no_match? Match1)
+                                        Match1
+                                        (let Match2 (match P2 Y)
+                                            (if (no_match? Match2)
+                                                Match2
+						(append Match1 Match2)))))
+
+    _ _ -> [(@p no matching)])
+      
+(define no_match?
+  {[(pattern * l_formula)] --> boolean}
+   [(@p no matching)] -> true
+   _ -> false)
+
+(define replace
+   {pattern --> l_formula --> l_formula --> l_formula}
+    V W [let V* X Y] -> [let V* X Y]  where (== V V*)
+    X Y X -> Y
+    V W [= X Y] -> [= (replace V W X) (replace V W Y)]
+    V W [/. P X] -> [/. P (replace V W X)] 		where (free? V P)
+    V W [if X Y Z] -> [if (replace V W X) (replace V W Y) (replace V W Z)]
+    V W [let X Y Z] -> [let X (replace V W Y) (replace V W Z)]
+    V W [@p X Y] -> [@p (replace V W X) (replace V W Y)]
+    V W [cons X Y] -> [cons (replace V W X) (replace V W Y)]
+    V W [cases | Xn] -> [cases | (map (/. Xi (replace V W Xi)) Xn)]
+    V W [where X Y] -> [where (replace V W X) (replace V W Y)]
+    V W [X Y] -> [(replace V W X) (replace V W Y)] 
+    _ _ X -> X) 	
+
+(define free?
+  {pattern --> pattern --> boolean}
+   P P -> false 
+   P [cons P1 P2] -> (and (free? P P1) (free? P P2))
+   P [@p P1 P2] -> (and (free? P P1) (free? P P2))
+   _ _ -> true)

data/shen/release/benchmarks/powerset.shen

@@ -0,0 +1,10 @@
+(define powerset
+   [] -> [[]]
+   [X | Y] -> (let Powerset (powerset Y)
+                (append (cons-X-to-each-set X Powerset) Powerset)))
+
+(define cons-X-to-each-set  
+    _ [ ] -> [ ]  
+    X [Y | Z] -> [[X | Y] | (cons-X-to-each-set X Z)])
+
+

data/shen/release/benchmarks/prime.shen

@@ -0,0 +1,10 @@
+(define prime? 
+  X -> (prime* X (sqrt X) 2))
+
+(define prime*
+  X Max Div -> false	where (integer? (/ X Div))				
+  X Max Div -> true	where (> Div Max)			
+  X Max Div -> (prime* X Max (+ 1 Div)))
+
+ 
+

data/shen/release/benchmarks/short.shen

@@ -0,0 +1,129 @@
+(define l_interpreter
+  {A --> B}
+  _ -> (read_eval_print_loop (output "~%L interpreter ~%~%~%~%l-interp --> ~A~%" 
+                                     (normal_form (input+ : l_formula)))))
+
+(define read_eval_print_loop
+  {string --> A}
+  _ -> (read_eval_print_loop 
+           (output "l-interp --> ~A~%"
+              (normal_form (input+ : l_formula))))) 
+
+(define normal_form
+  {l_formula --> l_formula}
+   X -> (fix ==> X))                 
+    
+(define ==>
+   {l_formula --> l_formula}
+   [= X Y] -> (let X* (normal_form X) 
+                   (let Y* (normal_form Y) 
+                        (if (or (eval_error? X*) (eval_error? Y*))
+                            "error!"
+                            (if (= X* Y*) true false))))
+   [[/. P X] Y] -> (let Match (match P (normal_form Y))
+                        (if (no_match? Match) 
+                            "no match"
+                            (sub Match X))) 
+   [if X Y Z] -> (let X* (normal_form X)
+                      (if (= X* true)
+                          Y
+                          (if (= X* false)
+                              Z
+                              "error!")))
+   [let X Y Z] -> [[/. X Z] Y]
+   [@p X Y] -> (let X* (normal_form X)
+                    (let Y* (normal_form Y)
+                         (if (or (eval_error? X*) (eval_error? Y*))
+                             "error!"
+                             [@p X* Y*])))
+   [cons X Y] -> (let X* (normal_form X)
+                      (let Y* (normal_form Y)
+                           (if (or (eval_error? X*) (eval_error? Y*))
+                               "error!"
+                               [cons X* Y*])))
+   [++ X] -> (successor (normal_form X))
+   [-- X] -> (predecessor (normal_form X))
+   \*[cases X1 | Xn] -> (let Case1 (normal_form X1)
+                           (if (= Case1 "no match")
+                               [cases | Xn]
+                               Case1))
+   [cases] -> "error!"            
+   [where X Y] -> [if X Y "no match"]
+   [y-combinator [/. X Y]] -> (replace X [y-combinator [/. X Y]] Y)
+   [X Y] -> (let X* (normal_form X)
+               (let Y* (normal_form Y)
+                  (if (or (eval_error? X*) (eval_error? Y*))
+                      "error!"
+                      [X* Y*])))*\
+    X -> X)
+
+(define eval_error?
+  {l_formula --> boolean}
+   "error!" -> true
+   "no match" -> true
+   _ -> false)  
+
+(define successor
+  {A --> l_formula}
+  X -> (+ 1 X) where (number? X)
+  _ -> "error!")
+
+(define predecessor
+  {A --> l_formula}
+  X -> (- X 1) where (number? X)
+  _ -> "error!")
+
+\* (spy +) *\
+
+(define sub
+  {[(pattern * l_formula)] --> l_formula --> l_formula}
+   [] X -> X
+   [(@p Var Val) | Assoc] X -> (sub Assoc (replace Var Val X)))
+
+(define match
+   {pattern --> l_formula --> (list (pattern * l_formula))}
+    P X -> [] where (== P X)
+    P X -> [(@p P X)]      where (variable? P)
+    [cons P1 P2] [cons X Y] -> (let Match1 (match P1 X)
+                                    (if (no_match? Match1)
+                                        Match1
+                                        (let Match2 (match P2 Y)
+                                            (if (no_match? Match2)
+                                                Match2
+						(append Match1 Match2)))))
+    [@p P1 P2] [@p X Y] -> (let Match1 (match P1 X)
+                                    (if (no_match? Match1)
+                                        Match1
+                                        (let Match2 (match P2 Y)
+                                            (if (no_match? Match2)
+                                                Match2
+						(append Match1 Match2)))))
+
+    _ _ -> [(@p no matching)])
+      
+(define no_match?
+  {[(pattern * l_formula)] --> boolean}
+   [(@p no matching)] -> true
+   _ -> false)
+
+(define replace
+   {pattern --> l_formula --> l_formula --> l_formula}
+    V W [let V* X Y] -> [let V* X Y]  where (== V V*)
+    X Y X -> Y
+    V W [= X Y] -> [= (replace V W X) (replace V W Y)]
+    V W [/. P X] -> [/. P (replace V W X)] 		where (free? V P)
+    V W [if X Y Z] -> [if (replace V W X) (replace V W Y) (replace V W Z)]
+    V W [let X Y Z] -> [let X (replace V W Y) (replace V W Z)]
+    V W [@p X Y] -> [@p (replace V W X) (replace V W Y)]
+    \* V W [cons X Y] -> [cons (replace V W X) (replace V W Y)]
+    V W [cases | Xn] -> [cases | (map (/. Xi (replace V W Xi)) Xn)]
+    V W [where X Y] -> [where (replace V W X) (replace V W Y)]
+    V W [X Y] -> [(replace V W X) (replace V W Y)] *\
+    _ _ X -> X) 	
+
+(define free?
+  {pattern --> pattern --> boolean}
+   P P -> false 
+   P [cons P1 P2] -> (and (free? P P1) (free? P P2))
+   P [@p P1 P2] -> (and (free? P P1) (free? P P2))
+   _ _ -> true)

data/shen/release/benchmarks/text.txt

@@ -0,0 +1,68 @@
+"Terms of Use
+By 'derivative work' we understand it as defined by the US copyright law. We emphasise the following passage from the copyright act of the USA
+
+Making minor changes or additions of little substance to a preexisting work will not qualify the work as a new version for copyright purposes.
+
+By 'copyright holder' we understand Dr Mark Tarver, or, in the event of his decease, the committee appointed under the terms of his will to administer his intellectual estate.
+
+By 'the software' we understand Shen and all the code used to implement it. We include both the original source code written in Shen, and the code derived from this code through compilation to other languages.
+
+By 'Shen standard' we understand the latest standards for Shen laid down in Lambda Associates by the copyright holder.
+
+By 'the user' we understand any person or group of persons, whether organised in a commercial company, cooperative or institution or not, that use the software. The use of 'he' and 'his' to refer to the user follows English usage, but makes no special assumptions about gender or plurality.
+
+The License
+
+The user is free to produce commercial applications with the software, to distribute these applications in source or binary form, and to charge monies for them as he sees fit and in concordance with the laws of the land subject to the following license.
+
+1. The license applies to all the software and all derived software and must appear on such.
+
+2. It is illegal to distribute the software without this license attached to it and use of the software implies agreement with the license as such. It is illegal for anyone who is not the copyright holder to tamper with or change the license.
+
+3. Neither the names of Lambda Associates or the copyright holder may be used to endorse or promote products built using the software without specific prior written permission from the copyright holder.
+
+4. That possession of this license does not confer on the copyright holder any special contractual obligation towards the user. That in no event shall the copyright holder be liable for any direct, indirect, incidental, special, exemplary or consequential damages (including but not limited to procurement of substitute goods or services, loss of use, data, or profits; or business interruption), however caused and on any theory of liability, whether in contract, strict liability or tort (including negligence) arising in any way out of the use of the software, even if advised of the possibility of such damage. 
+
+5. It is permitted for the user to change the software, for the purpose of improving performance, correcting an error, or porting to a new platform, and distribute the modified version of Shen (hereafter the modified version) provided the resulting program conforms in all respects to the Shen standard and is issued under that title. The user must it clear with his distribution that he/she is the author of the changes and what these changes are and why. 
+
+6. Derived versions of this software in whatever form are subject to the same restrictions. In particular it is not permitted to make derived copies of this software which do not conform to the Shen standard or appear under a different title.
+
+7. It is permitted to distribute versions of Shen which incorporate libraries, graphics or other facilities which are not part of the Shen standard.
+
+The License in Detail
+
+The user is free to produce commercial applications with the software, to distribute these applications in source or binary form, and to charge monies for them as he sees fit and in concordance with the laws of the land subject to the following license.
+
+That's the $free part. You can write your own Shen software and put your own license on it and charge what you want and distribute it either as closed or open source. We'll come back to that.
+
+1. The license applies to all the software and all derived software and must appear on that software.
+
+That means that the license applies to the Shen source code and the Kl source code which comes with the download. You will see that this code carries a copyright on the code. The concept of derivative is explained in US law as follows.
+
+A 'derivative work' is a work based upon one or more pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which a work may be recast, transformed, or adapted. A work consisting of editorial revisions, annotations, elaborations, or other modifications which, as a whole, represent an original work of authorship, is a 'derivative work'.
+
+To this we add that any computable mapping of the Shen source code and the Kl source code to another medium i.e. another language; counts as a derivative work in our understanding, and it is immaterial whether this mapping is done by a human being or by a computer. If you map Shen into Javascript by writing a compiler, then the resulting Javascript program carries the same license as the original and that license must appear on the code. If you retitle some of the functions using a global substitution it is a derivative work. If you copy it out in copperplate using a quill, it is derivative. In other words, the message and not the medium is important. 
+
+2. It is illegal to distribute the software without this license attached to it and use of the software implies agreement with the license as such. It is illegal for anyone who is not the copyright holder to tamper with or change the license.
+
+This is basic. You cannot remove this license or change it - only the copyright holder can do that. 
+
+3. Neither the names of Lambda Associates or the copyright holder may be used to endorse or promote products built using the software without specific prior written permission from the copyright holder.
+
+You cannot say 'My software is great because Mark Tarver recommends it' or 'Lambda Associates says this is really reliable' unless we did actually say that, and gave you the written permission to use our endorsement. That said, if you do write something really great in Shen, I'd be happy to endorse it and for you to use that endorsement.
+
+4. That possession of this license does not confer on the copyright holder any special contractual obligation towards the user. That in no event shall the copyright holder be liable for any direct, indirect, incidental, special, exemplary or consequential damages (including but not limited to procurement of substitute goods or services, loss of use, data, or profits; or business interruption), however caused and on any theory of liability, whether in contract, strict liability or tort (including negligence) arising in any way out of the use of the software, even if advised of the possibility of such damage. 
+
+This is the usual disclaimer. It protects us from a lawsuit in case anything goes wrong with our software. However Shen is based on a design with 20 years R&D; it has been very thoroughly tested by myself and by the people who have ported it to other platforms. So in all you are pretty safe here.
+
+5. It is permitted for the user to change the software, for the purpose of improving performance, correcting an error, or porting to a new platform, and distribute the modified version of Shen (hereafter the modified version) provided the resulting program conforms in all respects to the Shen standard and is issued under that title and the original license. The user must it clear with his distribution that he/she is the author of the changes and what these changes are and why. 
+
+Shen sources are readable for several reasons. The first is that we want to allow people to read our code and correct mistakes. The second is that people porting Shen to different OSes and different platforms need open access to the code to do the porting. The last is we allow people to improve the efficiency of our code by changing it - as long as it then still works i.e. it conforms to the spec. You have to put your name on the changes you make, because, in the event that something goes wrong, we cannot take the moral responsibility for those changes. It should be obvious (I hope) that optimising a small piece of code does not change the license or allow you to change the license. The resulting work is still derivative.
+
+6. Derived versions of this software in whatever form are subject to the same restrictions. In particular it is not permitted to make derived copies of this software which do not conform to the Shen standard or appear under a different title.
+
+Again this emphasises what we said in explicating 1. This point just says you cannot evade the license by simply retitling and reselling our code under a different title e.g. Shine. 
+
+7. It is permitted to distribute versions of Shen which incorporate libraries, graphics or other facilities which are not part of the Shen standard.
+
+This means you are free to add things to Shen which are not part of the standard and you can distribute that work under the Shen title."