nydp 0.4.0 → 0.4.6

data/spec/embedded_spec.rb

@@ -27,29 +27,29 @@ describe Nydp::Parser do
   it "should parse empty string" do
     expected = pair_list([sym('string-pieces'), Nydp::StringFragmentCloseToken.new('','')])
     actual   = parse_string ""
-    expect(actual).to eq Nydp::StringAtom.new ''
+    expect(actual).to eq ''
   end
 
   it "should parse external text" do
     actual   = parse_string "a fluffy bunny!"
-    expect(actual)        .to eq Nydp::StringAtom.new "a fluffy bunny!"
+    expect(actual)        .to eq "a fluffy bunny!"
     expect(actual.inspect).to eq '"a fluffy bunny!"'
   end
 
   it "should parse a string delimited by eof" do
     expected = pair_list([sym('string-pieces'), Nydp::StringFragmentCloseToken.new('a fluffy bunny!','a fluffy bunny!')])
     actual   = parse_string "a fluffy bunny!"
-    expect(actual)        .to eq Nydp::StringAtom.new "a fluffy bunny!"
+    expect(actual)        .to eq "a fluffy bunny!"
     expect(actual.inspect).to eq '"a fluffy bunny!"'
   end
 
   it "should parse a string with embedded code, delimited by eof" do
     x1 = sym('string-pieces')
     x2 = Nydp::StringFragmentToken.new('a fluffy bunny! ','a fluffy bunny! ~')
-    x2 = Nydp::StringAtom.new(x2.string, x2)
+    x2 = x2.string
     x3 = sym('expr')
     x4 = Nydp::StringFragmentCloseToken.new(' a purple cow!',' a purple cow!')
-    x4 = Nydp::StringAtom.new(x4.string, x4)
+    x4 = x4.string
 
     expected = pair_list([x1,x2,x3,x4])
     actual   = parse_string "a fluffy bunny! ~expr a purple cow!"
@@ -59,15 +59,15 @@ describe Nydp::Parser do
   it "should parse a string with embedded code containing a nested string, delimited by eof" do
     n1 = sym(:foo)
     n2 = sym(:bar)
-    n3 = Nydp::StringAtom.new 'an embedded bunny :)'
+    n3 = 'an embedded bunny :)'
     n4 = sym(:zop)
 
     x1 = sym('string-pieces')
     x2 = Nydp::StringFragmentToken.new('a fluffy bunny! ','a fluffy bunny! ~')
-    x2 = Nydp::StringAtom.new(x2.string, x2)
+    x2 = x2.string
     x3 = pair_list [n1, n2, n3, n4]
     x4 = Nydp::StringFragmentCloseToken.new(' a purple cow!',' a purple cow!')
-    x4 = Nydp::StringAtom.new(x4.string, x4)
+    x4 = x4.string
 
     expected = pair_list([x1,x2,x3,x4])
     actual   = parse_string 'a fluffy bunny! ~(foo bar "an embedded bunny :)" zop) a purple cow!'
@@ -80,10 +80,10 @@ describe Nydp::Parser do
 
     s1 = sym('string-pieces')
     s2 = Nydp::StringFragmentToken.new('a rather ','a rather ~')
-    s2 = Nydp::StringAtom.new(s2.string, s2)
+    s2 = s2.string
     s3 = pair_list [e1, e2]
     s4 = Nydp::StringFragmentCloseToken.new(' bunny :)',' bunny :)"')
-    s4 = Nydp::StringAtom.new(s4.string, s4)
+    s4 = s4.string
 
     n1 = sym(:foo)
     n2 = sym(:bar)
@@ -92,10 +92,10 @@ describe Nydp::Parser do
 
     x1 = sym('string-pieces')
     x2 = Nydp::StringFragmentToken.new('a fluffy bunny! ','a fluffy bunny! ~')
-    x2 = Nydp::StringAtom.new(x2.string, x2)
+    x2 = x2.string
     x3 = pair_list [n1, n2, n3, n4]
     x4 = Nydp::StringFragmentCloseToken.new(' a purple cow!',' a purple cow!')
-    x4 = Nydp::StringAtom.new(x4.string, x4)
+    x4 = x4.string
 
     expected = pair_list([x1,x2,x3,x4])
     actual   = parse_string "a fluffy bunny! ~(foo bar \"a rather ~(describe bunny) bunny :)\" zop) a purple cow!"

data/spec/foreign_hash_spec.rb

@@ -9,7 +9,7 @@ describe Nydp::Hash do
     describe "hash set" do
       it "returns a new Nydp hash" do
         k    = Nydp::Symbol.mk "keysym", ns
-        v    = Nydp::StringAtom.new "foobar"
+        v    = "foobar"
         args = pair_list [ahash, k, v]
         Nydp::Builtin::HashSet.instance.invoke vm, args
 
@@ -29,7 +29,7 @@ describe Nydp::Hash do
 
         Nydp::Builtin::HashGet.instance.invoke vm, pair_list(args)
 
-        expect(vm.args.pop).to eq Nydp::StringAtom.new("avalue")
+        expect(vm.args.pop).to eq "avalue"
       end
 
       it "converts ruby nil to nydp value" do
@@ -84,5 +84,17 @@ describe Nydp::Hash do
         expect(vm.args.pop).to eq pair_list [sym("k0"), sym("k1")]
       end
     end
+
+    describe "hash-slice" do
+      it "returns a new hash containing only the given keys from the old hash" do
+        ahash[:k0] = 42
+        ahash[:k1] = 84
+        args       = [ahash, pair_list([sym("k0"), sym("k1")])]
+
+        Nydp::Builtin::HashSlice.instance.invoke vm, pair_list(args)
+
+        expect(vm.args.pop).to eq({ k0: 42, k1: 84 })
+      end
+    end
   end
 end

data/spec/hash_non_hash_behaviour_spec.rb

@@ -20,15 +20,15 @@ describe Nydp::Hash do
         args   = [ ahash, k ]
 
         Nydp::Builtin::HashGet.instance.invoke vm, pair_list(args)
-        expect(vm.args.pop).to eq Nydp::StringAtom.new("hello there")
+        expect(vm.args.pop).to eq "hello there"
       end
 
       it "converts string keys to method names" do
-        k      = Nydp::StringAtom.new "b"
+        k      = "b"
         args   = [ ahash, k ]
 
         Nydp::Builtin::HashGet.instance.invoke vm, pair_list(args)
-        expect(vm.args.pop).to eq Nydp::StringAtom.new("hello there")
+        expect(vm.args.pop).to eq "hello there"
       end
 
       it "returns nil for unavailable methods" do
@@ -42,7 +42,7 @@ describe Nydp::Hash do
   end
 
   describe "unfriendly non-hash" do
-    let(:ahash) { Nydp::StringAtom.new "this here ain't no hash, hombre" }
+    let(:ahash) { "this here ain't no hash, hombre" }
 
     def cleanup_err_msg txt
       txt.gsub(/at \/.*:in `builtin_invoke'/, '<error info>')
@@ -51,7 +51,7 @@ describe Nydp::Hash do
     describe "hash set" do
       it "does nothing, returns its value" do
         k    = Nydp::Symbol.mk "keysym", ns
-        v    = Nydp::StringAtom.new "foobar"
+        v    = "foobar"
         args = pair_list [ahash, k, v]
 
         begin
@@ -66,7 +66,7 @@ with args
   keysym
   \"foobar\""
 
-        expect(cleanup_err_msg error.cause.message).to eq "hash-set: Not a hash: Nydp::StringAtom"
+        expect(cleanup_err_msg error.cause.message).to eq "_nydp_get : not settable: keysym on String"
       end
     end
 
@@ -86,7 +86,7 @@ with args
   \"this here ain't no hash, hombre\"
   keysym"
 
-        expect(cleanup_err_msg error.cause.message).to eq "hash-get: Not a hash: Nydp::StringAtom"
+        expect(cleanup_err_msg error.cause.message).to eq "_nydp_get : not gettable: keysym on String"
       end
     end
   end

data/spec/hash_spec.rb

@@ -16,7 +16,7 @@ describe Nydp::Hash do
 
     it "converts ruby string key to nydp string key" do
       hash = Nydp::Hash.new
-      hash[Nydp::StringAtom.new "boo"] = 42
+      hash["boo"] = 42
 
       rhash = hash.to_ruby
       expect(rhash["boo"]).to eq 42
@@ -123,7 +123,7 @@ describe Nydp::Hash do
     describe "hash set" do
       it "does nothing, returns its value" do
         k    = Nydp::Symbol.mk "keysym", ns
-        v    = Nydp::StringAtom.new "foobar"
+        v    = "foobar"
         args = pair_list [ahash, k, v]
         Nydp::Builtin::HashSet.instance.invoke vm, args
 
@@ -143,4 +143,26 @@ describe Nydp::Hash do
       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
+      sfoo = sym "foo"
+      sbar = sym "bar"
+      syak = sym "yak"
+      szeb = sym "zeb"
+
+      h = Nydp::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)
+
+      expect(vm.args.pop).to eq({ sbar => 42, szeb => 99 })
+    end
+  end
 end

data/spec/nydp_spec.rb

@@ -22,7 +22,7 @@ describe Nydp do
   end
 
   it "should add strings" do
-    expect(run '(+ "hello" " " "world")').to eq Nydp::StringAtom.new("hello world")
+    expect(run '(+ "hello" " " "world")').to eq "hello world"
   end
 
   it "should add Pairs" do
@@ -46,7 +46,7 @@ describe Nydp do
   end
 
   it "should convert items to strings" do
-    expect(run "(to-string 3.1415)").to eq Nydp::StringAtom.new("3.1415")
+    expect(run "(to-string 3.1415)").to eq "3.1415"
   end
 
   it "should compare integers" do
@@ -112,4 +112,16 @@ describe Nydp do
       expect(run code).to eq 17
     end
   end
+
+  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))
+
+      one_thing = run "((hash-get tt 'one_thing) 24)"
+      expect(one_thing).to eq(42 + 24)
+
+      two_things = run "((hash-get tt 'two_things) 60 2)"
+      expect(two_things).to eq(60 + (2 * 720))
+    end
+  end
 end

data/spec/parser_spec.rb

@@ -1,6 +1,7 @@
 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 }
@@ -9,6 +10,7 @@ describe Nydp::Parser do
   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 }
@@ -19,6 +21,7 @@ describe Nydp::Parser do
   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 }
 
   it "should return a stream of tokens" do
@@ -72,7 +75,7 @@ describe Nydp::Parser do
     s2 = Nydp::StringFragmentCloseToken.new "hello there", '"hello there"'
 
     x1 = 1
-    x2 = Nydp::StringAtom.new "hello there"
+    x2 = "hello there"
     x3 = 3
 
     expected = pair_list [x1, x2, x3]
@@ -82,7 +85,7 @@ describe Nydp::Parser do
 
   it "should parse a string" do
     x1 = sym 'join'
-    x2 = Nydp::StringAtom.new " - "
+    x2 = " - "
     x3 = 1
     x4 = 2
     x5 = 3
@@ -96,7 +99,7 @@ describe Nydp::Parser do
     s2 = Nydp::StringFragmentCloseToken.new "hello (1 2 3) there", '"hello (1 2 3) there"'
 
     x1 = 1
-    x2 = Nydp::StringAtom.new "hello (1 2 3) there"
+    x2 = "hello (1 2 3) there"
     x3 = 3
 
     expected = pair_list [x1, x2, x3]
@@ -108,7 +111,7 @@ describe Nydp::Parser do
     s2 = Nydp::StringFragmentCloseToken.new "hello there \"jimmy\"", '"hello there \"jimmy\""'
 
     x1 = 1
-    x2 = Nydp::StringAtom.new "hello there \"jimmy\""
+    x2 = "hello there \"jimmy\""
     x3 = 3
 
     expected = pair_list [x1, x2, x3]
@@ -117,7 +120,7 @@ describe Nydp::Parser do
   end
 
   it "should handle escaped tabs and newlines inside a string" do
-    expected = Nydp::StringAtom.new "hello\tworld\nnice day"
+    expected = "hello\tworld\nnice day"
     parsed = parse "\"hello\\tworld\\nnice day\""
     expect(parsed).to eq expected
   end
@@ -156,6 +159,14 @@ describe Nydp::Parser do
     expect(parse "foo::bar").to eq  pair_list([cocosyn, foo, bar])
   end
 
+  it "should parse an at symbol" do
+    expect(parse "foo@bar").to eq  pair_list([atsyn, foo, bar])
+  end
+
+  it "should parse a prefix-at symbol" do
+    expect(parse "@foobar").to eq  pair_list([atsyn, empty, foobar])
+  end
+
   it "should parse a colon-symbol within a colon-colon within a dotted symbol" do
     expected = parse "(colon-colon-syntax (colon-syntax (dot-syntax aa foo) foo) (colon-syntax bar (dot-syntax bar zz)))"
     expect(parse "aa.foo:foo::bar:bar.zz").to eq expected
@@ -204,7 +215,7 @@ describe Nydp::Parser do
   end
 
   it "retains otherwise unidentified list prefixes" do
-    expect(parse "%wong(bar)").to eq pair_list([prefix_list, Nydp::StringAtom.new("%wong"), pair_list([bar])])
+    expect(parse "%wong(bar)").to eq pair_list([prefix_list, "%wong", pair_list([bar])])
   end
 
   it "should do some complicated unquote stuff with lists" do
@@ -246,24 +257,24 @@ describe Nydp::Parser do
   end
 
   it "parses a simple string" do
-    expect(parse '"foo"').to eq Nydp::StringAtom.new("foo")
+    expect(parse '"foo"').to eq "foo"
   end
 
   it "parses a string with a simple interpolation" do
-    str = Nydp::StringAtom.new("foo ")
-    empty = Nydp::StringAtom.new("")
+    str = "foo "
+    empty = ""
     expect(parse '"foo ~foo"').to eq pair_list([string_pieces, str, foo, empty])
   end
 
   it "parses a string with a more complex interpolation" do
-    strf = Nydp::StringAtom.new("foo ")
-    strb = Nydp::StringAtom.new(" bar")
+    strf = "foo "
+    strb = " bar"
     expect(parse '"foo ~(foo bar) bar"').to eq pair_list([string_pieces, strf, pair_list([foo, bar]), strb])
   end
 
   it "parses a string with an interpolation containing a nested interpolation" do
-    strf = Nydp::StringAtom.new("foo ")
-    strb = Nydp::StringAtom.new(" bar")
+    strf = "foo "
+    strb = " bar"
 
     nested = pair_list [string_pieces, strf, foo, strb]
     expr   = pair_list [foo, nested, bar]
@@ -272,7 +283,7 @@ describe Nydp::Parser do
   end
 
   it "parses a string with only an interpolation" do
-    empty = Nydp::StringAtom.new("")
+    empty = ""
     expect(parse '"~foo"').to eq pair_list([string_pieces, empty, foo, empty])
   end
 
@@ -281,7 +292,7 @@ describe Nydp::Parser do
   ; here's a comment
   (zab))
 "
-    c1 = pair_list([comment, Nydp::StringAtom.new("here's a comment")])
+    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)
@@ -311,7 +322,7 @@ NYDP
     expect(args[1]).to eq sym("args")
     expect(args[2]).to be_nil
     expect(parsed[2].cdr.cdr).to eq sym("body")
-    expect(parsed[3].to_a).to eq [sym("comment"), Nydp::StringAtom.new("define a new function in the global namespace")]
+    expect(parsed[3].to_a).to eq [sym("comment"), "define a new function in the global namespace"]
     expect(parsed[4].to_a).to eq [sym("chapter"), sym("nydp-core")]
   end
 end

data/spec/rand_spec.rb

@@ -0,0 +1,45 @@
+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
+  end
+
+  describe "zero args" do
+    it "returns values between 0 and 1" do
+      numbers = (0..100).map { |i| get_rand }
+      expect(numbers.all? { |n| n >= 0 && n < 1 })
+      avg = numbers.reduce &:+
+      expect(avg).to be_between 40, 60 # with high probability
+      distinct = Set.new numbers
+      expect(distinct.count).to be > 90
+    end
+  end
+
+  describe "one arg" do
+    it "returns values between 0 and arg" do
+      numbers = (0..200).map { |i| get_rand 10 }
+      expect(numbers.all? { |n| n >= 0 && n < 10 })
+      avg = numbers.reduce &:+
+      expect(avg).to be_between 800, 1200 # with high probability
+      distinct = Set.new numbers
+      expect(distinct.count).to eq 10
+    end
+  end
+
+  describe "two arg" do
+    it "returns values between arg 0 and arg 1" do
+      numbers = (0..200).map { |i| get_rand 10, 20 }
+      expect(numbers.all? { |n| n >= 10 && n < 20 })
+      avg = numbers.reduce &:+
+      expect(avg).to be_between 2800, 3200 # with high probability
+      distinct = Set.new numbers
+      expect(distinct.count).to eq 10
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -37,5 +37,17 @@ class TestThing
     "(TestThing #{a.inspect} #{b.inspect})"
   end
 
-  def _nydp_safe_methods ; %i{ a b } ; end
+  def one_thing x
+    x + a
+  end
+
+  def two_things x, y
+    x + (y * b)
+  end
+
+  def _nydp_get name
+    name = name.to_s.to_sym
+    return send(name) if name == :a || name == :b
+    return method(name) if name == :one_thing || name == :two_things
+  end
 end