heist 0.3.0 → 0.3.1

data/History.txt

@@ -1,3 +1,10 @@
+=== Version 0.3.1 (2009-08-23)
+
+* Added the (rationalize) procedure
+* Allowed (gcd) and (lcm) to take more than two arguments
+* Fixed string output so the REPL prints all data types correctly
+
+
 === Version 0.3.0 (2009-07-31)
 
 We've got all your data types now

data/README.txt

@@ -38,7 +38,7 @@ languages.
 Heist nominally targets R5RS (http://www.schemers.org/Documents/Standards/R5RS/HTML).
 It has good support for many Scheme runtime features such as tail call
 optimisation, macros and first-class continuations, as well as reasonably
-complete numeric and list libraries.
+complete libraries for all the Scheme data types.
 
 Currently implemented R5RS features include:
 
@@ -71,9 +71,9 @@ Currently implemented R5RS features include:
   <tt>abs</tt>, <tt>quotient</tt>, <tt>remainder</tt>, <tt>modulo</tt>,
   <tt>gcd</tt>, <tt>lcm</tt>, <tt>numerator</tt>, <tt>denominator</tt>,
   <tt>floor</tt>, <tt>ceiling</tt>, <tt>truncate</tt>, <tt>round</tt>,
-  <tt>exp</tt>, <tt>log</tt>, <tt>sin</tt>, <tt>cos</tt>, <tt>tan</tt>,
-  <tt>asin</tt>, <tt>acos</tt>, <tt>atan</tt>, <tt>sqrt</tt>, <tt>expt</tt>,
-  <tt>make-rectangular</tt>, <tt>make-polar</tt>, <tt>real-part</tt>,
+  <tt>rationalize</tt>, <tt>exp</tt>, <tt>log</tt>, <tt>sin</tt>, <tt>cos</tt>,
+  <tt>tan</tt>, <tt>asin</tt>, <tt>acos</tt>, <tt>atan</tt>, <tt>sqrt</tt>,
+  <tt>expt</tt>, <tt>make-rectangular</tt>, <tt>make-polar</tt>, <tt>real-part</tt>,
   <tt>imag-part</tt>, <tt>magnitude</tt>, <tt>angle</tt>, <tt>number->string</tt>,
   <tt>string->number</tt>
 * Boolean library: <tt>and</tt>, <tt>or</tt>, <tt>not</tt>, <tt>boolean?</tt>
@@ -215,7 +215,9 @@ interface. Quoting syntax is out, so the expression <tt>'(1 2 3)</tt> would
 need to be written <tt>[:quote, [1, 2, 3]]</tt>. Dotted pairs and improper
 lists are also not available, though you can work around this to some extent
 using <tt>:cons</tt>. Vectors should be written as <tt>[:vector, 1, 2, 3]</tt>
-for example. Characters are not supported at all.
+for example. Characters can be generated using the <tt>char</tt> procedure
+with a unit-length string, for example <tt>[:char, "Z"]</tt> produces the
+character <tt>#\\Z</tt>.
 
 
 == Notes
@@ -226,6 +228,8 @@ explicitly documented in this file can be assumed to work according to
 the Scheme standard, or according to the information presented here,
 and can be assumed to be reasonably stable.
 
+=== Ruby-based syntax
+
 I have not documented how to write your own syntax using Ruby because
 it requires far too much knowledge of Heist's plumbing at present (I
 suspect this may be unavoidable). Besides, we have macros so if you
@@ -233,11 +237,25 @@ want new syntax we've got you covered. In fact, writing syntax using
 macros makes sure that new syntactic forms support continuations
 correctly, and Heist itself eschews Ruby-based syntax where possible.
 
+=== Valid symbols
+
 Heist is extremely liberal as regards symbols. Any sequence of
 characters that does not contain any spaces or parentheses and that
-is not a boolean literal, a number or a string is considered a valid
-symbol. This means that syntax that should be used for chars and
-vectors will currently parse as symbols.
+is not a boolean literal, a number, a character literal or a string
+is considered a valid symbol.
+
+=== Vectors and quoting
+
+Vectors do not need to be quoted, for example the expression <tt>#(1 2 3)</tt>
+evaluates to itself. If a vector is quoted, it is made immutable and
+a quoted vector expression returns the same in-memory object every time
+it is evaluated. In contrast, an unquoted vector returns a new vector
+object every time it is evaluated. Unquoted vectors are not frozen
+as this makes macro transformations hard to implement, and because we
+cannot let the <tt>vector-set!</tt> procedure modify the parse tree
+each unquoted vector is copied on evaluation.
+
+=== Macros
 
 Macros are slightly more liberal than R5RS, in that this is a valid
 macro:
@@ -274,6 +292,8 @@ conditionally, certainly this will not work with macros as the
 inlining process will overwrite conditional code using the first
 expansion generated.
 
+=== Laziness
+
 Lazy evaluation mode is mainly useful for doing lambda calculus
 without being concerned about the difference between normal and
 applicative order, which for example affects the expression for

data/lib/builtin/library.scm

@@ -2,6 +2,7 @@
 ; in Scheme should go here. If at all possible, write
 ; builtins in Scheme rather than Ruby.
 
+(define quit exit)
 
 ; (newline)
 ; prints a new-line character
@@ -149,22 +150,48 @@
 ; (gcd x y)
 ; Returns the greatest common divisor of two numbers
 ; http://en.wikipedia.org/wiki/Euclidean_algorithm
-; TODO take >2 arguments
-(define (gcd x y)
-  (if (zero? y)
-      (abs x)
-      (gcd y (remainder x y))))
+(define (gcd x y . rest)
+  (if (null? rest)
+      (if (zero? y)
+          (abs x)
+          (gcd y (remainder x y)))
+      (apply gcd (cons (gcd x y) rest))))
 
 ; (lcm x y)
 ; Returns the lowest common multiple of two numbers
 ; http://en.wikipedia.org/wiki/Least_common_multiple
-; TODO take >2 arguments
-(define (lcm x y)
-  (/ (abs (* x y))
-     (gcd x y)))
+(define (lcm x y . rest)
+  (if (null? rest)
+      (/ (abs (* x y))
+         (gcd x y))
+      (apply lcm (cons (lcm x y) rest))))
 
 (define ceiling ceil)
 
+; (rationalize x tolerance)
+; Returns the simplest rational number that differs from x by
+; no more than tolerance. Here 'simplest' means the smallest
+; possible denominator is found first, and with that set the
+; smallest corresponding numerator is chosen.
+(define (rationalize x tolerance)
+  (cond [(rational? x)
+          x]
+        [(not (zero? (imag-part x)))
+          (make-rectangular (rationalize (real-part x) tolerance)
+                            (rationalize (imag-part x) tolerance))]
+        [else
+          (let* ([t (abs tolerance)]
+                 [a (- x t)]
+                 [b (+ x t)])
+            (do ([i 1 (+ i 1)]
+                 [z #f])
+                ((number? z) z)
+              (let ([p (ceiling (* a i))]
+                    [q (floor (* b i))])
+                (if (<= p q)
+                    (set! z (/ (if (positive? p) p q)
+                               i))))))]))
+
 ; (make-polar magnitude angle)
 ; Returns a new complex number with the given
 ; magnitude and angle
@@ -342,6 +369,15 @@
 
 ; Character functions
 
+; (char string)
+; Returns a character from a single-character string. Mostly
+; useful for succinct representation of characters in hand-
+; written Ruby code.
+(define (char string)
+  (if (and (string? string) (= (string-length string) 1))
+      (string-ref string 0)
+      '()))
+
 ; (char-upper-case? letter)
 ; Returns true iff letter is an uppercase letter
 (define (char-upper-case? letter)

data/lib/heist.rb

@@ -9,7 +9,7 @@ require 'treetop'
 # utility methods that don't belong anywhere else. See the README for an
 # overview of Heist's features.
 module Heist
-  VERSION = '0.3.0'
+  VERSION = '0.3.1'
   
   ROOT_PATH    = File.expand_path(File.dirname(__FILE__))
   PARSER_PATH  = ROOT_PATH + '/parser/'
@@ -66,6 +66,18 @@ module Heist
           op1.to_f / op2
     end
     
+    # Returns a string representation of the object suitable for display on the
+    # command line. Some built-in Ruby types need special handling to display
+    # according to Scheme conventions.
+    def stringify(object)
+      case object
+      when Runtime::Character, String then object.inspect
+      when TrueClass  then '#t'
+      when FalseClass then '#f'
+      else object.to_s
+      end
+    end
+    
   end
 end
 

data/lib/repl.rb

@@ -31,7 +31,7 @@ module Heist
           reset!
           result = @scope.eval(tree)
           unless result.nil?
-            puts "; => #{ text(result) }\n\n"
+            puts "; => #{ Heist.stringify(result) }\n\n"
             @results << result
             @scope['^'] = result
           end
@@ -64,15 +64,6 @@ module Heist
       @indent = 0
     end
     
-    def text(object)
-      case object
-      when Runtime::Character, String then object.inspect
-      when TrueClass  then '#t'
-      when FalseClass then '#f'
-      else object.to_s
-      end
-    end
-    
     def push(line)
       old_depth = depth
       @buffer << line

data/lib/runtime/data/cons.rb

@@ -218,13 +218,13 @@ module Heist
       end
       
       # Returns a Scheme-style string representation of the list.
-      def inspect
+      def to_s
         strings = []
-        tail = each { |value| strings << value.inspect }.cdr
+        tail = each { |value| strings << Heist.stringify(value) }.cdr
         '(' + (strings * ' ') +
               (tail == NULL ? '' : ' . ' + tail.to_s) + ')'
       end
-      alias :to_s :inspect
+      alias :inspect :to_s
     end
     
   end

data/lib/runtime/data/vector.rb

@@ -54,10 +54,10 @@ module Heist
       end
       
       # Returns a Scheme-style string representation of the +Vector+.
-      def inspect
-        '#(' + map { |cell| cell.inspect }.join(' ') + ')'
+      def to_s
+        '#(' + map { |cell| Heist.stringify(cell) }.join(' ') + ')'
       end
-      alias :to_s :inspect
+      alias :inspect :to_s
     end
     
   end

data/test/arithmetic.scm

@@ -41,6 +41,8 @@
 (assert-equal 4 (gcd 32 -36))
 (assert-equal 288 (lcm 32 -36))
 (assert-equal 288.0 (lcm 32.0 -36)) ; inexact
+(assert-equal 6 (lcm 2 6))
+(assert-equal 12 (lcm 2 6 4))
 
 (assert-equal 3 (numerator (/ 6 4)))
 (assert-equal 2 (denominator (/ 6 4)))

data/test/numbers.scm

@@ -39,3 +39,10 @@
 
 (assert-equal 1 (make-polar 1 0))
 
+(assert-equal 3 (rationalize 5.5 3))
+(assert-equal 4 (rationalize 5.5 2))
+(assert-equal 5 (rationalize 5.5 1))
+(assert-equal 11/2 (rationalize 5.5 0.1))
+(assert-equal 16/3 (rationalize 5.25 0.1))
+(assert-equal 21/4 (rationalize 5.25 0.01))
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: heist
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - James Coglan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-31 00:00:00 +01:00
+date: 2009-08-23 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency