Allow recursive functions & closures

lib/chervil/ast/application.rb

         if function.nil?
           ::Chervil::Error.new("Unbound variable #{@expr.name}")
         else
-          function.call(@arguments.map { |arg| arg.evaluate(env) })
+          function.call(@arguments.map { |arg| arg.evaluate(env) }, env)
         end
       end
     end

lib/chervil/ast/function.rb

       self
     end
 
-    def call(args)
+    def call(args, env)
       unless @params.size == args.size
         raise "Expected #{params.size} arguments but received #{args.size}"
       end
 
-      env = ::Chervil::Env.new
       @params.zip(args).each do |key, value|
         env.set(key.name, value)
       end

spec/ast/function_spec.rb

             )
           ],
         ).call(
-          [AST::Number.new(5.0)]
+          [AST::Number.new(5.0)],
+          Env.new
         )
       ).to eq(25.0)
     end

spec/env_spec.rb

   RSpec.describe Env do
     it 'has arithmetic from core' do
       env = Env.new
-      expect(env.get("+").call([1, 2])).to eq(3)
+      expect(env.get("+").call([1, 2], env)).to eq(3)
     end
 
     it 'inherits from parent env' do

spec/interpreter_spec.rb

       expect(env.get("x")).to eq(AST::Number.new(5.0))
       expect(interpret('x', env).first).to eq(5.0)
     end
+
+    it 'interprets a recursive function' do
+      env = Env.new
+      interpret('(define (fact x) (if (= x 0) 1 (* x (fact (- x 1)))))', env)
+      expect(interpret('(fact 5)', env).first).to eq(120.0)
+    end
+
+    it 'supports closures' do
+      env = Env.new
+      interpret('(define one 1)', env)
+      interpret('(define (plus-one x) (+ x one))', env)
+      expect(interpret('(plus-one 2)', env).first).to eq(3.0)
+    end
   end
 end