nydp 0.5.1 → 0.6.0

data/spec/hash_non_hash_behaviour_spec.rb

@@ -1,42 +1,29 @@
 require "spec_helper"
 
-describe Nydp::Hash do
-  let(:vm) { Nydp::VM.new(ns) }
+describe ::Hash do
 
   describe "friendly non-hashes" do
     let(:ahash) { TestThing.new 123, "hello there", "private" }
 
     describe "hash get" do
       it "returns a plain number" do
-        k      = Nydp::Symbol.mk "a", ns
-        args   = [ ahash, k ]
-
-        Nydp::Builtin::HashGet.instance.invoke vm, pair_list(args)
-        expect(vm.args.pop).to eq 123
+        a = Nydp::Builtin::HashGet.instance.call ahash, :a
+        expect(a).to eq 123
       end
 
       it "converts ruby value to nydp value" do
-        k      = Nydp::Symbol.mk "b", ns
-        args   = [ ahash, k ]
-
-        Nydp::Builtin::HashGet.instance.invoke vm, pair_list(args)
-        expect(vm.args.pop).to eq "hello there"
+        a = Nydp::Builtin::HashGet.instance.call ahash, :b
+        expect(a).to eq "hello there"
       end
 
       it "converts string keys to method names" do
-        k      = "b"
-        args   = [ ahash, k ]
-
-        Nydp::Builtin::HashGet.instance.invoke vm, pair_list(args)
-        expect(vm.args.pop).to eq "hello there"
+        a = Nydp::Builtin::HashGet.instance.call ahash, "b"
+        expect(a).to eq "hello there"
       end
 
       it "returns nil for unavailable methods" do
-        k      = Nydp::Symbol.mk "c", ns
-        args   = [ ahash, k ]
-
-        Nydp::Builtin::HashGet.instance.invoke vm, pair_list(args)
-        expect(vm.args.pop).to eq Nydp::NIL
+        a = Nydp::Builtin::HashGet.instance.call ahash, :c
+        expect(a).to eq Nydp::NIL
       end
     end
   end
@@ -50,12 +37,11 @@ describe Nydp::Hash do
 
     describe "hash set" do
       it "does nothing, returns its value" do
-        k    = Nydp::Symbol.mk "keysym", ns
+        k    = :keysym
         v    = "foobar"
-        args = pair_list [ahash, k, v]
 
         begin
-          Nydp::Builtin::HashSet.instance.invoke vm, args
+          Nydp::Builtin::HashSet.instance.call ahash, k, v
         rescue StandardError => e
           error = e
         end
@@ -72,11 +58,8 @@ with args
 
     describe "hash get" do
       it "converts ruby value to nydp value" do
-        k      = Nydp::Symbol.mk "keysym", ns
-        args   = [ ahash, k ]
-
         begin
-          Nydp::Builtin::HashGet.instance.invoke vm, pair_list(args)
+          Nydp::Builtin::HashGet.instance.call ahash, :keysym
         rescue StandardError => e
           error = e
         end

data/spec/hash_spec.rb

@@ -1,12 +1,10 @@
 require "spec_helper"
 
-describe Nydp::Hash do
-
-  let(:vm) { Nydp::VM.new(ns) }
+describe ::Hash do
 
   describe "#to_ruby" do
     it "converts ruby symbol key to nydp symbol key" do
-      hash = Nydp::Hash.new
+      hash = ::Hash.new
       hash[sym "boo"] = 42
 
       rhash = hash.to_ruby
@@ -15,7 +13,7 @@ describe Nydp::Hash do
     end
 
     it "converts ruby string key to nydp string key" do
-      hash = Nydp::Hash.new
+      hash = ::Hash.new
       hash["boo"] = 42
 
       rhash = hash.to_ruby
@@ -24,7 +22,7 @@ describe Nydp::Hash do
     end
 
     it "uses integer keys unconverted" do
-      hash = Nydp::Hash.new
+      hash = ::Hash.new
       hash[21] = 42
 
       rhash = hash.to_ruby
@@ -35,7 +33,6 @@ describe Nydp::Hash do
 
   describe "hash merge" do
     it "merges two hashes" do
-      ns = { }
       Nydp.setup(ns)
       hash_0 = { foo: 12, bar: 34}
       hash_1 = { foo: 49, zap: 87}
@@ -49,120 +46,110 @@ describe Nydp::Hash do
   describe "nydp hashes" do
     describe "new hash" do
       it "returns a new Nydp hash" do
-        Nydp::Builtin::Hash.instance.invoke vm, Nydp::NIL
-        h = vm.args.pop
-        expect(h).to be_a Nydp::Hash
+        h  = Nydp::Builtin::Hash.instance.call
+        expect(h).to be_a ::Hash
       end
     end
 
     describe "hash set" do
       it "sets a value on a hash" do
-        h    = Nydp::Hash.new
-        k    = sym "keysym"
-        v    = 42
-        args = Nydp::Pair.from_list([h, k, v])
-        Nydp::Builtin::HashSet.instance.invoke vm, args
+        h    = ::Hash.new
+        a    = Nydp::Builtin::HashSet.instance.call h, :keysym, 42
 
-        expect(h.keys).    to eq [k]
-        expect(h[k]).      to eq v
-        expect(vm.args.pop).to eq v
+        expect(h.keys).    to eq [:keysym]
+        expect(h[:keysym]).to eq 42
+        expect(a).         to eq 42
       end
     end
 
     describe "hash get" do
       it "gets a value from a hash" do
-        h    = Nydp::Hash.new
-        k    = sym "keysym"
+        h    = ::Hash.new
+        k    = :keysym
         v    = 42
         h[k] = v
 
-        args = Nydp::Pair.from_list([h, k])
-        Nydp::Builtin::HashGet.instance.invoke vm, args
-        expect(vm.args.pop).to eq v
+        a    = Nydp::Builtin::HashGet.instance.call h, k
+        expect(a).to eq v
       end
     end
 
     describe "key?" do
       it "returns t when key is present" do
-        h    = Nydp::Hash.new
+        h    = ::Hash.new
         k    = sym "jerry"
         v    = 42
         h[k] = v
 
-        Nydp::Builtin::HashKeyPresent.instance.invoke vm, pair_list([h, k])
+        a = Nydp::Builtin::HashKeyPresent.instance.call h, k
 
-        expect(vm.args.pop).to eq Nydp::T
+        expect(a).to eq true
       end
 
       it "returns nil when key is absent" do
-        h    = Nydp::Hash.new
+        h    = ::Hash.new
         k    = sym "benjamin"
 
-        Nydp::Builtin::HashKeyPresent.instance.invoke vm, pair_list([h, k])
+        a = Nydp::Builtin::HashKeyPresent.instance.call h, k
 
-        expect(vm.args.pop).to eq Nydp::NIL
+        expect(a).to eq nil
       end
     end
 
     describe "hash keys" do
       it "returns a list of keys" do
-        h    = Nydp::Hash.new
+        h    = ::Hash.new
         h[sym "k0"] = 42
         h[sym "k1"] = 84
 
-        args = Nydp::Pair.from_list([h])
-        Nydp::Builtin::HashKeys.instance.invoke vm, args
-        expect(vm.args.pop).to eq pair_list [sym("k0"), sym("k1")]
+        a    = Nydp::Builtin::HashKeys.instance.call h
+        expect(a).to eq pair_list [sym("k0"), sym("k1")]
       end
     end
   end
 
   describe "get/set nil" do
-    let(:ahash) { Nydp::NIL }
+    let(:ahash) { nil }
 
     describe "hash set" do
       it "does nothing, returns its value" do
-        k    = Nydp::Symbol.mk "keysym", ns
+        k    = :keysym
         v    = "foobar"
-        args = pair_list [ahash, k, v]
-        Nydp::Builtin::HashSet.instance.invoke vm, args
+        a    = Nydp::Builtin::HashSet.instance.call ahash, k, v
 
-        expect(ahash).     to eq Nydp::NIL
-        expect(vm.args.pop).to eq v
+        expect(ahash).     to eq nil
+        expect(a).         to eq v
       end
     end
 
     describe "hash get" do
       it "converts ruby value to nydp value" do
-        k    = Nydp::Symbol.mk "keysym", ns
-        args           = [ ahash, k ]
+        k    = :keysym
 
-        Nydp::Builtin::HashGet.instance.invoke vm, pair_list(args)
+        a = Nydp::Builtin::HashGet.instance.call ahash, k
 
-        expect(vm.args.pop).to eq Nydp::NIL
+        expect(a).to eq nil
       end
     end
   end
 
   describe "hash-slice" do
     it "returns a new hash containing only the given keys from the old hash" do
-      hash = Nydp::Hash.new
+      hash = ::Hash.new
       sfoo = sym "foo"
       sbar = sym "bar"
       syak = sym "yak"
       szeb = sym "zeb"
 
-      h = Nydp::Hash.new
+      h = ::Hash.new
 
       h[sfoo] = 16
       h[sbar] = 42
       h[szeb] = 99
 
-      args       = [h, pair_list([sbar, syak, szeb])]
-
-      Nydp::Builtin::HashSlice.instance.invoke vm, pair_list(args)
+      a = Nydp::Builtin::HashSlice.instance.call h, pair_list([sbar, syak, szeb])
 
-      expect(vm.args.pop).to eq({ sbar => 42, szeb => 99 })
+      expect(a).to eq({ sbar => 42, szeb => 99 })
     end
   end
 end

data/spec/literal_spec.rb

@@ -2,28 +2,28 @@ require 'spec_helper'
 
 describe Nydp::Literal do
   it "returns a ruby symbol in #to_ruby" do
-    sym = Nydp::Symbol.mk :foo, ns
+    sym = :foo
     lit = Nydp::Literal.new sym
     expect(lit.to_ruby).to eq :foo
   end
 
   describe "t" do
     it "is #true in ruby" do
-      expect(Nydp::T.to_ruby).to eq true
+      expect(true.to_ruby).to eq true
     end
   end
 
   describe "nil" do
     it "is #nil in ruby" do
-      expect(Nydp::NIL.to_ruby).to eq nil
+      expect(nil.to_ruby).to eq nil
     end
   end
 
   describe "false" do
     it "is stored in toplevel namespace" do
-      Nydp::Core.new.setup ns
-      nydp_false = Nydp::Symbol.mk :false, ns
-      expect(nydp_false.value).to eq false
+      false_ns = Nydp::Namespace.new
+      Nydp::Core.new.setup false_ns
+      expect(false_ns.ns_false).to eq false
     end
   end
 end

data/spec/nydp_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 describe Nydp do
-  let(:parser) { Nydp.new_parser(ns) }
-  let(:vm)     { Nydp::VM.new(ns)     }
+  let(:parser) { Nydp.new_parser  }
 
   def run txt
     Nydp.setup ns
@@ -14,7 +13,7 @@ describe Nydp do
   end
 
   it "should make a symbol from a string" do
-    expect(run '(sym "the-family")').to eq sym(:"the-family")
+    expect(run '(sym "the-family")').to eq :"the-family"
   end
 
   it "should sum integers" do
@@ -83,16 +82,17 @@ describe Nydp do
     expect(result).to eq 100
   end
 
-  it "should recurse without consuming extra memory" do
-    program = "(assign f1 (fn (x acc)
-                              (cond (< x 1)
-                                    (vm-info)
-                                    (f1 (- x 1)
-                                        (+ x acc)))))
-               (f1 1000 0)"
-    expected = parse "((contexts . 0) (instructions . 0) (args . 0))"
-    expect(run program).to eq expected
-  end
+  # no longer true or meaningful, nydp stack is implemented on top of ruby stack now, unlimited recursion is no longer available by default
+  # it "should recurse without consuming extra memory" do
+  #   program = "(assign f1 (fn (x acc)
+  #                             (cond (< x 1)
+  #                                   (vm-info)
+  #                                   (f1 (- x 1)
+  #                                       (+ x acc)))))
+  #              (f1 1000 0)"
+  #   expected = parse "((contexts . 0) (instructions . 0) (args . 0))"
+  #   expect(run program).to eq expected
+  # end
 
   describe :cond do
     it "should execute false conditionals" do
@@ -115,7 +115,7 @@ describe Nydp do
 
   describe "proc from ruby object" do
     it "invokes a proc like a builtin function" do
-      Nydp::Symbol.mk(:tt, ns).assign(TestThing.new(42, 720, 9699690))
+      ns.ns_tt = TestThing.new(42, 720, 9699690)
 
       one_thing = run "((hash-get tt 'one_thing) 24)"
       expect(one_thing).to eq(42 + 24)

data/spec/pair_spec.rb

@@ -1,18 +1,18 @@
 require "spec_helper"
 
 describe Nydp::Pair do
-  let(:a)                { Nydp::Symbol.mk :a,                  ns }
-  let(:b)                { Nydp::Symbol.mk :b,                  ns }
-  let(:c)                { Nydp::Symbol.mk :c,                  ns }
-  let(:d)                { Nydp::Symbol.mk :d,                  ns }
-  let(:foo)              { Nydp::Symbol.mk :foo,                ns }
-  let(:dot)              { Nydp::Symbol.mk ".".to_sym,          ns }
+  let(:a)                { :a                  }
+  let(:b)                { :b                  }
+  let(:c)                { :c                  }
+  let(:d)                { :d                  }
+  let(:foo)              { :foo                }
+  let(:dot)              { ".".to_sym          }
 
   describe "#map" do
     it "behaves like ruby #map" do
       list = pair_list [1,2,3]
       mapped = list.map { |x| x * 2 }
-      expect(mapped).to eq [2,4,6]
+      expect(mapped).to eq pair_list([2,4,6])
     end
   end
 
@@ -28,7 +28,7 @@ describe Nydp::Pair do
     end
 
     it "is false for (nil) == nil" do
-      expect(Nydp::Pair.from_list([Nydp::NIL]) == Nydp::NIL).to eq false
+      expect(Nydp::Pair.from_list([nil]) == nil).to eq false
     end
 
     it "should be true for nested empty lists" do

data/spec/parser_spec.rb

@@ -1,31 +1,31 @@
 require 'spec_helper'
 
 describe Nydp::Parser do
-  let(:empty)            { Nydp::Symbol.mk :"",                   ns }
-  let(:aa)               { Nydp::Symbol.mk :aa,                   ns }
-  let(:a)                { Nydp::Symbol.mk :a,                    ns }
-  let(:b)                { Nydp::Symbol.mk :b,                    ns }
-  let(:c)                { Nydp::Symbol.mk :c,                    ns }
-  let(:d)                { Nydp::Symbol.mk :d,                    ns }
-  let(:zz)               { Nydp::Symbol.mk :zz,                   ns }
-  let(:foo)              { Nydp::Symbol.mk :foo,                  ns }
-  let(:bar)              { Nydp::Symbol.mk :bar,                  ns }
-  let(:foobar)           { Nydp::Symbol.mk :foobar,               ns }
-  let(:zab)              { Nydp::Symbol.mk :zab,                  ns }
-  let(:quote)            { Nydp::Symbol.mk :quote,                ns }
-  let(:quasiquote)       { Nydp::Symbol.mk :quasiquote,           ns }
-  let(:unquote)          { Nydp::Symbol.mk :unquote,              ns }
-  let(:prefix_list)      { Nydp::Symbol.mk :"prefix-list",        ns }
-  let(:unquote_splicing) { Nydp::Symbol.mk :"unquote-splicing",   ns }
-  let(:comment)          { Nydp::Symbol.mk :comment,              ns }
-  let(:dotsyn)           { Nydp::Symbol.mk :"dot-syntax",         ns }
-  let(:cocosyn)          { Nydp::Symbol.mk :"colon-colon-syntax", ns }
-  let(:colosyn)          { Nydp::Symbol.mk :"colon-syntax",       ns }
-  let(:atsyn)            { Nydp::Symbol.mk :"at-syntax",          ns }
-  let(:string_pieces)    { Nydp::Symbol.mk :"string-pieces",      ns }
+  let(:empty)            { :""                   }
+  let(:aa)               { :aa                   }
+  let(:a)                { :a                    }
+  let(:b)                { :b                    }
+  let(:c)                { :c                    }
+  let(:d)                { :d                    }
+  let(:zz)               { :zz                   }
+  let(:foo)              { :foo                  }
+  let(:bar)              { :bar                  }
+  let(:foobar)           { :foobar               }
+  let(:zab)              { :zab                  }
+  let(:quote)            { :quote                }
+  let(:quasiquote)       { :quasiquote           }
+  let(:unquote)          { :unquote              }
+  let(:prefix_list)      { :"prefix-list"        }
+  let(:unquote_splicing) { :"unquote-splicing"   }
+  let(:comment)          { :comment              }
+  let(:dotsyn)           { :"dot-syntax"         }
+  let(:cocosyn)          { :"colon-colon-syntax" }
+  let(:colosyn)          { :"colon-syntax"       }
+  let(:atsyn)            { :"at-syntax"          }
+  let(:string_pieces)    { :"string-pieces"      }
 
   it "should return a stream of tokens" do
-    reader = Nydp::StringReader.new ""
+    reader = Nydp::StringReader.new "test", ""
     t = Nydp.new_tokeniser reader
     expect(t.next_token).to eq nil
   end
@@ -49,6 +49,10 @@ describe Nydp::Parser do
     expect(parse "(|foo bar| || |\" hello, there, silly billy!\"|)").to eq pair_list([s0, s1, s2])
   end
 
+  it "returns ruby nil for token nil" do
+    expect(parse "(nil nil nil)").to eq pair_list([nil, nil, nil])
+  end
+
   it "should parse untidy symbols with special syntax" do
     quote_foo_bar = parse "'|foo bar|"
     expect(quote_foo_bar).to eq pair_list([quote, sym("foo bar")])
@@ -139,15 +143,15 @@ describe Nydp::Parser do
 
   it "should spot numbers hiding in special syntax" do
     parsed = parse("foo.2:3:4")
-    expect(parsed.inspect).to eq "(colon-syntax (dot-syntax foo 2) 3 4)"
+    expect(parsed._nydp_inspect).to eq "(colon-syntax (dot-syntax foo 2) 3 4)"
 
-    expect(parsed.map &:class).to eq [Nydp::Symbol, Nydp::Pair, Integer, Integer]
-    expect(parsed.cdr.car.map &:class).to eq [Nydp::Symbol, Nydp::Symbol, Integer]
+    expect(parsed.map &:class).to eq pair_list([::Symbol, Nydp::Pair, Integer, Integer])
+    expect(parsed.cdr.car.map &:class).to eq pair_list([::Symbol, ::Symbol, Integer])
   end
 
   it "should handle prefix and postfix syntax also" do
     parsed = parse(".foo123:")
-    expect(parsed.inspect).to eq "(colon-syntax (dot-syntax || foo123) ||)"
+    expect(parsed._nydp_inspect).to eq "(colon-syntax (dot-syntax || foo123) ||)"
   end
 
   it "should parse a dotted symbol" do
@@ -199,7 +203,7 @@ describe Nydp::Parser do
   end
 
   it "should unquote-unquote_splicing symbols" do
-    expect(parse(",,@foo").inspect).to eq "(unquote (unquote-splicing foo))"
+    expect(parse(",,@foo")._nydp_inspect).to eq "(unquote (unquote-splicing foo))"
   end
 
   it "should quote lists" do
@@ -219,21 +223,21 @@ describe Nydp::Parser do
   end
 
   it "should do some complicated unquote stuff with lists" do
-    expect(parse("`(a b `(c d ,(+ 1 2) ,,(+ 3 4)))").inspect).to eq "(quasiquote (a b (quasiquote (c d (unquote (+ 1 2)) (unquote (unquote (+ 3 4)))))))"
+    expect(parse("`(a b `(c d ,(+ 1 2) ,,(+ 3 4)))")._nydp_inspect).to eq "(quasiquote (a b (quasiquote (c d (unquote (+ 1 2)) (unquote (unquote (+ 3 4)))))))"
   end
 
   it "should do some complicated unquote stuff with mixed lists and symbols" do
-    expect(parse("`(a b `(c d ,,@foo e f))").inspect).to eq "(quasiquote (a b (quasiquote (c d (unquote (unquote-splicing foo)) e f))))"
-    expect(parse("`(a b `(c d ,@,foo e f))").inspect).to eq "(quasiquote (a b (quasiquote (c d (unquote-splicing (unquote foo)) e f))))"
-    expect(parse("`(a b `(c d ,',foo e f))").inspect).to eq "(quasiquote (a b (quasiquote (c d (unquote (quote (unquote foo))) e f))))"
+    expect(parse("`(a b `(c d ,,@foo e f))")._nydp_inspect).to eq "(quasiquote (a b (quasiquote (c d (unquote (unquote-splicing foo)) e f))))"
+    expect(parse("`(a b `(c d ,@,foo e f))")._nydp_inspect).to eq "(quasiquote (a b (quasiquote (c d (unquote-splicing (unquote foo)) e f))))"
+    expect(parse("`(a b `(c d ,',foo e f))")._nydp_inspect).to eq "(quasiquote (a b (quasiquote (c d (unquote (quote (unquote foo))) e f))))"
   end
 
   it "should do some complicated unquote stuff with lists" do
-    expect(parse("`(a b `(c d ,(+ 1 2) ,,@(list 3 4)))").inspect).to eq "(quasiquote (a b (quasiquote (c d (unquote (+ 1 2)) (unquote (unquote-splicing (list 3 4)))))))"
+    expect(parse("`(a b `(c d ,(+ 1 2) ,,@(list 3 4)))")._nydp_inspect).to eq "(quasiquote (a b (quasiquote (c d (unquote (+ 1 2)) (unquote (unquote-splicing (list 3 4)))))))"
   end
 
   it "should do some complicated unquote stuff with symbols" do
-    expect(parse("`(a b `(c d ,(+ 1 2) ,,x))").inspect).to eq "(quasiquote (a b (quasiquote (c d (unquote (+ 1 2)) (unquote (unquote x))))))"
+    expect(parse("`(a b `(c d ,(+ 1 2) ,,x))")._nydp_inspect).to eq "(quasiquote (a b (quasiquote (c d (unquote (+ 1 2)) (unquote (unquote x))))))"
   end
 
   it "should unquote-splicing atoms" do
@@ -294,8 +298,8 @@ describe Nydp::Parser do
 "
     c1 = pair_list([comment, "here's a comment"])
     fbar = pair_list([bar])
-    fzab = pair_list([Nydp::Symbol.mk(:zab, ns)])
-    fdef = Nydp::Symbol.mk(:def, ns)
+    fzab = pair_list([:zab])
+    fdef = :def
     expr = pair_list([fdef, foo, fbar, c1, fzab])
     expect(parse txt).to eq expr
   end
@@ -304,7 +308,7 @@ describe Nydp::Parser do
     txt = <<NYDP
 (def plugin-end   (name) (assign this-plugin nil ) (chapter-end))
 NYDP
-    expect(parse(txt).to_a.inspect).to eq "[def, plugin-end, (name), (assign this-plugin nil), (chapter-end)]"
+    expect(parse(txt).to_a._nydp_inspect).to eq "[def plugin-end (name) (assign this-plugin nil) (chapter-end)]"
   end
 
   it "parses a more complete expression" do

data/spec/rand_spec.rb

@@ -1,13 +1,10 @@
 require "spec_helper"
 
 describe Nydp::Builtin::Rand do
-  let(:vm) { Nydp::VM.new(ns) }
-
   let(:randf) { Nydp::Builtin::Rand.instance }
 
   def get_rand *args
-    randf.invoke vm, pair_list(args)
-    vm.pop_args(1).first
+    randf.call *args
   end
 
   describe "zero args" do

data/spec/spec_helper.rb

@@ -3,11 +3,11 @@ require 'nydp/symbol'
 
 module SpecHelper
   def sym name
-    Nydp::Symbol.mk name.to_sym, ns
+    name.to_s.to_sym
   end
 
   def parse txt
-    Nydp.new_parser(ns).expression(Nydp.new_tokeniser Nydp::StringReader.new(txt))
+    Nydp.new_parser.expression(Nydp.new_tokeniser Nydp::StringReader.new("test", txt))
   end
 
   def pair_list xs, last=Nydp::NIL
@@ -15,7 +15,7 @@ module SpecHelper
   end
 
   def self.included base
-    base.let(:ns)  { { } }
+    base.let(:ns)  { Nydp::Namespace.new }
   end
 end
 

data/spec/string_atom_spec.rb

@@ -1,22 +1,21 @@
 require "spec_helper"
 
 describe Nydp::StringAtom do
-  let(:bar) { Nydp::StringAtom.new "BAR" }
-  let(:foo) { Nydp::StringAtom.new "FOO" }
-  let(:vm)  { Nydp::VM.new(ns)           }
+  let(:bar) { "BAR" }
+  let(:foo) { "FOO" }
 
   it "is not equal to a symbol with the same represenation" do
-    string = Nydp::StringAtom.new "harrypotter"
-    symbol = Nydp::Symbol.mk "harrypotter", ns
-    compare = Nydp::StringAtom.new symbol.to_s
+    string = "harrypotter"
+    symbol = :harrypotter
+    compare = symbol.to_s
     expect(string == compare).to eq true
     expect(string == symbol) .to eq false
   end
 
   it "is not equal to a list with the same represenation" do
-    string = Nydp::StringAtom.new "(FOO BAR)"
+    string = '("FOO" "BAR")'
     list   = Nydp::Pair.from_list [foo, bar]
-    compare = Nydp::StringAtom.new list.to_s
+    compare = list.to_s
     expect(string == compare).to eq true
     expect(string == list)   .to eq false
   end
@@ -30,32 +29,32 @@ describe Nydp::StringAtom do
   it "works with builtin greater-than when true" do
     f = Nydp::Builtin::GreaterThan.instance
 
-    f.invoke vm, pair_list([foo, bar])
+    a = f.call foo, bar
 
-    expect(vm.args.pop).to eq bar
+    expect(a).to eq bar
   end
 
   it "works with builtin greater-than when false" do
     f = Nydp::Builtin::GreaterThan.instance
 
-    f.invoke vm, pair_list([bar, foo])
+    a = f.call bar, foo
 
-    expect(vm.args.pop).to eq Nydp::NIL
+    expect(a).to eq Nydp::NIL
   end
 
   it "works with builtin less-than when true" do
     f = Nydp::Builtin::LessThan.instance
 
-    f.invoke vm, pair_list([bar, foo])
+    a = f.call bar, foo
 
-    expect(vm.args.pop).to eq foo
+    expect(a).to eq foo
   end
 
   it "works with builtin less-than when false" do
     f = Nydp::Builtin::LessThan.instance
 
-    f.invoke vm, pair_list([foo, bar])
+    a = f.call foo, bar
 
-    expect(vm.args.pop).to eq Nydp::NIL
+    expect(a).to eq Nydp::NIL
   end
 end