heist 0.2.1 → 0.3.0

data/lib/parser/scheme.tt

@@ -10,7 +10,7 @@ module Heist
     
     rule cell
       ignore quote cell <QuotedCell> /
-      ignore (list / atom) ignore <Cell>
+      ignore (list / vector / atom) ignore <Cell>
     end
     
     rule quote
@@ -21,6 +21,10 @@ module Heist
       "."
     end
     
+    rule hash
+      "#"
+    end
+    
     rule list
       ("(" cells ")" / "[" cells "]") <List>
     end
@@ -30,16 +34,20 @@ module Heist
       cell* ignore
     end
     
+    rule vector
+      (hash "(" cell* ignore ")" / hash "[" cell* ignore "]") <Vector>
+    end
+    
     rule atom
       datum / identifier
     end
     
     rule datum
-      (boolean / number / string) !(!delimiter .) <Datum>
+      (boolean / number / character / string) !(!delimiter .) <Datum>
     end
     
     rule boolean
-      ("#t" / "#f") <Boolean>
+      hash [tf] <Boolean>
     end
     
     rule number
@@ -62,6 +70,10 @@ module Heist
       "-"? ("0" / [1-9] digit*) <Integer>
     end
     
+    rule character
+      "#\\" glyph:(identifier / .) <Character>
+    end
+    
     rule string
       '"' ('\\"' / [^"])* '"' <String>
     end
@@ -79,7 +91,7 @@ module Heist
     end
     
     rule delimiter
-      quote / paren / space
+      quote / hash / paren / space
     end
     
     rule paren
@@ -91,11 +103,11 @@ module Heist
     end
     
     rule ignore
-      space* comment?
+      space* (comment ignore)?
     end
     
     rule comment
-      ";" (![\n\r] .)* ignore
+      ";" (![\n\r] .)*
     end
   end
 end

data/lib/repl.rb

@@ -6,6 +6,10 @@ module Heist
     def initialize(options = {})
       @runtime = Runtime.new(options)
       @scope = Runtime::FileScope.new(@runtime.top_level, File.expand_path('.'))
+      @results = []
+      
+      @runtime.define('~') { |x| @results[-x] }
+      
       reset!
     end
     
@@ -13,18 +17,7 @@ module Heist
       puts @runtime.info
       
       Readline.completion_append_character = nil
-      Readline.completion_proc = lambda do |prefix|
-        return nil if prefix == ''
-        matches = @runtime.top_level.grep(%r[^#{prefix}]i).
-                           sort_by { |r| r.length }
-        return nil unless word = matches.first
-        while word.length > prefix.length
-          break if matches.all? { |m| m =~ %r[^#{word}]i }
-          word = word.gsub(/.$/, '')
-        end
-        return nil if word == prefix
-        word + (matches.size == 1 ? ' ' : '')
-      end
+      Readline.completion_proc = @runtime.top_level.method(:longest_prefix)
       
       loop do
         begin
@@ -37,7 +30,11 @@ module Heist
           
           reset!
           result = @scope.eval(tree)
-          puts "; => #{ result }\n\n" unless result.nil?
+          unless result.nil?
+            puts "; => #{ text(result) }\n\n"
+            @results << result
+            @scope['^'] = result
+          end
           
         rescue Exception => ex
           return if SystemExit === ex
@@ -67,6 +64,15 @@ 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/binding.rb

@@ -46,6 +46,7 @@ module Heist
       def to_s
         @expression.to_s
       end
+      alias :inspect :to_s
     end
     
   end

data/lib/runtime/callable/continuation.rb

@@ -38,6 +38,7 @@ module Heist
       def to_s
         "#<continuation>"
       end
+      alias :inspect :to_s
     end
     
   end

data/lib/runtime/callable/macro.rb

@@ -48,6 +48,8 @@ module Heist
           when Cons then
             tail = pattern.each { |cell| pattern_vars(cell, excluded, results) }
             pattern_vars(tail.cdr, excluded, results)
+          when Vector then
+            pattern.each { |cell| pattern_vars(cell, excluded, results) }
         end
         results
       end
@@ -68,6 +70,7 @@ module Heist
       def to_s
         "#<macro:#{ @name }>"
       end
+      alias :inspect :to_s
       
       # Takes a +Cons+ expression and a +Scope+ (required for determining
       # the binding of macro keywords), and returns a tuple containing an
@@ -173,8 +176,9 @@ module Heist
               # using the current pattern until the pattern no
               # longer matches the current input
               #
-              return nil unless consume[] or followed_by_ellipsis
-              input_pair = input_pair.cdr
+              consumed = consume[]
+              return nil unless consumed or followed_by_ellipsis
+              input_pair = input_pair.cdr if consumed
               input_pair = input_pair.cdr while followed_by_ellipsis and consume[]
               
               skip[]
@@ -186,6 +190,37 @@ module Heist
             # input matches this object.
             return nil unless rule_matches(scope, pattern_pair, input_pair, matches, depth)
         
+          when Vector then
+            # Fail if the pattern is a vector and the input is not
+            return nil unless Vector === input
+            
+            # Iterate over the pattern and input, consuming input cells
+            # as we go. This is very similar to how we handle lists, we
+            # should probably refactor this.
+            input_index = 0
+            pattern.each_with_index do |token, pattern_index|
+              next if token == ELLIPSIS
+              
+              followed_by_ellipsis = (pattern[pattern_index+1] == ELLIPSIS)
+              dx = followed_by_ellipsis ? 1 : 0
+              
+              matches.descend!(Macro.pattern_vars(token, @formals),
+                               depth + dx) if followed_by_ellipsis
+              
+              consume = lambda do
+                not input[input_index].nil? and
+                rule_matches(scope, token, input[input_index],
+                             matches, depth + dx)
+              end
+              
+              consumed = consume[]
+              return nil unless consumed or followed_by_ellipsis
+              input_index += 1 if consumed
+              input_index += 1 while followed_by_ellipsis and consume[]
+            end
+            
+            return nil unless input_index == input.size
+        
           # If the pattern is a formal keyword for the macro (a
           # 'literal identifier' in the terms of the spec), return
           # a boolean indicating whether the input is an identifier

data/lib/runtime/callable/macro/expansion.rb

@@ -60,6 +60,9 @@ module Heist
           case template
           
             when Cons then
+              # Return NULL if the template is an empty list
+              return Cons::NULL if template.null?
+              
               # If the template is a list opening with an ellipsis, expand
               # the rest of the list, transcribing ellipses verbatim
               return expand(template.cdr.car,
@@ -81,13 +84,16 @@ module Heist
               end
               
               # Iterate over the template, inserting matches as we go
-              while not template_pair.null?
+              while Cons === template_pair and not template_pair.null?
                 cell = template_pair.car
                 
                 # Increment the repetition depth if the current subtemplate
                 # is followed by an ellipsis and we are not treating ellipses
                 # as literals
-                followed_by_ellipsis = (template_pair.cdr.car == ELLIPSIS) && !ignoring_ellipses
+                followed_by_ellipsis = ( Cons === template_pair.cdr &&
+                                         template_pair.cdr.car == ELLIPSIS) &&
+                                       !ignoring_ellipses
+                
                 dx = followed_by_ellipsis ? 1 : 0
                 
                 repeater = cell if followed_by_ellipsis
@@ -109,6 +115,32 @@ module Heist
                 
                 template_pair = template_pair.cdr
               end
+              
+              # Handle the tail of improper list templates
+              last.cdr = expand(template_pair, matches, depth, ignoring_ellipses) unless last.nil?
+              result
+          
+            # TODO this is very similar to how we handle lists -> refactor
+            when Vector then
+              result, repeater = Vector.new, nil
+              push = lambda { |value| result << value }
+              
+              template.each_with_index do |cell, template_index|
+                
+                followed_by_ellipsis = (template[template_index+1] == ELLIPSIS) && !ignoring_ellipses
+                dx = followed_by_ellipsis ? 1 : 0
+                
+                repeater = cell if followed_by_ellipsis
+                
+                if cell == ELLIPSIS and not ignoring_ellipses
+                  matches.expand!(repeater, depth + 1) do
+                    push[expand(repeater, matches, depth + 1)]
+                  end
+                else
+                  push[expand(cell, matches, depth + dx,
+                              ignoring_ellipses)] unless followed_by_ellipsis
+                end
+              end
               result
           
             when Identifier then

data/lib/runtime/callable/syntax.rb

@@ -37,6 +37,7 @@ module Heist
       def to_s
         "#<syntax:#{ @name }>"
       end
+      alias :inspect :to_s
     end
     
   end

data/lib/runtime/data/character.rb

@@ -0,0 +1,83 @@
+module Heist
+  class Runtime
+    
+    # The +Character+ class is used to represent Scheme's notion of characters,
+    # objects that represent single ASCII glyphs. They are written in Scheme code
+    # as the symbols <tt>#\\</tt> followed by the desired glyph.
+    #
+    # Characters can be mapped back and forth to integer character codes and are
+    # thus sortable. This class uses Ruby's +Comparable+ mixin to sort characters
+    # by their ASCII code.
+    #
+    # In addition to single glyphs, there are a few named characters that
+    # represent whitespace characters: see +SPECIAL+ for named characters
+    # supported by Heist.
+    #
+    class Character
+      include Comparable
+      attr_reader :glyph
+      
+      # List of special character names and the strings they represent
+      SPECIAL = {
+        "space"   => " ",
+        "newline" => "\n",
+        "tab"     => "\t"
+      }
+      
+      # A +Character+ is initialized using either a single-character string,
+      # or a string containing the name of a special whitespace character. If
+      # a name is used, it must appear as a key in +SPECIAL+ otherwise an
+      # exception is thrown.
+      def initialize(glyph)
+        raise SyntaxError.new("There is no character named '#{glyph}'") if glyph.size > 1 and SPECIAL[glyph].nil?
+        @glyph = glyph
+      end
+      
+      # Returns the ASCII code for the +Character+ as an integer.
+      def char_code
+        code, char = nil, to_s
+        char.each_byte { |x| code = x }
+        code
+      end
+      alias :to_i :char_code
+      
+      # Returns +true+ iff the two characters represent the same glyph.
+      def ==(other)
+        Character === other and
+        ( @glyph               == other.glyph or
+          SPECIAL[@glyph]      == other.glyph or
+          SPECIAL[other.glyph] == @glyph )
+      end
+      
+      # Returns the difference between the receiver's charcode and the argument's
+      # charcode, used for the +Comparable+ operations.
+      def <=>(other)
+        char_code - other.char_code
+      end
+      
+      # Returns a new +Character+ representing the uppercase version
+      # of the receiver.
+      def upcase
+        self.class.new(to_s.upcase)
+      end
+      
+      # Returns a new +Character+ representing the lowercase version
+      # of the receiver.
+      def downcase
+        self.class.new(to_s.downcase)
+      end
+      
+      # Returns a +String+ of unit length containing only the +Character+.
+      def to_s
+        SPECIAL[@glyph] || @glyph
+      end
+      
+      # Returns a Scheme-style string representation of the +Character+.
+      def inspect
+        "#\\#{ @glyph }"
+      end
+    end
+    
+  end
+end
+

data/lib/runtime/data/cons.rb

@@ -16,19 +16,23 @@ module Heist
     #
     #   Proper list: (1 2 3)    Improper list: (1 2 3 . 4)
     #
-    #         #                         #                    # = cons
-    #        / \\                      / \\                  / = car
-    #       1   #                     1   #                 \\ = cdr
-    #          / \\                      / \\               () = NULL
-    #         2   #                     2   #
-    #            / \\                      / \\
-    #           3   ()                    3   4
+    #         .                         .                    . = cons
+    #        / \                       / \                   / = car
+    #       1   .                     1   .                  \ = cdr
+    #          / \                       / \                () = NULL
+    #         2   .                     2   .
+    #            / \                       / \ 
+    #           3  ()                     3   4
+    #
+    # This also illustrates the relationship between dotted pairs and +Cons+
+    # cells; <tt>'(a . b)</tt> is equivalent to <tt>(cons 'a 'b)</tt>, and the
+    # list <tt>(1 2 3)</tt> is more fully written as <tt>(1 . (2 . (3 . ())))</tt>.
     #
     # +Cons+ objects are +Enumerable+, though always keep in mind that a
     # +Cons+ does not 'contain' a whole list, it contains one value and a
     # pointer to the rest of the list. Iterating on a +Cons+ involves
     # walking this object graph.
-
+    #
     class Cons
       include Enumerable
       include Expression
@@ -107,14 +111,14 @@ module Heist
       # Sets the +car+ of the receiving +Cons+, unless it is frozen. If the
       # given value is +nil+, +NULL+ is used instead.
       def car=(car)
-        raise ImmutableError.new("Cannot modify constant value") if frozen?
+        raise ImmutableError.new("Cannot modify list constant") if frozen?
         @car = car.nil? ? NULL : car
       end
       
       # Sets the +cdr+ of the receiving +Cons+, unless it is frozen. If the
       # given value is +nil+, +NULL+ is used instead.
       def cdr=(cdr)
-        raise ImmutableError.new("Cannot modify constant value") if frozen?
+        raise ImmutableError.new("Cannot modify list constant") if frozen?
         @cdr = cdr.nil? ? NULL : cdr
       end
       
@@ -214,19 +218,13 @@ module Heist
       end
       
       # Returns a Scheme-style string representation of the list.
-      def to_s
+      def inspect
         strings = []
-        tail = each { |value|
-          strings << case value
-                       when String then value.inspect
-                       when Symbol then "'#{value}"
-                       else value
-                     end
-        }.cdr
+        tail = each { |value| strings << value.inspect }.cdr
         '(' + (strings * ' ') +
               (tail == NULL ? '' : ' . ' + tail.to_s) + ')'
       end
-      alias :inspect :to_s
+      alias :to_s :inspect
     end
     
   end

data/lib/runtime/data/vector.rb

@@ -0,0 +1,65 @@
+module Heist
+  class Runtime
+    
+    # +Vector+ is Scheme's equivalent of Ruby's +Array+ class, and Heist
+    # implements it by subclassing +Array+. In Scheme code a vector is
+    # denoted as a proper list preceeded by a <tt>#</tt> symbol, for
+    # example <tt>#(1 2 3)</tt>. Vectors are flat, non-recursive data
+    # structures, meaning they are faster for accessing slots by numeric
+    # index since we do not have to walk a tree to find the correct node.
+    #
+    # As an example, you can think of the list <tt>(1 2 3)</tt> and the
+    # vector <tt>#(1 2 3 4)</tt> as having the following structure:
+    #
+    #   Proper list: (1 2 3)      Vector: #(1 2 3 4)
+    #
+    #         .                           .
+    #        / \                          |
+    #       1   .                   -------------
+    #          / \                  |   |   |   |
+    #         2   .                 1   2   3   4
+    #            / \ 
+    #           3  ()
+    #
+    # Accessing a member of a vector takes time independent of the member's
+    # index, whereas access time scales as O(n) for lists.
+    #
+    class Vector < Array
+      # A +Vector+ is initialized using a sequence of values, just like
+      # a Ruby +Array+. Optionally, it can be initialized using an array
+      # and a block, which will be used to map the array to new values
+      # before inserting into the +Vector+.
+      # 
+      #   Vector.new([1,2,3,4]) { |x| x*x }
+      #   #=> #(1 2 3 4)
+      #
+      def initialize(*args, &block)
+        return super(*args) unless block_given?
+        args.first.each_with_index { |cell, i| self[i] = block.call(cell) }
+      end
+      
+      # Performs a recursive freeze of the +Vector+ and all its members.
+      def freeze!
+        freeze
+        each { |slot| slot.freeze! if slot.respond_to?(:freeze!) }
+      end
+      
+      # Sets the +value+ at the given +index+. Will throw an exception
+      # if the +Vector+ is frozen. The Scheme function <tt>(vector-set!)</tt>
+      # also performs out-of-bounds checks to keep vectors a fixed size,
+      # but this is not enforced at this level.
+      def []=(index, value)
+        raise ImmutableError.new("Cannot modify vector constant") if frozen?
+        super
+      end
+      
+      # Returns a Scheme-style string representation of the +Vector+.
+      def inspect
+        '#(' + map { |cell| cell.inspect }.join(' ') + ')'
+      end
+      alias :to_s :inspect
+    end
+    
+  end
+end
+