 
   describe 'indexing', ->
     it 'should find value of list from index', ->
-      ip('(@ 1 (1 2 3))').should.eql 2
+      ip('(@ 1 (1 2 3))').should.equal 2
 
     it 'should find attribute of dict from index', ->
-      ip('(@ "key1" {"key0":"foo" "key1":42 key2:false})').should.eql 42
+      ip('(@ "key1" {"key0":"foo" "key1":42 key2:false})').should.equal 42
 
     it 'should find letter of string from index', ->
-      ip('(@ 3 "foobar")').should.eql 'b'
+      ip('(@ 3 "foobar")').should.equal 'b'
 
     describe 'lengths', ->
       it 'should get length of string', ->
-        ip('(_ "foobar")').should.eql 6
+        ip('(_ "foobar")').should.equal 6
 
       it 'should get length of list', ->
-        ip('(_ (1 2 3))').should.eql 3
+        ip('(_ (1 2 3))').should.equal 3
 
       it 'should not any get length of dict', ->
         should.not.exist ip('(_ {0:0 1:1})')

describe 'Whip', ->
  describe 'parser', ->
    it 'should lex a single atom', ->
      'a'.should.eql w.parse('a').value

    it 'should lex an atom in a list', ->
      [].should.eql unan w.parse '()'


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

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

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

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

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

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

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

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

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