          ip('((lambda (tail (1 2))))').should.eql [2]
 
       it 'should return correct result for lambda that takes and returns arg', ->
-         ip('((lambda (x) x) 1)').should.eql 1
+         ip('((lambda (x) x) 1)').should.equal 1
 
       it 'should return correct result for lambda that returns list of vars', ->
          ip('((lambda (x y) (x y)) 1 2)').should.eql [1, 2]


    describe 'atoms', ->
      it 'should return string atom', ->
         ip('"a"').should.eql 'a'

      it 'should return string with space atom', ->
          ip('"a b"').should.eql 'a b'

      it 'should return string with opening paren', ->
         ip('"(a"').should.eql '(a'

      it 'should return string with closing paren', ->
         ip('")a"').should.eql ')a'

      it 'should return string with parens', ->
         ip('"(a)"').should.eql '(a)'

      it 'should return number atom', ->
         ip('123').should.eql 123

    describe 'invocation', ->
      it 'should run print on an int', ->
         ip('(print 1)').should.eql 1

      it 'should return first element of list', ->
         ip('(head (1 2 3))').should.eql 1

      it 'should return rest of list', ->
         ip('(tail (1 2 3))').should.eql [2, 3]

         ip('(let ((x 1) (y x)) (x y))').should.eql [1, undefined]

      it 'should accept empty binding list', ->
         ip('(let () 42)').should.equal 42

    describe 'if', ->
      it 'should choose the right branch', ->
         ip('(if true 42 4711)').should.equal 42
         ip('(if false 42 4711)').should.equal 4711

    describe 'dictionaries', ->
      it 'should generate dictionary with keys and values', ->
