Parse function definitions

lib/chervil/ast.rb

     require "chervil/ast/application"
     require "chervil/ast/boolean"
     require "chervil/ast/definition"
+    require "chervil/ast/function"
     require "chervil/ast/identifier"
     require "chervil/ast/number"
     require "chervil/ast/string"

lib/chervil/ast/function.rb

+module Chervil::AST
+  class Function
+    attr_reader :params
+    attr_reader :body
+
+    def initialize(params, body)
+      @params = params
+      @body = body
+    end
+
+    def ==(other)
+      @params == other.params && @body == other.body
+    end
+  end
+end

lib/chervil/parser.rb

       eat(:lparen)
 
       if @current_token.type == :identifier && @current_token.value == 'define'
-        eat(:identifier)
-        name = identifier
-        value = expr
-        eat(:rparen)
-        return AST::Definition.new(name, value)
+        return definition
       end
 
       expression = expr
       AST::Application.new(expression, args)
     end
 
+    def definition
+      eat(:identifier) # the `define`
+      if @current_token.type == :identifier
+        name = identifier
+        value = expr
+        eat(:rparen)
+        AST::Definition.new(name, value)
+      elsif @current_token.type == :lparen
+        eat(:lparen)
+        name = identifier
+        params = Array.new
+        until [:rparen, :eof].include?(@current_token.type)
+          params << expr
+        end
+        eat(:rparen)
+
+        body = Array.new
+        until [:rparen, :eof].include?(@current_token.type)
+          body << expr
+        end
+
+        eat(:rparen)
+
+        AST::Definition.new(name, AST::Function.new(params, body))
+      end
+    end
+
     def identifier
       identifier = eat(:identifier)
       AST::Identifier.new(identifier.value)

spec/parser_spec.rb

       expect(parse('+').first).to eq(AST::Identifier.new('+'))
     end
 
+    it 'parses booleans' do
+      expect(parse('#t #f')).to eq(
+        [
+          AST::Boolean.new(true),
+          AST::Boolean.new(false),
+        ]
+      )
+    end
+
     it 'parses an application' do
       expect(parse('(+ 1 2)').first).to eq(
         AST::Application.new(
       )
     end
 
-    it 'parses booleans' do
-      expect(parse('#t #f')).to eq(
-        [
-          AST::Boolean.new(true),
-          AST::Boolean.new(false),
-        ]
+    it 'parses a function definition' do
+      expect(parse('(define (square x) (* x x))').first).to eq(
+        AST::Definition.new(
+          AST::Identifier.new("square"),
+          AST::Function.new(
+            [
+              AST::Identifier.new("x")
+            ],
+            [
+              AST::Application.new(
+                AST::Identifier.new("*"),
+                [
+                  AST::Identifier.new("x"),
+                  AST::Identifier.new("x"),
+                ]
+              )
+            ]
+          )
+        )
       )
     end
   end