Implement lambdas

lib/chervil/ast/list.rb

         []
       else
         head = @elements.first
-        if head.class == Identifier
+        if head.is_a?(Identifier)
           function = env.get(head.name)
 
           if function.nil?
           else
             function.call(@elements[1..-1].map { |arg| arg.evaluate(env) }, env)
           end
+        elsif head.is_a?(Function)
+          head.call(@elements[1..-1].map { |arg| arg.evaluate(env) }, env)
         else
           @elements.map { |el| el.evaluate(env) }
         end

lib/chervil/parser.rb

           return definition
         elsif @current_token.value == 'if'
           return conditional
+        elsif @current_token.value == 'lambda'
+          return lambda_
         end
       end
 
       AST::Conditional.new(predicate, true_branch, false_branch)
     end
 
+    def lambda_
+      eat(:identifier) # the `lambda`
+
+      name = AST::Identifier.new("lambda")
+      params = Array.new
+
+      eat(:lparen)
+      while @current_token.type == :identifier
+        params.push(identifier)
+      end
+      eat(:rparen)
+
+      body = Array.new
+      until [:rparen, :eof].include?(@current_token.type)
+        body << expr
+      end
+
+      eat(:rparen)
+
+      AST::Function.new(name, params, body)
+    end
+
     def identifier
       identifier = eat(:identifier)
       AST::Identifier.new(identifier.value)

spec/ast/list_spec.rb

         .evaluate(env))
         .to eq(Error.new("Unbound variable x"))
     end
+
+    it 'applies a function in the first position' do
+      env = Env.new
+      list = AST::List.new(
+        [
+          AST::Function.new(
+            AST::Identifier.new("lambda"),
+            [AST::Identifier.new("x")],
+            [
+              AST::List.new(
+                [
+                  AST::Identifier.new("+"),
+                  AST::Identifier.new("x"),
+                  AST::Number.new(1.0),
+                ]
+              )
+            ]
+          ),
+          AST::Number.new(5.0),
+        ]
+      )
+
+      expect(list.evaluate(env)).to eq(6.0)
+    end
   end
 end

spec/parser_spec.rb

         )
       )
     end
+
+    it 'parses a lambda expression' do
+      expect(parse('(lambda (x) (* x x))').first).to eq(
+        AST::Function.new(
+          AST::Identifier.new("lambda"),
+          [AST::Identifier.new("x")],
+          [
+            AST::List.new(
+              [
+                AST::Identifier.new("*"),
+                AST::Identifier.new("x"),
+                AST::Identifier.new("x"),
+              ]
+            ),
+          ]
+        )
+      )
+    end
   end
 end