apricot 0.0.1 → 0.0.2

data/lib/apricot/special_forms/if.rb

@@ -0,0 +1,31 @@
+module Apricot
+  # (if cond body else_body?)
+  SpecialForm.define(:if) do |g, args|
+    g.compile_error "Too few arguments to if" if args.count < 2
+    g.compile_error "Too many arguments to if" if args.count > 3
+
+    cond, body, else_body = *args
+    else_label = g.new_label
+    end_label = g.new_label
+
+    tail_position = g.tail_position?
+
+    g.tail_position = false
+    Compiler.bytecode(g, cond)
+    g.gif else_label
+
+    g.tail_position = tail_position
+    Compiler.bytecode(g, body)
+    g.goto end_label
+
+    g.tail_position = tail_position
+    else_label.set!
+    if else_body
+      Compiler.bytecode(g, else_body)
+    else
+      g.push_nil
+    end
+
+    end_label.set!
+  end
+end

data/lib/apricot/special_forms/let.rb

@@ -0,0 +1,8 @@
+module Apricot
+  # (let [binding*] body*) where binding is an identifier followed by a value
+  SpecialForm.define(:let) do |g, args|
+    # loop and let share a lot of code. See special_forms.rb for the shared
+    # definition.
+    let(g, args, :let)
+  end
+end

data/lib/apricot/special_forms/loop.rb

@@ -0,0 +1,10 @@
+module Apricot
+  # (loop [binding*] body*) where binding is an identifier followed by a value
+  # Just like let but also introduces a loop target for (recur ...)
+  SpecialForm.define(:loop) do |g, args|
+    # loop and let share a lot of code. See special_forms.rb for the shared
+    # definition.
+    g.tail_position = true
+    let(g, args, :loop)
+  end
+end

data/lib/apricot/special_forms/quote.rb

@@ -0,0 +1,9 @@
+module Apricot
+  # (quote form)
+  SpecialForm.define(:quote) do |g, args|
+    g.compile_error "Too few arguments to quote" if args.count < 1
+    g.compile_error "Too many arguments to quote" if args.count > 1
+
+    Compiler.bytecode(g, args.first, true)
+  end
+end

data/lib/apricot/special_forms/recur.rb

@@ -0,0 +1,26 @@
+module Apricot
+  # (recur args*)
+  # Rebinds the arguments of the nearest enclosing loop or fn and jumps to the
+  # top of the loop/fn. Argument rebinding is done in parallel (rebinding a
+  # variable in a recur will not affect uses of that variable in the other
+  # recur bindings.)
+  SpecialForm.define(:recur) do |g, args|
+    target = g.scope.find_recur_target
+    g.compile_error "No recursion target found for recur" unless target
+
+    g.compile_error "Can only recur from tail position" unless g.tail_position?
+
+    vars = target.variables.values
+    g.compile_error "Arity of recur does not match enclosing loop or fn" unless vars.length == args.count
+
+    args.each {|arg| Compiler.bytecode(g, arg) }
+
+    vars.reverse_each do |var|
+      g.set_local var
+      g.pop
+    end
+
+    g.check_interrupts
+    g.goto target.loop_label
+  end
+end

data/lib/apricot/special_forms/try.rb

@@ -0,0 +1,146 @@
+module Apricot
+  # (try body* (rescue name|[name condition*] body*)* (ensure body*)?)
+  SpecialForm.define(:try) do |g, args|
+    body = []
+    rescue_clauses = []
+    ensure_clause = nil
+
+    args.each do |arg|
+      g.compile_error "Unexpected form after ensure clause" if ensure_clause
+
+      if arg.is_a?(Seq) && arg.first == Identifier.intern(:rescue)
+        rescue_clauses << arg.rest
+      elsif arg.is_a?(Seq) && arg.first == Identifier.intern(:ensure)
+        ensure_clause = arg.rest
+      else
+        g.compile_error "Unexpected form after rescue clause" unless rescue_clauses.empty?
+        body << arg
+      end
+    end
+
+    # Set up ensure
+    if ensure_clause
+      ensure_ex = g.new_label
+      ensure_ok = g.new_label
+      g.setup_unwind ensure_ex, 1
+    end
+
+    ex = g.new_label
+    done = g.new_label
+
+    g.push_exception_state
+    ex_state = g.new_stack_local
+    g.set_stack_local ex_state
+    g.pop
+
+    # Evaluate body
+    g.setup_unwind ex, 0
+    SpecialForm[:do].bytecode(g, body)
+    g.pop_unwind
+    g.goto done
+
+    # Body raised an exception
+    ex.set!
+
+    # Save exception state for re-raise
+    g.push_exception_state
+    raised_ex_state = g.new_stack_local
+    g.set_stack_local raised_ex_state
+    g.pop
+
+    # Push exception for rescue conditions
+    g.push_current_exception
+
+    rescue_clauses.each do |clause|
+      # Parse either (rescue e body) or (rescue [e Exception*] body)
+      if clause.first.is_a? Identifier
+        name, clause = clause.first, clause.rest
+        conditions = []
+      elsif clause.first.is_a? Array
+        conditions, clause = clause.first, clause.rest
+        name = conditions.shift
+        g.compile_error "Expected identifier as first form of rescue clause binding" unless name.is_a? Identifier
+      else
+        g.compile_error "Expected identifier or array as first form of rescue clause"
+      end
+
+      # Default to StandardError for (rescue e body) and (rescue [e] body)
+      conditions << Identifier.intern(:StandardError) if conditions.empty?
+
+      body = g.new_label
+      next_rescue = g.new_label
+
+      conditions.each do |cond|
+        g.dup # The exception
+        Compiler.bytecode(g, cond)
+        g.swap
+        g.send :===, 1
+        g.git body
+      end
+      g.goto next_rescue
+
+      # This rescue condition matched
+      body.set!
+
+      # Create a new scope to hold the exception
+      scope = LetScope.new(g.scope)
+      g.scopes << scope
+
+      # Exception is still on the stack
+      g.set_local scope.new_local(name)
+      g.pop
+
+      SpecialForm[:do].bytecode(g, clause)
+
+      # Yay!
+      g.clear_exception
+      g.goto done
+
+      g.scopes.pop
+
+      # Rescue condition did not match
+      next_rescue.set!
+    end
+
+    # No rescue conditions matched, re-raise
+    g.pop # The exception
+
+    # Re-raise the original exception
+    g.push_stack_local raised_ex_state
+    g.restore_exception_state
+    g.reraise
+
+    # Body executed without exception or was rescued
+    done.set!
+
+    g.push_stack_local raised_ex_state
+    g.restore_exception_state
+
+    if ensure_clause
+      g.pop_unwind
+      g.goto ensure_ok
+
+      # Body raised an exception
+      ensure_ex.set!
+
+      # Execute ensure clause
+      g.push_exception_state
+      ensure_clause.each do |expr|
+        Compiler.bytecode(g, expr)
+        g.pop # Ensure cannot return anything
+      end
+      g.restore_exception_state
+
+      g.reraise
+
+      # Body executed without exception or was rescued
+      ensure_ok.set!
+
+      # Execute ensure clause
+      ensure_clause.each do |expr|
+        Compiler.bytecode(g, expr)
+        g.pop
+      end
+    end
+  end
+end

data/lib/apricot/variables.rb

@@ -0,0 +1,65 @@
+module Apricot
+  class LocalReference
+    attr_reader :slot, :depth
+
+    def initialize(slot, depth = 0)
+      @slot = slot
+      @depth = depth
+    end
+
+    def bytecode(g)
+      if @depth == 0
+        g.push_local @slot
+      else
+        g.push_local_depth @depth, @slot
+      end
+    end
+  end
+
+  class QualifiedReference
+    def initialize(name, qualifier)
+      unless qualifier.is_a? Module # Namespaces are Modules as well.
+        raise ArgumentError, "qualifier for #{self.class} must be a Namespace or Module"
+      end
+
+      @name = name
+      @qualifier = qualifier
+      @on_namespace = qualifier.is_a? Namespace
+    end
+
+    def bytecode(g)
+      if @qualifier.is_a?(Namespace) && !@qualifier.has_var?(@name)
+        g.compile_error "Unable to resolve name #{@name} in namespace #{@qualifier}"
+      end
+
+      ns_id = Identifier.intern(@qualifier.name)
+      g.push_const ns_id.const_names.first
+      ns_id.const_names.drop(1).each {|n| g.find_const(n) }
+
+      g.push_literal @name
+
+      if on_namespace?
+        g.send :get_var, 1
+      else # @qualifier is a regular Ruby module
+        g.send :method, 1
+      end
+    end
+
+    def on_namespace?
+      @on_namespace
+    end
+
+    def meta
+      on_namespace? && @qualifier.vars[@name] &&
+        @qualifier.vars[@name].apricot_meta
+    end
+
+    def fn?
+      on_namespace? && @qualifier.fns.include?(@name)
+    end
+
+    def method?
+      !on_namespace? && @qualifier.respond_to?(@name)
+    end
+  end
+end

data/lib/apricot/version.rb

@@ -1,3 +1,3 @@
 module Apricot
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/spec/compiler_spec.rb

@@ -1,499 +1,102 @@
 describe 'Apricot' do
-  def apricot(code)
-    Apricot::Compiler.eval code
-  end
-
-  def bad_apricot(code)
-    expect { apricot(code) }.to raise_error(CompileError)
-  end
+  include CompilerSpec
 
   it 'compiles an empty program' do
-    apricot('').should == nil
+    apr('').should == nil
   end
 
   it 'compiles false, true and nil' do
-    apricot('true').should == true
-    apricot('false').should == false
-    apricot('nil').should == nil
+    apr('true').should == true
+    apr('false').should == false
+    apr('nil').should == nil
   end
 
   it 'compiles numbers' do
-    apricot('1').should == 1
-    apricot('1.0').should == 1.0
-    apricot('1/3').should == Rational(1, 3)
+    apr('1').should == 1
+    apr('1.0').should == 1.0
+    apr('1/3').should == Rational(1, 3)
   end
 
   it 'compiles symbols' do
-    apricot(':foo').should == :foo
+    apr(':foo').should == :foo
+  end
+
+  it "doesn't mix up symbols and keywords in lists" do
+    # There once was a bug where :true would get compiled as the value true.
+    apr('(.class :true)').should == Symbol
   end
 
   it 'compiles strings' do
-    apricot('"foo"').should == "foo"
+    apr('"foo"').should == "foo"
   end
 
   it 'compiles regexes' do
-    apricot('#r"foo"').should == /foo/
-    apricot('#r/foo/x').should == /foo/x
-    apricot('#r[foo]xim').should == /foo/xim
+    apr('#r"foo"').should == /foo/
+    apr('#r/foo/x').should == /foo/x
+    apr('#r[foo]xim').should == /foo/xim
   end
 
   it 'compiles arrays' do
-    apricot('[]').should == []
-    apricot('[1 2 3]').should == [1, 2, 3]
+    apr('[]').should == []
+    apr('[1 2 3]').should == [1, 2, 3]
   end
 
   it 'compiles hashes' do
-    apricot('{}').should == {}
-    apricot('{:foo 1, :bar 2}').should == {:foo => 1, :bar => 2}
+    apr('{}').should == {}
+    apr('{:foo 1, :bar 2}').should == {:foo => 1, :bar => 2}
   end
 
   it 'compiles sets' do
-    apricot('#{}').should == Set.new
-    apricot('#{:foo :foo :bar}').should == Set[:foo, :foo, :bar]
+    apr('#{}').should == Set.new
+    apr('#{:foo :foo :bar}').should == Set[:foo, :foo, :bar]
   end
 
   it 'compiles constants' do
-    apricot('Array').should == Array
-    apricot('Rubinius::Compiler').should == Rubinius::Compiler
+    apr('Array').should == Array
+    apr('Enumerable::Enumerator').should == Enumerable::Enumerator
   end
 
   it 'compiles call forms with data structures' do
-    apricot('([:a :b] 1)').should == :b
-    apricot('([:a :b] 3)').should == nil
-    apricot('(#{:a :b} :b)').should == :b
-    apricot('(#{:a :b} :c)').should == nil
-    apricot('({:a 1} :a)').should == 1
-    apricot('({:a 1} :b)').should == nil
+    apr('([:a :b] 1)').should == :b
+    apr('([:a :b] 3)').should == nil
+    apr('(#{:a :b} :b)').should == :b
+    apr('(#{:a :b} :c)').should == nil
+    apr('({:a 1} :a)').should == 1
+    apr('({:a 1} :b)').should == nil
   end
 
   it 'compiles symbol call forms' do
-    apricot('(:a {:a 1 :b 2})').should == 1
-    apricot('(:c {:a 1 :b 2})').should == nil
-    apricot('(:a #{:a :b})').should == :a
-    apricot('(:c #{:a :b})').should == nil
-  end
-
-  it 'compiles send forms' do
-    apricot('(. 1 class)').should == Fixnum
-    apricot('(. 1 (class))').should == Fixnum
-    apricot('(. "foo" append "bar")').should == "foobar"
-    apricot('(. "foo" (append "bar"))').should == "foobar"
-  end
-
-  it 'compiles send forms with block args' do
-    apricot('(. [1 2 3] map | :to_s)').should == ['1', '2', '3']
-    apricot('(. [1 2 3] (map | :to_s))').should == ['1', '2', '3']
-    apricot('(. [1 2 3] map | #(. % + 1))').should == [2, 3, 4]
-    apricot('(. [1 2 3] (map | #(. % + 1)))').should == [2, 3, 4]
-  end
-
-  it 'compiles shorthand send forms' do
-    apricot('(.class 1)').should == Fixnum
-    apricot('(.append "foo" "bar")').should == "foobar"
-  end
-
-  it 'compiles shorthand send forms with block args' do
-    apricot('(.map [1 2 3] | :to_s)').should == ['1', '2', '3']
-    apricot('(.map [1 2 3] | #(. % + 1))').should == [2, 3, 4]
-  end
-
-  it 'macroexpands shorthand send forms' do
-    form = apricot "'(.meth recv arg1 arg2)"
-    ex = Apricot.macroexpand(form)
-
-    dot  = Identifier.intern(:'.')
-    recv = Identifier.intern(:recv)
-    meth = Identifier.intern(:meth)
-    arg1 = Identifier.intern(:arg1)
-    arg2 = Identifier.intern(:arg2)
-    ex.should == List[dot, recv, meth, arg1, arg2]
-  end
-
-  it 'compiles shorthand new forms' do
-    apricot('(Range. 1 10)').should == (1..10)
-    apricot('(Array. 2 5)').should == [5, 5]
-  end
-
-  it 'compiles shorthand new forms with block args' do
-    apricot('(Array. 3 | :to_s)').should == ["0", "1", "2"]
-    apricot('(Array. 5 | #(* % %))').should == [0, 1, 4, 9, 16]
-  end
-
-  it 'macroexpands shorthand new forms' do
-    form = apricot "'(Klass. arg1 arg2)"
-    ex = Apricot.macroexpand(form)
-
-    dot   = Identifier.intern(:'.')
-    klass = Identifier.intern(:Klass)
-    new   = Identifier.intern(:new)
-    arg1  = Identifier.intern(:arg1)
-    arg2  = Identifier.intern(:arg2)
-    ex.should == List[dot, klass, new, arg1, arg2]
+    apr('(:a {:a 1 :b 2})').should == 1
+    apr('(:c {:a 1 :b 2})').should == nil
+    apr('(:a #{:a :b})').should == :a
+    apr('(:c #{:a :b})').should == nil
   end
 
   it 'compiles constant defs' do
     expect { Foo }.to raise_error(NameError)
-    apricot '(def Foo 1)'
+    apr '(def Foo 1)'
     Foo.should == 1
   end
 
-  it 'compiles if forms' do
-    apricot('(if true :foo :bar)').should == :foo
-    apricot('(if false :foo :bar)').should == :bar
-    apricot('(if true :foo)').should == :foo
-    apricot('(if false :foo)').should == nil
-  end
-
-  it 'compiles do forms' do
-    apricot('(do)').should == nil
-    apricot('(do 1)').should == 1
-    apricot('(do 1 2 3)').should == 3
-    expect { Bar }.to raise_error(NameError)
-    apricot('(do (def Bar 1) Bar)').should == 1
-  end
-
-  it 'compiles let forms' do
-    apricot('(let [])').should == nil
-    apricot('(let [a 1])').should == nil
-    apricot('(let [a 1] a)').should == 1
-    apricot('(let [a 1 b 2] [b a])').should == [2, 1]
-    apricot('(let [a 1] [(let [a 2] a) a])').should == [2, 1]
-    apricot('(let [a 1 b 2] (let [a 42] [b a]))').should == [2, 42]
-    apricot('(let [a 1 b a] [a b])').should == [1, 1]
-    apricot('(let [a 1] (let [b a] [a b]))').should == [1, 1]
-  end
-
-  it 'compiles fn forms' do
-    apricot('((fn []))').should == nil
-    apricot('((fn [] 42))').should == 42
-    apricot('((fn [x] x) 42)').should == 42
-    apricot('((fn [x y] [y x]) 1 2)').should == [2, 1]
-  end
-
-  it 'compiles fn forms with optional arguments' do
-    apricot('((fn [[x 42]] x))').should == 42
-    apricot('((fn [[x 42]] x) 0)').should == 0
-    apricot('((fn [x [y 2]] [x y]) 1)').should == [1, 2]
-    apricot('((fn [x [y 2]] [x y]) 3 4)').should == [3, 4]
-    apricot('((fn [[x 1] [y 2]] [x y]))').should == [1, 2]
-    apricot('((fn [[x 1] [y 2]] [x y]) 3)').should == [3, 2]
-    apricot('((fn [[x 1] [y 2]] [x y]) 3 4)').should == [3, 4]
-  end
-
-  it 'compiles fn forms with splat arguments' do
-    apricot('((fn [& x] x))').should == []
-    apricot('((fn [& x] x) 1)').should == [1]
-    apricot('((fn [& x] x) 1 2)').should == [1, 2]
-    apricot('((fn [x & y] y) 1)').should == []
-    apricot('((fn [x & y] y) 1 2 3)').should == [2, 3]
-  end
-
-  it 'compiles fn forms with optional and splat arguments' do
-    apricot('((fn [x [y 2] & z] [x y z]) 1)').should == [1, 2, []]
-    apricot('((fn [x [y 2] & z] [x y z]) 1 3)').should == [1, 3, []]
-    apricot('((fn [x [y 2] & z] [x y z]) 1 3 4 5)').should == [1, 3, [4, 5]]
-  end
-
-  it 'compiles fn forms with block arguments' do
-    apricot('((fn [| block] block))').should == nil
-    apricot('(.call (fn [| block] (block)) | (fn [] 42))').should == 42
-
-    fn = apricot '(fn [x | block] (block x))'
-    # Without passing a block, 'block' is nil.
-    expect { fn.call(2) }.to raise_error(NoMethodError)
-    fn.call(2) {|x| x + 40 }.should == 42
-
-    reduce_args = apricot <<-CODE
-      (fn reduce-args
-        ([x] x)
-        ([x y | f] (f x y))
-        ([x y & more | f]
-         (recur (f x y) (first more) (next more))))
-    CODE
-
-    reduce_args.call(1).should == 1
-    reduce_args.call(40, 2) {|x,y| x * y }.should == 80
-    reduce_args.call(1,2,3,4,5,6) {|x,y| x + y }.should == 21
-  end
-
-  it 'does not compile invalid fn forms' do
-    bad_apricot '(fn :foo)'
-    bad_apricot '(fn [1])'
-    bad_apricot '(fn [[x 1] y])'
-    bad_apricot '(fn [[1 1]])'
-    bad_apricot '(fn [[x]])'
-    bad_apricot '(fn [&])'
-    bad_apricot '(fn [& x y])'
-    bad_apricot '(fn [x x])'
-    bad_apricot '(fn [x & rest1 & rest2])'
-    bad_apricot '(fn [a b x c d x e f])'
-    bad_apricot '(fn [a x b [x 1]])'
-    bad_apricot '(fn [a b x c d & x])'
-    bad_apricot '(fn [a b c [x 1] [y 2] [x 3]])'
-    bad_apricot '(fn [a b [x 1] & x])'
-    bad_apricot '(fn [|])'
-    bad_apricot '(fn [| &])'
-    bad_apricot '(fn [| & a])'
-    bad_apricot '(fn [| a &])'
-    bad_apricot '(fn [& x |])'
-    bad_apricot '(fn [| x y])'
-    bad_apricot '(fn [| x & y])'
-    bad_apricot '(fn [x | x])'
-    bad_apricot '(fn [x | b1 | b2])'
-  end
-
-  it 'compiles arity-overloaded fn forms' do
-    apricot('((fn ([] 0)))') == 0
-    apricot('((fn ([x] x)) 42)') == 42
-    apricot('((fn ([[x 42]] x)))') == 42
-    apricot('((fn ([& rest] rest)) 1 2 3)') == [1, 2, 3]
-    apricot('((fn ([] 0) ([x] x)))') == 0
-    apricot('((fn ([] 0) ([x] x)) 42)') == 42
-    apricot('((fn ([x] x) ([x y] y)) 42)') == 42
-    apricot('((fn ([x] x) ([x y] y)) 42 13)') == 13
-
-    add_fn = apricot <<-CODE
-      (fn
-        ([] 0)
-        ([x] x)
-        ([x y] (.+ x y))
-        ([x y & more]
-         (.reduce more (.+ x y) :+)))
-    CODE
-
-    add_fn.call.should == 0
-    add_fn.call(42).should == 42
-    add_fn.call(1,2).should == 3
-    add_fn.call(1,2,3).should == 6
-    add_fn.call(1,2,3,4,5,6,7,8).should == 36
-
-    two_or_three = apricot '(fn ([x y] 2) ([x y z] 3))'
-    expect { two_or_three.call }.to raise_error(ArgumentError)
-    expect { two_or_three.call(1) }.to raise_error(ArgumentError)
-    two_or_three.call(1,2).should == 2
-    two_or_three.call(1,2,3).should == 3
-    expect { two_or_three.call(1,2,3,4) }.to raise_error(ArgumentError)
-    expect { two_or_three.call(1,2,3,4,5) }.to raise_error(ArgumentError)
-  end
-
-  it 'compiles arity-overloaded fns with no matching overloads for some arities' do
-    zero_or_two = apricot '(fn ([] 0) ([x y] 2))'
-    zero_or_two.call.should == 0
-    expect { zero_or_two.call(1) }.to raise_error(ArgumentError)
-    zero_or_two.call(1,2).should == 2
-    expect { zero_or_two.call(1,2,3) }.to raise_error(ArgumentError)
-
-    one_or_four = apricot '(fn ([w] 1) ([w x y z] 4))'
-    expect { one_or_four.call }.to raise_error(ArgumentError)
-    one_or_four.call(1).should == 1
-    expect { one_or_four.call(1,2) }.to raise_error(ArgumentError)
-    expect { one_or_four.call(1,2,3) }.to raise_error(ArgumentError)
-    one_or_four.call(1,2,3,4).should == 4
-    expect { one_or_four.call(1,2,3,4,5) }.to raise_error(ArgumentError)
-  end
-
-  it 'does not compile invalid arity-overloaded fn forms' do
-    bad_apricot '(fn ([] 1) :foo)'
-    bad_apricot '(fn ([] 1) ([] 2))'
-    bad_apricot '(fn ([[o 1]] 1) ([] 2))'
-    bad_apricot '(fn ([] 1) ([[o 2]] 2))'
-    bad_apricot '(fn ([[o 1]] 1) ([[o 2]] 2))'
-    bad_apricot '(fn ([x [o 1]] 1) ([x] 2))'
-    bad_apricot '(fn ([x [o 1]] 1) ([[o 2]] 2))'
-    bad_apricot '(fn ([x y z [o 1]] 1) ([x y z & rest] 2))'
-    bad_apricot '(fn ([x [o 1] [p 2] [q 3]] 1) ([x y z] 2))'
-    bad_apricot '(fn ([x & rest] 1) ([x y] 2))'
-    bad_apricot '(fn ([x & rest] 1) ([x [o 1]] 2))'
-    bad_apricot '(fn ([x [o 1] & rest] 1) ([x] 2))'
-  end
-
-  it 'compiles fn forms with self-reference' do
-    foo = apricot '(fn foo [] foo)'
-    foo.call.should == foo
-
-    # This one will stack overflow from the infinite loop.
-    expect { apricot '((fn foo [] (foo)))' }.to raise_error(SystemStackError)
-
-    add = apricot <<-CODE
-      (fn add
-        ([] 0)
-        ([& args]
-         (.+ (first args) (apply add (rest args)))))
-    CODE
-
-    add.call.should == 0
-    add.call(1).should == 1
-    add.call(1,2,3).should == 6
-  end
-
-  it 'compiles loop and recur forms' do
-    apricot('(loop [])').should == nil
-    apricot('(loop [a 1])').should == nil
-    apricot('(loop [a 1] a)').should == 1
-
-    apricot(<<-CODE).should == [5,4,3,2,1]
-      (let [a []]
-        (loop [x 5]
-          (if (. x > 0)
-            (do
-              (. a << x)
-              (recur (. x - 1)))))
-        a)
-    CODE
-  end
-
-  it 'compiles recur forms in fns' do
-    apricot(<<-CODE).should == 15
-      ((fn [x y]
-         (if (. x > 0)
-           (recur (. x - 1) (. y + x))
-           y))
-       5 0)
-    CODE
-  end
-
-  it 'compiles recur forms in fns with optional arguments' do
-    apricot(<<-CODE).should == 150
-      ((fn [x y [mult 10]]
-         (if (. x > 0)
-           (recur (. x - 1) (. y + x) mult)
-           (* y mult)))
-       5 0)
-    CODE
-
-    apricot(<<-CODE).should == 300
-      ((fn [x y [mult 10]]
-         (if (. x > 0)
-           (recur (. x - 1) (. y + x) mult)
-           (* y mult)))
-       5 0 20)
-    CODE
-  end
-
-  it 'does not compile invalid recur forms' do
-    bad_apricot '(fn [] (recur 1))'
-    bad_apricot '(fn [x] (recur))'
-    bad_apricot '(fn [[x 10]] (recur))'
-    bad_apricot '(fn [x & rest] (recur 1))'
-    bad_apricot '(fn [x & rest] (recur 1 2 3))'
-  end
-
-  it 'compiles recur forms in arity-overloaded fns' do
-    apricot(<<-CODE).should == 0
-      ((fn
-         ([] 0)
-         ([& args] (recur [])))
-        1 2 3)
-    CODE
-
-    apricot(<<-CODE).should == 0
-      ((fn
-         ([] 0)
-         ([& args] (recur (rest args))))
-        1 2 3)
-    CODE
-
-    apricot(<<-CODE).should == 6
-      ((fn
-         ([x] x)
-         ([x & args] (recur (.+ x (first args)) (rest args))))
-        1 2 3)
-    CODE
-
-    apricot(<<-CODE).should == 42
-      ((fn
-         ([] 0)
-         ([x y & args]
-          (if (.empty? args)
-            42
-            (recur x y (rest args)))))
-        1 2 3)
-    CODE
-  end
-
-  it 'compiles try forms' do
-    apricot('(try)').should == nil
-    apricot('(try :foo)').should == :foo
-
-    apricot('(try :success (rescue e :rescue))').should == :success
-    expect { apricot '(try (. Kernel raise))' }.to raise_error(RuntimeError)
-    apricot('(try (. Kernel raise) (rescue e :rescue))').should == :rescue
-    apricot('(try (. Kernel raise) (rescue [e] :rescue))').should == :rescue
-    apricot(<<-CODE).should == :rescue
-      (try
-        (. Kernel raise)
-        (rescue [e 1 2 RuntimeError] :rescue))
-    CODE
-    apricot(<<-CODE).should == :rescue_bar
-      (try
-        (. Kernel raise ArgumentError)
-        (rescue [e TypeError] :rescue_foo)
-        (rescue [e ArgumentError] :rescue_bar))
-    CODE
-    apricot(<<-CODE).should be_a(TypeError)
-      (try
-        (. Kernel raise TypeError)
-        (rescue e e))
-    CODE
-    expect { apricot(<<-CODE) }.to raise_error(TypeError)
-      (try
-        (. Kernel raise TypeError)
-        (rescue [e ArgumentError] :rescue))
-    CODE
-
-    apricot(<<-CODE).should == :rescue
-      (try
-        (try
-          (. Kernel raise)
-          (rescue e (. Kernel raise)))
-        (rescue e :rescue))
-    CODE
-
-    apricot(<<-CODE).should == []
-      (let [a [1]]
-        (try
-          :success
-          (ensure (.pop a)))
-        a)
-    CODE
-    apricot(<<-CODE).should == []
-      (let [a [1]]
-        (try
-          (. Kernel raise)
-          (rescue e :rescue)
-          (ensure (.pop a)))
-        a)
-    CODE
-    apricot(<<-CODE).should == []
-      (let [a [1]]
-        (try
-          (try
-            (. Kernel raise)
-            (ensure (.pop a)))
-          (rescue e :rescue))
-        a)
-    CODE
-  end
-
   it 'compiles quoted forms' do
-    apricot("'1").should == 1
-    apricot("'a").should == Identifier.intern(:a)
-    apricot("''a").should == List[
+    apr("'1").should == 1
+    apr("'a").should == Identifier.intern(:a)
+    apr("''a").should == List[
       Identifier.intern(:quote),
       Identifier.intern(:a)
     ]
-    apricot("'1.2").should == 1.2
-    apricot("'1/2").should == Rational(1,2)
-    apricot("':a").should == :a
-    apricot("'()").should == List::EmptyList
-    apricot("'(1)").should == List[1]
-    apricot("'[a]").should == [Identifier.intern(:a)]
-    apricot("'{a 1}").should == {Identifier.intern(:a) => 1}
-    apricot('\'"foo"').should == "foo"
-    apricot("'true").should == true
-    apricot("'false").should == false
-    apricot("'nil").should == nil
-    apricot("'self").should == Identifier.intern(:self)
-    apricot("'Foo::Bar").should == Identifier.intern(:'Foo::Bar')
+    apr("'1.2").should == 1.2
+    apr("'1/2").should == Rational(1,2)
+    apr("':a").should == :a
+    apr("'()").should == List::EMPTY_LIST
+    apr("'(1)").should == List[1]
+    apr("'[a]").should == [Identifier.intern(:a)]
+    apr("'{a 1}").should == {Identifier.intern(:a) => 1}
+    apr('\'"foo"').should == "foo"
+    apr("'true").should == true
+    apr("'false").should == false
+    apr("'nil").should == nil
+    apr("'self").should == Identifier.intern(:self)
+    apr("'Foo::Bar").should == Identifier.intern(:'Foo::Bar')
   end
 end