Replace Application with List

I see what I was going for with the Application AST node but
Chervil is a Lisp after all and lists are the fundamental data
structure. The direct reason I wanted to do this was for quoted values,
since a quoted list isn't an application.

lib/chervil/ast.rb

 
 module Chervil
   module AST
-    require "chervil/ast/application"
     require "chervil/ast/boolean"
     require "chervil/ast/conditional"
     require "chervil/ast/definition"
     require "chervil/ast/function"
     require "chervil/ast/identifier"
+    require "chervil/ast/list"
     require "chervil/ast/number"
     require "chervil/ast/string"
   end

lib/chervil/ast/application.rb

-module Chervil::AST
-  class Application
-    attr_reader :expr
-    attr_reader :arguments
-
-    def initialize(expr, arguments)
-      @expr = expr
-      @arguments = arguments
-    end
-
-    def ==(other)
-      @expr == other.expr && @arguments == other.arguments
-    end
-
-    def evaluate(env)
-      if @expr.class == Identifier
-        function = env.get(@expr.name)
-
-        if function.nil?
-          ::Chervil::Error.new("Unbound variable #{@expr.name}")
-        else
-          function.call(@arguments.map { |arg| arg.evaluate(env) }, env)
-        end
-      end
-    end
-  end
-end

lib/chervil/ast/list.rb

+module Chervil::AST
+  class List
+    attr_reader :elements
+
+    def initialize(elements)
+      @elements = elements
+    end
+
+    def ==(other)
+      @elements == other.elements
+    end
+
+    def evaluate(env)
+      if elements.empty?
+        []
+      else
+        head = @elements.first
+        if head.class == Identifier
+          function = env.get(head.name)
+
+          if function.nil?
+            ::Chervil::Error.new("Unbound variable #{head.name}")
+          else
+            function.call(@elements[1..-1].map { |arg| arg.evaluate(env) }, env)
+          end
+        end
+      end
+    end
+  end
+end

lib/chervil/parser.rb

       elsif @current_token.type == :identifier
         identifier
       elsif @current_token.type == :lparen
-        application
+        list
       else
         @error = Error.new("Unexpected token #{@current_token.type}: #{@current_token.value}")
       end
     end
 
-    def application
+    def list
       eat(:lparen)
 
       if @current_token.type == :identifier
         end
       end
 
-      expression = expr
-
-      args = Array.new
+      elements = Array.new
       until @current_token.type == :rparen || @current_token.type == :eof
-        args << expr
+        elements << expr
       end
 
       eat(:rparen)
 
-      AST::Application.new(expression, args)
+      AST::List.new(elements)
     end
 
     def definition

spec/ast/application_spec.rb

-module Chervil
-  RSpec.describe AST::Application do
-    it 'evaluates addition' do
-      env = Env.new
-      expect(
-        AST::Application.new(
-          AST::Identifier.new('+'),
-          [AST::Number.new(1.0), AST::Number.new(2.0)]
-        )
-          .evaluate(env)
-      ).to eq(3.0)
-    end
-
-    it 'evaluates nested arithmetic' do
-      env = Env.new
-      expect(
-        AST::Application.new(
-          AST::Identifier.new('+'),
-          [
-            AST::Application.new(
-              AST::Identifier.new('+'),
-              [AST::Number.new(1.0), AST::Number.new(2.0)]
-            ),
-            AST::Application.new(
-              AST::Identifier.new('+'),
-              [AST::Number.new(3.0), AST::Number.new(4.0)]
-            )
-          ]
-        )
-          .evaluate(env)
-      ).to eq(10.0)
-    end
-
-    it 'returns an error if the function is not defined' do
-      env = Env.new
-      expect(AST::Application.new(AST::Identifier.new("x"), []).evaluate(env)).to eq(
-        Error.new("Unbound variable x")
-      )
-    end
-  end
-end

spec/ast/conditional_spec.rb

 
     it 'evaluates complex predicates' do
       expect(AST::Conditional.new(
-        AST::Application.new(
-          AST::Identifier.new(">"),
+        AST::List.new(
           [
+            AST::Identifier.new(">"),
             AST::Number.new(2.0),
             AST::Number.new(1.0),
           ]
     it 'evaluates complex branches' do
       expect(AST::Conditional.new(
         AST::Boolean.new(true),
-        AST::Application.new(
-          AST::Identifier.new("+"),
+        AST::List.new(
           [
+            AST::Identifier.new("+"),
             AST::Number.new(2.0),
             AST::Number.new(1.0),
           ]

spec/ast/function_spec.rb

             AST::Identifier.new("x")
           ],
           [
-            AST::Application.new(
-              AST::Identifier.new("*"),
+            AST::List.new(
               [
+                AST::Identifier.new("*"),
                 AST::Identifier.new("x"),
                 AST::Identifier.new("x")
               ]

spec/ast/list_spec.rb

+module Chervil
+  RSpec.describe AST::List do
+    it 'evaluates addition' do
+      env = Env.new
+      expect(
+        AST::List.new(
+          [AST::Identifier.new('+'),
+          AST::Number.new(1.0), AST::Number.new(2.0)]
+        )
+          .evaluate(env)
+      ).to eq(3.0)
+    end
+
+    it 'evaluates nested arithmetic' do
+      env = Env.new
+      expect(
+        AST::List.new(
+          [
+            AST::Identifier.new('+'),
+            AST::List.new(
+              [
+                AST::Identifier.new('+'),
+                AST::Number.new(1.0),
+                AST::Number.new(2.0)
+              ]
+            ),
+            AST::List.new(
+              [
+                AST::Identifier.new('+'),
+                AST::Number.new(3.0),
+                AST::Number.new(4.0)
+              ]
+            )
+          ]
+        )
+          .evaluate(env)
+      ).to eq(10.0)
+    end
+
+    it 'returns an error if the function is not defined' do
+      env = Env.new
+      expect(AST::List.new([AST::Identifier.new("x")])
+        .evaluate(env))
+        .to eq(Error.new("Unbound variable x"))
+    end
+  end
+end

spec/interpreter_spec.rb

       expect(interpret('(plus-one 2)', env).first).to eq(3.0)
     end
 
-    it 'doesn\'t leave variables bound after function execution' do
+    it "doesn't leave variables bound after function execution" do
       env = Env.new
       interpret('(define (plus-one x) (+ 1 x))', env)
       interpret('(plus-one 5)', env)
 
     it 'returns a type error for invalid operation' do
       expect(interpret('(+ 1 "hello")', Env.new).first).to eq(
-        Error.new("Expected an argument of type number but got string")
+        Error.new('Expected an argument of type number but got string')
       )
     end
   end

spec/parser_spec.rb

 
     it 'parses an application' do
       expect(parse('(+ 1 2)').first).to eq(
-        AST::Application.new(
-          AST::Identifier.new('+'),
-          [AST::Number.new(1.0), AST::Number.new(2.0)]
+        AST::List.new(
+          [AST::Identifier.new('+'), AST::Number.new(1.0), AST::Number.new(2.0)]
         )
       )
     end
 
     it 'parses a nested expression' do
       expect(parse('(+ (+ 1 2) (- 3 4))').first).to eq(
-        AST::Application.new(
-          AST::Identifier.new('+'),
+        AST::List.new(
           [
-            AST::Application.new(
-              AST::Identifier.new('+'),
-              [AST::Number.new(1.0), AST::Number.new(2.0)]
+            AST::Identifier.new('+'),
+            AST::List.new(
+              [
+                AST::Identifier.new('+'),
+                AST::Number.new(1.0),
+                AST::Number.new(2.0)
+              ]
             ),
-            AST::Application.new(
-              AST::Identifier.new('-'),
-              [AST::Number.new(3.0), AST::Number.new(4.0)]
+            AST::List.new(
+              [
+                AST::Identifier.new('-'),
+                AST::Number.new(3.0),
+                AST::Number.new(4.0)
+              ]
             )
           ]
         )
             AST::Identifier.new('square'),
             [AST::Identifier.new('x')],
             [
-              AST::Application.new(
-                AST::Identifier.new('*'),
-                [AST::Identifier.new('x'), AST::Identifier.new('x')]
+              AST::List.new(
+                [
+                  AST::Identifier.new('*'),
+                  AST::Identifier.new('x'),
+                  AST::Identifier.new('x')
+                ]
               )
             ]
           )