apricot 0.0.1 → 0.0.2

data/lib/apricot/generator.rb

@@ -1,7 +1,14 @@
 module Apricot
-  class Generator < Rubinius::Generator
-    def scopes
-      @scopes ||= []
+  class Generator < Rubinius::ToolSet::Runtime::Generator
+    attr_reader :scopes
+    attr_accessor :tail_position
+
+    alias_method :tail_position?, :tail_position
+
+    def initialize
+      super
+      @scopes = []
+      @tail_position = false
     end
 
     def scope

data/lib/apricot/identifier.rb

@@ -1,6 +1,6 @@
 module Apricot
   class Identifier
-    attr_reader :name, :ns, :unqualified_name
+    attr_reader :name, :unqualified_name
 
     @table = {}
 
@@ -19,16 +19,15 @@ module Apricot
         @const_names = @name.to_s.split('::').map(&:to_sym)
       elsif @name =~ /\A(.+?)\/(.+)\z/
         @qualified = true
-        ns_id = Identifier.intern($1)
-        raise 'namespace in identifier must be a constant' unless ns_id.constant?
+        qualifier_id = Identifier.intern($1)
+        raise 'Qualifier in qualified identifier must be a constant' unless qualifier_id.constant?
 
-        @ns = ns_id.const_names.reduce(Object) do |mod, name|
+        @qualifier = qualifier_id.const_names.reduce(Object) do |mod, name|
           mod.const_get(name)
         end
 
         @unqualified_name = $2.to_sym
       else
-        @ns = Apricot.current_namespace
         @unqualified_name = name
       end
     end
@@ -37,14 +36,30 @@ module Apricot
       @qualified
     end
 
-    def unqualified_name
-      @unqualified_name
-    end
-
     def constant?
       @constant
     end
 
+    # Does the identifier reference a fn on a namespace?
+    def fn?
+      qualifier.is_a?(Namespace) && qualifier.fns.include?(@unqualified_name)
+    end
+
+    # Does the identifier reference a method on a module?
+    def method?
+      !qualifier.is_a?(Namespace) && qualifier.respond_to?(@unqualified_name)
+    end
+
+    # Get the metadata of the object this identifier references, or nil.
+    def meta
+      qualifier.is_a?(Namespace) && qualifier.vars[@unqualified_name] &&
+        qualifier.vars[@unqualified_name].apricot_meta
+    end
+
+    def qualifier
+      @qualifier ||= Apricot.current_namespace
+    end
+
     def const_names
       raise "#{@name} is not a constant" unless constant?
       @const_names
@@ -71,7 +86,7 @@ module Apricot
         # be parsed as keywords or numbers
         str = @name.to_s.gsub(/(\\.)|\|/) { $1 || '\|' }
         "#|#{str}|"
-      when /\A#{Apricot::Parser::IDENTIFIER}+\z/
+      when /\A#{Reader::IDENTIFIER}+\z/
         @name.to_s
       else
         str = @name.to_s.inspect[1..-2]

data/lib/apricot/list.rb

@@ -4,59 +4,25 @@ module Apricot
     include Seq
 
     def self.[](*args)
-      list = EmptyList
+      list = EMPTY_LIST
       args.reverse_each do |arg|
         list = list.cons(arg)
       end
       list
     end
 
-    attr_reader :head, :tail
+    attr_reader :head, :tail, :count
 
     def initialize(head, tail)
       @head = head
-      @tail = tail
+      @tail = tail || EMPTY_LIST
+      @count = tail ? tail.count + 1 : 1
     end
 
     def cons(x)
       List.new(x, self)
     end
 
-    def each
-      list = self
-      until list.empty?
-        yield list.head
-        list = list.tail
-      end
-    end
-
-    def ==(other)
-      return true if self.equal? other
-      return false unless other.is_a? List
-
-      list = self
-
-      until list.empty?
-        return false if other.empty? || list.head != other.head
-
-        list = list.tail
-        other = other.tail
-      end
-
-      other.empty?
-    end
-
-    alias_method :eql?, :==
-
-    def hash
-      hashes = map {|x| x.hash }
-      hashes.reduce(hashes.size) {|acc,hash| acc ^ hash }
-    end
-
-    def empty?
-      !@tail
-    end
-
     def initialize_copy(other)
       super
       @tail = other.tail.dup if other.tail && !other.tail.empty?
@@ -69,7 +35,7 @@ module Apricot
     end
 
     def first
-      empty? ? nil : @head
+      @head
     end
 
     def next
@@ -77,7 +43,7 @@ module Apricot
     end
 
     def to_seq
-      empty? ? nil : self
+      self
     end
 
     def inspect
@@ -91,6 +57,27 @@ module Apricot
 
     alias_method :to_s, :inspect
 
-    EmptyList = new(nil, nil)
+    class EmptyList < List
+      def initialize
+        @count = 0
+      end
+
+      def each
+      end
+
+      def empty?
+        true
+      end
+
+      def first
+        nil
+      end
+
+      def next
+        nil
+      end
+    end
+
+    EMPTY_LIST = EmptyList.new
   end
 end

data/lib/apricot/macroexpand.rb

@@ -1,30 +1,36 @@
 module Apricot
   def self.macroexpand(form)
     ex = macroexpand_1(form)
-    ex.equal?(form) ? ex : macroexpand(ex)
+
+    until ex.equal?(form)
+      form = ex
+      ex = macroexpand_1(form)
+    end
+
+    ex
   end
 
   def self.macroexpand_1(form)
-    return form unless form.is_a? List
+    return form unless form.is_a? Seq
 
     callee = form.first
     return form unless callee.is_a?(Identifier) && !callee.constant?
 
     name = callee.name
     name_s = name.to_s
-    args = form.tail
+    args = form.rest
 
     # Handle the (.method receiver args*) send expression form
-    if name.length > 1 && name_s != '..' && name_s.start_with?('.')
+    if name.length > 1 && name != :'..' && name_s.start_with?('.')
       raise ArgumentError, "Too few arguments to send expression, expecting (.method receiver ...)" if args.empty?
 
       dot = Identifier.intern(:'.')
       method = Identifier.intern(name_s[1..-1])
-      return List[dot, args.first, method, *args.tail]
+      return List[dot, args.first, method, *args.rest]
     end
 
     # Handle the (Class. args*) shorthand new form
-    if name.length > 1 && name_s != '..' && name_s.end_with?('.')
+    if name.length > 1 && name != :'..' && name_s.end_with?('.')
       dot = Identifier.intern(:'.')
       klass = Identifier.intern(name_s[0..-2])
       new = Identifier.intern(:new)
@@ -32,8 +38,8 @@ module Apricot
     end
 
     # Handle defined macros
-    if callee.ns.is_a?(Namespace) && callee.ns.vars.include?(callee.unqualified_name)
-      potential_macro = callee.ns.get_var(callee.unqualified_name)
+    if callee.qualifier.is_a?(Namespace) && callee.qualifier.vars.include?(callee.unqualified_name)
+      potential_macro = callee.qualifier.get_var(callee.unqualified_name)
       meta = potential_macro.apricot_meta
 
       if meta && meta[:macro]

data/lib/apricot/misc.rb

@@ -6,6 +6,7 @@ module Apricot
   @gensym = 0
 
   def self.gensym(prefix = 'g')
-    :"#{prefix}__#{@gensym += 1}"
+    @gensym += 1
+    Identifier.intern("#{prefix}__#{@gensym}")
   end
 end

data/lib/apricot/namespace.rb

@@ -16,11 +16,12 @@ module Apricot
       ns
     end
 
-    attr_reader :vars, :fns
+    attr_reader :vars, :fns, :aliases
 
     def initialize
       @vars = {}
       @fns = Set[]
+      @aliases = {}
     end
 
     def set_var(name, val)
@@ -42,8 +43,24 @@ module Apricot
     def get_var(name)
       # raise may be a function defined on the namespace so we need to
       # explicitly call the Ruby raise method.
-      Kernel.raise NameError, "Undefined variable '#{name}' on #{self}" unless @vars.include? name
-      @vars[name]
+      Kernel.raise NameError,
+        "Undefined variable '#{name}' on #{self}" unless has_var? name
+
+      if var = @vars[name]
+        var
+      elsif ns = @aliases[name]
+        ns.get_var(name)
+      else
+        nil
+      end
+    end
+
+    def add_alias(name, ns)
+      @aliases[name] = ns
+    end
+
+    def has_var?(name)
+      @vars.has_key?(name) || @aliases.has_key?(name)
     end
   end
 

data/lib/apricot/{parser.rb → reader.rb}

@@ -1,63 +1,82 @@
 require 'stringio'
 
 module Apricot
-  class Parser
+  class Reader
     IDENTIFIER   = /[^'`~()\[\]{}";,\s]/
     OCTAL        = /[0-7]/
     HEX          = /[0-9a-fA-F]/
     DIGITS       = ('0'..'9').to_a + ('a'..'z').to_a
-    CHAR_ESCAPES = {"a" => "\a", "b" => "\b", "t" => "\t", "n" => "\n",
-                    "v" => "\v", "f" => "\f", "r" => "\r", "e" => "\e"}
-    REGEXP_OPTIONS = {'i' => Regexp::IGNORECASE, 'x' => Regexp::EXTENDED,
-                      'm' => Regexp::MULTILINE}
+
+    CHAR_ESCAPES = {
+      "a" => "\a", "b" => "\b", "t" => "\t", "n" => "\n",
+      "v" => "\v", "f" => "\f", "r" => "\r", "e" => "\e"
+    }
+
+    REGEXP_OPTIONS = {
+      'i' => Regexp::IGNORECASE,
+      'x' => Regexp::EXTENDED,
+      'm' => Regexp::MULTILINE
+    }
+
+    QUOTE = Identifier.intern(:quote)
+    UNQUOTE = Identifier.intern(:unquote)
+    UNQUOTE_SPLICING = Identifier.intern(:'unquote-splicing')
+    CONCAT = Identifier.intern(:concat)
+    APPLY = Identifier.intern(:apply)
+    LIST = Identifier.intern(:list)
+    FN = Identifier.intern(:fn)
 
     FnState = Struct.new(:args, :rest)
 
     # @param [IO] io an input stream object to read forms from
-    def initialize(io, filename = "(none)", line = 1)
+    def initialize(io, filename = '(none)', line = 1)
       @filename = filename
       @io = io
       @location = 0
       @line = line
 
       @fn_state = []
-      @syntax_quote_gensyms = []
+
+      # Read the first character
+      next_char
     end
 
-    def self.parse_file(filename)
-      File.open(filename) {|f| new(f, filename).parse(true) }
+    def self.read_file(filename)
+      File.open(filename) {|f| new(f, filename).read }
     end
 
-    def self.parse_string(source, filename = "(none)", line = 1)
-      new(StringIO.new(source, "r"), filename, line).parse
+    def self.read_string(source, filename = '(none)', line = 1)
+      new(StringIO.new(source), filename, line).read
     end
 
-    # @return [Array<AST::Node>] a list of the forms in the program
-    def parse(evaluate = false)
-      program = []
-      next_char
+    # Return a list of the forms that were read.
+    def read
+      forms = []
 
       skip_whitespace
       while @char
-        program << parse_form
+        forms << read_form
         skip_whitespace
       end
 
-      Apricot::AST::TopLevel.new(program, @filename, 1, evaluate)
+      forms
     end
 
-    # @return AST::Node an AST node representing the form read
-    def parse_one
-      next_char
+    def read_one
       skip_whitespace
-      parse_form
+      form = read_form
+
+      # Unget the last character because the reader always reads one character
+      # ahead.
+      @io.ungetc(@char) if @char
+
+      form
     end
 
     private
-    # Parse Lisp forms until the given character is encountered
-    # @param [String] terminator the character to stop parsing at
-    # @return [Array<AST::Node>] a list of the Lisp forms parsed
-    def parse_forms_until(terminator)
+
+    # Read forms until the given character is encountered
+    def read_forms_until(terminator)
       skip_whitespace
       forms = []
 
@@ -67,7 +86,7 @@ module Apricot
           return forms
         end
 
-        forms << parse_form
+        forms << read_form
         skip_whitespace
       end
 
@@ -75,39 +94,38 @@ module Apricot
       incomplete_error "Unexpected end of program, expected #{terminator}"
     end
 
-    # Parse a single Lisp form
-    # @return [AST::Node] an AST node representing the form
-    def parse_form
+    # Read a single Lisp form
+    def read_form
       case @char
-      when '#' then parse_dispatch
-      when "'" then parse_quote
-      when "`" then parse_syntax_quote
-      when "~" then parse_unquote
-      when '(' then parse_list
-      when '[' then parse_array
-      when '{' then parse_hash
-      when '"' then parse_string
-      when ':' then parse_symbol
-      when /\d/ then parse_number
+      when '#' then read_dispatch
+      when "'" then read_quote
+      when "`" then read_syntax_quote
+      when "~" then read_unquote
+      when '(' then read_list
+      when '[' then read_array
+      when '{' then read_hash
+      when '"' then read_string
+      when ':' then read_symbol
+      when /\d/ then read_number
       when IDENTIFIER
         if @char =~ /[+-]/ && peek_char =~ /\d/
-          parse_number
+          read_number
         else
-          parse_identifier
+          read_identifier
         end
       else syntax_error "Unexpected character: #{@char}"
       end
     end
 
-    def parse_dispatch
+    def read_dispatch
       next_char # skip #
       case @char
-      when '|' then parse_pipe_identifier
-      when '{' then parse_set
-      when '(' then parse_fn
-      when 'r' then parse_regex
-      when 'q' then parse_quotation(false)
-      when 'Q' then parse_quotation(true)
+      when '|' then read_pipe_identifier
+      when '{' then read_set
+      when '(' then read_fn
+      when 'r' then read_regex
+      when 'q' then read_quotation(false)
+      when 'Q' then read_quotation(true)
       else syntax_error "Unknown reader macro: ##{@char}"
       end
     end
@@ -126,163 +144,144 @@ module Apricot
           next_char; next_char # skip #_
           skip_whitespace
           incomplete_error "Unexpected end of program after #_, expected a form" unless @char
-          parse_form # discard next form
+          read_form # discard next form
         else
           next_char
         end
       end
     end
 
-    def parse_quote
+    def read_quote
+      line = @line
       next_char # skip the '
       skip_whitespace
       incomplete_error "Unexpected end of program after quote ('), expected a form" unless @char
 
-      form = parse_form
-      quote = AST::Identifier.new(@line, :quote)
-      AST::List.new(@line, [quote, form])
+      with_location List[QUOTE, read_form], line
     end
 
-    def parse_syntax_quote
+    def read_syntax_quote
+      line = @line
       next_char # skip the `
       skip_whitespace
       incomplete_error "Unexpected end of program after syntax quote (`), expected a form" unless @char
 
-      @syntax_quote_gensyms << {}
-      form = syntax_quote(parse_form)
-      @syntax_quote_gensyms.pop
-
-      form
+      with_location syntax_quote(read_form, {}), line
     end
 
-    def syntax_quote(form)
-      quote = AST::Identifier.new(@line, :quote)
-
+    def syntax_quote(form, gensyms)
       case form
-      when AST::List
-        if is_unquote?(form)
-          form[1]
-        elsif is_unquote_splicing?(form)
+      when Seq
+        if is_unquote? form
+          form.rest.first
+        elsif is_unquote_splicing? form
           syntax_error "splicing unquote (~@) not in list"
         else
-          concat = AST::Identifier.new(@line, :concat)
-          AST::List.new(@line, [concat] + syntax_quote_list(form.elements))
+          syntax_quote_list(form, gensyms)
         end
-      when AST::ArrayLiteral
-        syntax_quote_coll(:array, form.elements)
-      when AST::SetLiteral
-        syntax_quote_coll(:set, form.elements)
-      when AST::HashLiteral
-        syntax_quote_coll(:hash, form.elements)
-      when AST::Identifier
+      when Array
+        syntax_quote_coll(:array, form, gensyms)
+      when Set
+        syntax_quote_coll(:'hash-set', form, gensyms)
+      when Hash
+        syntax_quote_coll(:hash, form.to_a.flatten(1), gensyms)
+      when Identifier
         name = form.name
+
         if name.to_s.end_with?('#')
-          @syntax_quote_gensyms.last[name] ||= Apricot.gensym(name)
-          id = AST::Identifier.new(@line, @syntax_quote_gensyms.last[name])
-          AST::List.new(@line, [quote, id])
+          gensyms[name] ||= Apricot.gensym(name)
+          List[QUOTE, gensyms[name]]
         else
-          AST::List.new(@line, [quote, form])
+          List[QUOTE, form]
         end
-      when AST::BasicLiteral
-        form
       else
-        AST::List.new(@line, [quote, form])
+        form
       end
     end
 
-    def syntax_quote_coll(creator_name, elements)
-      apply = AST::Identifier.new(@line, :apply)
-      concat = AST::Identifier.new(@line, :concat)
-      creator = AST::Identifier.new(@line, creator_name)
-      list = AST::List.new(@line, [concat] + syntax_quote_list(elements))
-      AST::List.new(@line, [apply, creator, list])
+    def syntax_quote_coll(creator_name, elements, gensyms)
+      creator = Identifier.intern(creator_name)
+      list = syntax_quote_list(elements, gensyms)
+      List[APPLY, creator, list]
     end
 
-    def syntax_quote_list(elements)
-      list = AST::Identifier.new(@line, :list)
-
-      elements.map do |form|
-        if is_unquote?(form)
-          AST::List.new(@line, [list, form[1]])
-        elsif is_unquote_splicing?(form)
-          form[1]
+    def syntax_quote_list(elements, gensyms)
+      parts = elements.map do |form|
+        if is_unquote? form
+          List[LIST, form.rest.first]
+        elsif is_unquote_splicing? form
+          form.rest.first
         else
-          AST::List.new(@line, [list, syntax_quote(form)])
+          List[LIST, syntax_quote(form, gensyms)]
         end
       end
-    end
 
-    def is_unquote?(form)
-      form.is_a?(AST::List)          &&
-      form[0].is_a?(AST::Identifier) &&
-      form[0].name == :unquote
+      Cons.new(CONCAT, parts)
     end
 
-    def is_unquote_splicing?(form)
-      form.is_a?(AST::List)          &&
-      form[0].is_a?(AST::Identifier) &&
-      form[0].name == :'unquote-splicing'
-    end
-
-    def parse_unquote
-      unquote = :unquote
+    def read_unquote
+      line = @line
+      unquote_type = UNQUOTE
       next_char # skip the ~
 
       if @char == '@'
         next_char # skip the ~@
-        unquote = :'unquote-splicing'
+        unquote_type = UNQUOTE_SPLICING
       end
 
       skip_whitespace
 
       unless @char
-        syntax = unquote == :unquote ? '~' : '~@'
+        syntax = (unquote_type == UNQUOTE ? '~' : '~@')
         incomplete_error "Unexpected end of program after #{syntax}, expected a form"
       end
 
-      form = parse_form
-      unquote = AST::Identifier.new(@line, unquote)
-      AST::List.new(@line, [unquote, form])
+      with_location List[unquote_type, read_form], line
     end
 
-    def parse_fn
+    def read_fn
+      line = @line
+
       @fn_state << FnState.new([], nil)
-      body = parse_list
+      body = read_list
       state = @fn_state.pop
 
-      state.args << :'&' << state.rest if state.rest
+      state.args << Identifier.intern(:'&') << state.rest if state.rest
+
       args = state.args.map.with_index do |x, i|
-        AST::Identifier.new(body.line, x || Apricot.gensym("p#{i + 1}"))
+        x || Apricot.gensym("p#{i + 1}")
       end
 
-      AST::List.new(body.line, [AST::Identifier.new(body.line, :fn),
-                                AST::ArrayLiteral.new(body.line, args),
-                                body])
+      with_location List[FN, args, body], line
     end
 
-    def parse_list
+    def read_list
+      line = @line
       next_char # skip the (
-      AST::List.new(@line, parse_forms_until(')'))
+      with_location read_forms_until(')').to_list, line
     end
 
-    def parse_array
+    def read_array
+      line = @line
       next_char # skip the [
-      AST::ArrayLiteral.new(@line, parse_forms_until(']'))
+      with_location read_forms_until(']'), line
     end
 
-    def parse_hash
+    def read_hash
+      line = @line
       next_char # skip the {
-      forms = parse_forms_until('}')
+      forms = read_forms_until('}')
       syntax_error "Odd number of forms in key-value hash" if forms.count.odd?
-      AST::HashLiteral.new(@line, forms)
+      with_location hashify(forms), line
     end
 
-    def parse_set
+    def read_set
+      line = @line
       next_char # skip the {
-      AST::SetLiteral.new(@line, parse_forms_until('}'))
+      with_location read_forms_until('}').to_set, line
     end
 
-    def parse_string
+    def read_string
       line = @line
       next_char # skip the opening "
       string = ""
@@ -290,38 +289,41 @@ module Apricot
       while @char
         if @char == '"'
           next_char # consume the "
-          return AST::StringLiteral.new(line, string)
+          return with_location string, line
         end
 
-        string << parse_string_char
+        string << read_string_char
       end
 
       # Can only reach here if we run out of chars without getting a "
       incomplete_error "Unexpected end of program while parsing string"
     end
 
-    def parse_string_char
-      char = if @char == "\\"
-               next_char
-               if CHAR_ESCAPES.has_key?(@char)
-                 CHAR_ESCAPES[consume_char]
-               elsif @char =~ OCTAL
-                 char_escape_helper(8, OCTAL, 3)
-               elsif @char == 'x'
-                 next_char
-                 syntax_error "Invalid hex character escape" unless @char =~ HEX
-                 char_escape_helper(16, HEX, 2)
-               else
-                 consume_char
-               end
-             else
-               consume_char
-             end
+    def read_string_char
+      char =
+        if @char == "\\"
+          next_char
+          if CHAR_ESCAPES.has_key?(@char)
+            CHAR_ESCAPES[consume_char]
+          elsif @char =~ OCTAL
+            char_escape_helper(8, OCTAL, 3)
+          elsif @char == 'x'
+            next_char
+            syntax_error "Invalid hex character escape" unless @char =~ HEX
+            char_escape_helper(16, HEX, 2)
+          else
+            consume_char
+          end
+        else
+          consume_char
+        end
+
       incomplete_error "Unexpected end of file while parsing character escape" unless char
+
       char
     end
 
-    # Parse digits in a certain base for string character escapes
+    # Read digits in a certain base for string character escapes
     def char_escape_helper(base, regex, n)
       number = ""
 
@@ -334,20 +336,10 @@ module Apricot
       number.to_i(base).chr
     end
 
-    def delimiter_helper(c)
-      case c
-      when '(' then ')'
-      when '[' then ']'
-      when '{' then '}'
-      when '<' then '>'
-      else c
-      end
-    end
-
-    def parse_regex
+    def read_regex
       line = @line
       next_char # skip the r
-      delimiter = delimiter_helper(@char)
+      delimiter = opposite_delimiter(@char)
       next_char # skip delimiter
       regex = ""
 
@@ -355,7 +347,7 @@ module Apricot
         if @char == delimiter
           next_char # consume delimiter
           options = regex_options_helper
-          return AST::RegexLiteral.new(line, regex, options)
+          return with_location Regexp.new(regex, options), line
         elsif @char == "\\" && peek_char == delimiter
           next_char
         elsif @char == "\\" && peek_char == "\\"
@@ -383,21 +375,21 @@ module Apricot
       options
     end
 
-    def parse_quotation(double_quote)
+    def read_quotation(double_quote)
       line = @line
       next_char # skip the prefix
-      delimiter = delimiter_helper(@char)
+      delimiter = opposite_delimiter(@char)
       next_char # skip delimiter
       string = ""
 
       while @char
         if @char == delimiter
           next_char # consume delimiter
-          return AST::StringLiteral.new(line, string)
+          return with_location string, line
         end
 
         if double_quote
-          string << parse_string_char
+          string << read_string_char
         elsif @char == "\\" && (peek_char == delimiter || peek_char == "\\")
           next_char
           string << consume_char
@@ -409,7 +401,7 @@ module Apricot
       incomplete_error "Unexpected end of program while parsing quotation"
     end
 
-    def parse_symbol
+    def read_symbol
       line = @line
       next_char # skip the :
       symbol = ""
@@ -418,7 +410,7 @@ module Apricot
         next_char # skip opening "
         while @char
           break if @char == '"'
-          symbol << parse_string_char
+          symbol << read_string_char
         end
         incomplete_error "Unexpected end of program while parsing symbol" unless @char == '"'
         next_char # skip closing "
@@ -431,10 +423,10 @@ module Apricot
         syntax_error "Empty symbol name" if symbol.empty?
       end
 
-      AST::SymbolLiteral.new(line, symbol.to_sym)
+      symbol.to_sym
     end
 
-    def parse_number
+    def read_number
       number = ""
 
       while @char =~ IDENTIFIER
@@ -444,22 +436,23 @@ module Apricot
 
       case number
       when /^[+-]?\d+$/
-        AST.new_integer(@line, number.to_i)
+        number.to_i
       when /^([+-]?)(\d+)r([a-zA-Z0-9]+)$/
         sign, radix, digits = $1, $2.to_i, $3
         syntax_error "Radix out of range: #{radix}" unless 2 <= radix && radix <= 36
         syntax_error "Invalid digits for radix in number: #{number}" unless digits.downcase.chars.all? {|d| DIGITS[0..radix-1].include?(d) }
-        AST.new_integer(@line, (sign + digits).to_i(radix))
+        (sign + digits).to_i(radix)
       when /^[+-]?\d+\.?\d*(?:e[+-]?\d+)?$/
-        AST::FloatLiteral.new(@line, number.to_f)
+        number.to_f
       when /^([+-]?\d+)\/(\d+)$/
-        AST::RationalLiteral.new(@line, $1.to_i, $2.to_i)
+        Rational($1.to_i, $2.to_i)
       else
         syntax_error "Invalid number: #{number}"
       end
     end
 
-    def parse_identifier
+    def read_identifier
+      line = @line
       identifier = ""
 
       while @char =~ IDENTIFIER
@@ -467,32 +460,33 @@ module Apricot
         next_char
       end
 
+      case identifier
+      when 'true'  then return true
+      when 'false' then return false
+      when 'nil'   then return nil
+      end
+
+      state = @fn_state.last
+
       # Handle % identifiers in #() syntax
-      if (state = @fn_state.last) && identifier[0] == '%'
-        identifier = case identifier[1..-1]
+      if state && identifier[0] == '%'
+        case identifier[1..-1]
         when '' # % is equivalent to %1
-          state.args[0] ||= Apricot.gensym('p1')
+          state.args[0] ||= with_location Apricot.gensym('p1'), line
         when '&'
-          state.rest ||= Apricot.gensym('rest')
+          state.rest ||= with_location Apricot.gensym('rest'), line
         when /^[1-9]\d*$/
           n = identifier[1..-1].to_i
-          state.args[n - 1] ||= Apricot.gensym("p#{n}")
+          state.args[n - 1] ||= with_location Apricot.gensym("p#{n}"), line
         else
           syntax_error "arg literal must be %, %& or %integer"
         end
       else
-        identifier = identifier.to_sym
-      end
-
-      case identifier
-      when :true, :false, :nil
-        AST::Literal.new(@line, identifier)
-      else
-        AST::Identifier.new(@line, identifier)
+        with_location Identifier.intern(identifier), line
       end
     end
 
-    def parse_pipe_identifier
+    def read_pipe_identifier
       line = @line
       next_char # skip the |
       identifier = ""
@@ -500,10 +494,10 @@ module Apricot
       while @char
         if @char == '|'
           next_char # consume the |
-          return AST::Identifier.new(line, identifier.to_sym)
+          return with_location Identifier.intern(identifier), line
         end
 
-        identifier << parse_string_char
+        identifier << read_string_char
       end
 
       incomplete_error "Unexpected end of program while parsing pipe identifier"
@@ -537,5 +531,38 @@ module Apricot
     def incomplete_error(message)
       raise SyntaxError.new(@filename, @line, message, true)
     end
+
+    def with_location(obj, line)
+      obj.apricot_meta = {line: line}
+      obj
+    end
+
+    def cons(head, tail)
+      tail.cons(head)
+    end
+
+    def is_unquote?(form)
+      form.is_a?(Seq) && form.first == UNQUOTE
+    end
+
+    def is_unquote_splicing?(form)
+      form.is_a?(Seq) && form.first == UNQUOTE_SPLICING
+    end
+
+    def hashify(array)
+      array.each_slice(2).with_object({}) do |(key, value), hash|
+        hash[key] = value
+      end
+    end
+
+    def opposite_delimiter(c)
+      case c
+      when '(' then ')'
+      when '[' then ']'
+      when '{' then '}'
+      when '<' then '>'
+      else c
+      end
+    end
   end
 end