apricot 0.0.1 → 0.0.2

data/lib/apricot/repl.rb

@@ -1,5 +1,6 @@
 require 'readline'
 require 'yaml'
+Apricot.require "repl"
 
 module Apricot
   class REPL
@@ -37,20 +38,26 @@ module Apricot
     }
 
     COMMAND_COMPLETIONS = COMMANDS.keys.sort
-    SPECIAL_COMPLETIONS = SpecialForm::Specials.keys.map(&:to_s)
+    SPECIAL_COMPLETIONS = SpecialForm::SPECIAL_FORMS.keys.map(&:to_s)
 
-    def initialize(prompt = 'apr> ', bytecode = false, history_file = nil)
+    def initialize(prompt = 'apr> ', history_file = nil)
       @prompt = prompt
-      @bytecode = bytecode
       @history_file = File.expand_path(history_file || HISTORY_FILE)
       @line = 1
     end
 
     def run
+      # *1, *2, and *3 shall hold the results of the previous three
+      # evaluations.
+      Apricot::Core.set_var(:'*1', nil)
+      Apricot::Core.set_var(:'*2', nil)
+      Apricot::Core.set_var(:'*3', nil)
+
+      # Set up some Readline options.
       Readline.completion_append_character = " "
       Readline.basic_word_break_characters = " \t\n\"'`~@;{[("
-      Readline.basic_quote_characters = "\""
 
+      # Set up tab completion.
       Readline.completion_proc = proc do |s|
         if s.start_with? '!'
           # User is typing a REPL command
@@ -69,46 +76,78 @@ module Apricot
       load_history
       terminal_state = `stty -g`.chomp
 
+      # Clear the current line before starting the REPL. This means the user
+      # can begin typing before the prompt appears and it will gracefully
+      # appear in front of their code when the REPL is ready, without any ugly
+      # text duplication issues.
+      clear_line
+
       while code = readline_with_history
         stripped = code.strip
-        if stripped.empty?
-          next
-        elsif stripped.start_with?('!')
+
+        # Ignore blank lines.
+        next if stripped.empty?
+
+        # Handle REPL commands.
+        if stripped.start_with?('!')
           if COMMANDS.include?(stripped) && block = COMMANDS[stripped][:code]
             instance_eval(&block)
           else
             puts "Unknown command: #{stripped}"
           end
+
           next
         end
 
+        # Otherwise treat the input as code to evaluate.
         begin
-          @compiled_code =
-            Apricot::Compiler.compile_string(code, "(eval)", @line, @bytecode)
-          value = Rubinius.run_script @compiled_code
-          puts "=> #{value.apricot_inspect}"
-          Apricot.current_namespace.set_var(:_, value)
-          e = nil
-        rescue Apricot::SyntaxError => e
-          if e.incomplete?
+          begin
+            forms = Apricot::Reader.read_string(code, "(eval)", @line)
+          rescue Apricot::SyntaxError => e
+            # Reraise unless this is an incomplete error (meaning we can read
+            # more on the next line).
+            raise unless e.incomplete?
+
             begin
-              more_code = Readline.readline(' ' * @prompt.length, false)
+              indent = ' ' * @prompt.length
+              more_code = Readline.readline(indent, false)
+
               if more_code
-                code << "\n" << more_code
-                Readline::HISTORY << Readline::HISTORY.pop + "\n" +
-                  ' ' * @prompt.length +  more_code
+                code << "\n" << indent << more_code
+                Readline::HISTORY.pop
+                Readline::HISTORY << code
                 retry
               else
                 print "\r" # print the exception at the start of the line
+                raise
               end
             rescue Interrupt
               # This is raised by Ctrl-C. Stop trying to read more code and
               # just give up. Remove the current input from history.
+              puts "^C"
               current_code = Readline::HISTORY.pop
-              @line -= current_code.count "\n"
-              e = nil # ignore the syntax error since the code was Ctrl-C'd
+              @line -= current_code.count("\n")
+              next
             end
           end
+
+          forms.each do |form|
+            @compiled_code =
+              Apricot::Compiler.compile_form(form, "(eval)", @line)
+
+            value = Rubinius.run_script(@compiled_code)
+            puts "=> #{value.apricot_inspect}"
+
+            # Save the result of the evaluation in *1 and shift down the older
+            # previous values.
+            old   = Apricot::Core.get_var(:'*1')
+            older = Apricot::Core.get_var(:'*2')
+            Apricot::Core.set_var(:'*1', value)
+            Apricot::Core.set_var(:'*2', old)
+            Apricot::Core.set_var(:'*3', older)
+          end
+
+          e = nil
         rescue Interrupt => e
           # Raised by Ctrl-C. Print a newline so the error message is on the
           # next line.
@@ -133,6 +172,12 @@ module Apricot
       system('stty', terminal_state) if terminal_state # Restore the terminal
     end
 
+    # Clear the current line in the terminal. This snippet was stolen from
+    # Pry.
+    def clear_line
+      puts "\e[0A\e[0G"
+    end
+
     def load_history
       if File.exist?(@history_file)
         hist = YAML.load_file @history_file
@@ -172,10 +217,8 @@ module Apricot
 
       line
     rescue Interrupt
-      # This is raised by Ctrl-C. Remove the line from history then try to
-      # read another line.
+      # This is raised by Ctrl-C. Try to read another line.
       puts "^C"
-      Readline::HISTORY.pop
       @line -= 1
       retry
     end

data/lib/apricot/ruby_ext.rb

@@ -1,5 +1,9 @@
 class Object
-  attr_accessor :apricot_meta
+  attr_reader :apricot_meta
+
+  def apricot_meta=(meta)
+    @apricot_meta = meta unless frozen?
+  end
 
   def apricot_inspect
     inspect
@@ -71,6 +75,10 @@ class Array
     def count
       @array.length - @offset
     end
+
+    def to_a
+      @array[@offset..-1]
+    end
   end
 end
 
@@ -94,8 +102,8 @@ class Hash
     str << '}'
   end
 
-  def apricot_call(key)
-    self[key]
+  def apricot_call(key, default = nil)
+    fetch(key, default)
   end
 
   alias_method :apricot_str, :apricot_inspect
@@ -119,11 +127,10 @@ class Set
     str << '}'
   end
 
-  def [](elem)
-    elem if self.include? elem
+  def apricot_call(elem, default = nil)
+    include?(elem) ? elem : default
   end
 
-  alias_method :apricot_call, :[]
   alias_method :apricot_str, :apricot_inspect
 
   def to_seq
@@ -155,15 +162,19 @@ class Symbol
   def apricot_inspect
     str = to_s
 
-    if str =~ /\A#{Apricot::Parser::IDENTIFIER}+\z/
+    if str =~ /\A#{Apricot::Reader::IDENTIFIER}+\z/
       ":#{str}"
     else
       ":#{str.inspect}"
     end
   end
 
-  def apricot_call(o)
-    o[self]
+  def apricot_call(obj, default = nil)
+    if obj.is_a?(Hash) || obj.is_a?(Set)
+      obj.apricot_call(self, default)
+    else
+      nil
+    end
   end
 end
 
@@ -179,10 +190,10 @@ class Range
   class Seq
     include Apricot::Seq
 
-    def initialize(first, last, exclude)
+    def initialize(first, last, exclusive)
       @first = first
       @last = last
-      @exclude = exclude
+      @exclusive = exclusive
     end
 
     def first
@@ -192,10 +203,10 @@ class Range
     def next
       next_val = @first.succ
 
-      if @first == @last || (next_val == @last && @exclude)
+      if @first == @last || (next_val == @last && @exclusive)
         nil
       else
-        Seq.new(next_val, @last, @exclude)
+        Seq.new(next_val, @last, @exclusive)
       end
     end
 
@@ -203,7 +214,7 @@ class Range
       prev = nil
       val = @first
 
-      until prev == @last || (val == @last && @exclude)
+      until prev == @last || (val == @last && @exclusive)
         yield val
         prev = val
         val = val.succ
@@ -216,7 +227,7 @@ end
 
 module Enumerable
   def to_list
-    list = Apricot::List::EmptyList
+    list = Apricot::List::EMPTY_LIST
     reverse_each {|x| list = list.cons(x) }
     list
   end
@@ -249,6 +260,6 @@ class NilClass
   end
 
   def rest
-    Apricot::List::EmptyList
+    Apricot::List::EMPTY_LIST
   end
 end

data/lib/apricot/scopes.rb

@@ -0,0 +1,159 @@
+module Apricot
+  # This is a scope with real local variable storage, i.e. it is part of a
+  # block of code like a fn or the top level program. Let scopes do not have
+  # storage and must ask for storage from one of these.
+  module StorageScope
+    def variable_names
+      @variable_names ||= []
+    end
+
+    def store_new_local(name)
+      slot = next_slot
+      variable_names << name
+      slot
+    end
+
+    def next_slot
+      variable_names.size
+    end
+
+    def local_count
+      variable_names.size
+    end
+
+    def local_names
+      variable_names
+    end
+  end
+
+  class TopLevelScope
+    include StorageScope
+
+    # A nested scope is looking up a variable. There are no local variables
+    # at the top level, so look up the variable on the current namespace.
+    def find_var(name, depth = nil)
+      # Ignore depth, it has no bearing on namespace lookups.
+      QualifiedReference.new(name, Apricot.current_namespace)
+    end
+
+    # A (recur) is looking for a recursion target. Since this is the top
+    # level, which has no parent, the lookup has failed.
+    def find_recur_target
+      nil
+    end
+  end
+
+  class Scope
+    attr_reader :parent, :variables
+    # The loop label stores the code location where a (recur) form should
+    # jump to.
+    attr_accessor :loop_label
+
+    def initialize(parent)
+      @parent = parent
+      @variables = {}
+      @loop_label = nil
+    end
+  end
+
+  class FnScope < Scope
+    attr_reader :name, :self_reference
+
+    def initialize(parent, name)
+      super(parent)
+
+      if name
+        @name = name
+        name_slot = @parent.store_new_local(name)
+        @self_reference = LocalReference.new(name_slot, 1)
+      end
+    end
+
+    # An identifier or a nested scope is looking up a variable. If the
+    # variable is found here, return a reference to it. Otherwise look it up
+    # on the parent and increment its depth because it is beyond the bounds
+    # of the current block of code (fn).
+    def find_var(name, depth = 0)
+      return @self_reference if name == @name
+
+      @parent.find_var(name, depth + 1)
+    end
+
+    # A (recur) is looking for a recursion target (ie. a loop or a fn
+    # overload scope).
+    def find_recur_target
+      @parent.find_recur_target
+    end
+  end
+
+  class OverloadScope < Scope
+    include StorageScope
+
+    attr_accessor :splat
+    alias_method :splat?, :splat
+
+    attr_accessor :block_arg
+
+    def initialize(parent_fn)
+      super(parent_fn)
+    end
+
+    # An identifier or a nested scope is looking up a variable. If the
+    # variable is found here, return a reference to it. Otherwise look it up
+    # on the parent (a fn). Don't increase the depth, the lookup on the fn
+    # will do that, and if we do it twice then the generated
+    # push_local_depth instructions look up too many scopes.
+    def find_var(name, depth = 0)
+      if slot = @variables[name]
+        LocalReference.new(slot, depth)
+      else
+        @parent.find_var(name, depth)
+      end
+    end
+
+    # Create a new local on the current level.
+    def new_local(name)
+      name = name.name if name.is_a? Identifier
+      @variables[name] = store_new_local(name)
+    end
+
+    # A (recur) is looking for a recursion target. This, being a fn
+    # overload, is one.
+    def find_recur_target
+      self
+    end
+  end
+
+  # The let scope doesn't have real storage for locals. It stores its locals
+  # on the nearest enclosing real scope, which is any separate block of code
+  # such as a fn, defn, defmacro or the top level of the program.
+  class LetScope < Scope
+    # An identifier or a nested scope is looking up a variable.
+    def find_var(name, depth = 0)
+      if slot = @variables[name]
+        LocalReference.new(slot, depth)
+      else
+        @parent.find_var(name, depth)
+      end
+    end
+
+    # Create a new local on the current level, with storage on the nearest
+    # enclosing real scope.
+    def new_local(name)
+      name = name.name if name.is_a? Identifier
+      @variables[name] = @parent.store_new_local(name)
+    end
+
+    # A deeper let is asking for a new local slot. Pass it along to the
+    # parent so it eventually reaches a real scope.
+    def store_new_local(name)
+      @parent.store_new_local(name)
+    end
+
+    # A (recur) is looking for a recursion target. This is one only if it is
+    # a (loop) form.
+    def find_recur_target
+      loop_label ? self : @parent.find_recur_target
+    end
+  end
+end

data/lib/apricot/seq.rb

@@ -8,9 +8,10 @@ module Apricot
   #   if there are no more items.
   module Seq
     include Enumerable
+    include Comparable
 
     def rest
-      self.next || Apricot::List::EmptyList
+      self.next || List::EMPTY_LIST
     end
 
     def each
@@ -32,6 +33,47 @@ module Apricot
       false
     end
 
+    def last
+      s = self
+
+      while s.next
+        s = s.next
+      end
+
+      s.first
+    end
+
+    def cons(x)
+      Cons.new(x, self)
+    end
+
+    def <=>(other)
+      return unless other.is_a?(Seq) || other.nil?
+      s, o = self, other
+
+      while s && o
+        comp = s.first <=> o.first
+        return comp unless comp == 0
+        s = s.next
+        o = o.next
+      end
+
+      if s
+        1
+      elsif o
+        -1
+      else
+        0
+      end
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      hashes = map {|x| x.hash }
+      hashes.reduce(hashes.size) {|acc,hash| acc ^ hash }
+    end
+
     def to_s
       str = '('
       each {|x| str << x.apricot_inspect << ' ' }