nydp 0.0.1

data/spec/embedded_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Nydp::Parser do
+
+  let(: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(: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(: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 }
+
+  def sym name
+    Nydp::Symbol.mk name.to_sym, ns
+  end
+
+  def parse_string txt, open_delim, close_delim
+    Nydp::Parser.new(ns).string(Nydp::Tokeniser.new(txt), open_delim, close_delim)
+  end
+
+  def pair_list xs, last=Nydp.NIL
+    Nydp::Pair.from_list xs, last
+  end
+
+  it "should parse empty string" do
+    expected = pair_list([sym('string-pieces'), Nydp::StringFragmentCloseToken.new('','$%')])
+    actual   = parse_string "%", '$', /%/
+    expect(actual).to eq ''
+  end
+
+  it "should parse external text" do
+    actual   = parse_string "a fluffy bunny!", 'EAT ', /!/
+    expect(actual)        .to eq "a fluffy bunny"
+    expect(actual.inspect).to eq "EAT 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!", '', :eof
+    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! %%')
+    x3 = sym('expr')
+    x4 = Nydp::StringFragmentCloseToken.new(' a purple cow!',' a purple cow!')
+
+    expected = pair_list([x1,x2,x3,x4])
+    actual   = parse_string "a fluffy bunny! %%expr a purple cow!", ':', :eof
+    expect(actual).to eq expected
+  end
+
+  it "should parse a string with embedded code containing a nested string, delimited by eof" do
+    n1 = sym(:foo)
+    n2 = sym(:bar)
+    n3 = 'an embedded bunny :)'
+    n4 = sym(:zop)
+
+    x1 = sym('string-pieces')
+    x2 = Nydp::StringFragmentToken.new('a fluffy bunny! ','------->a fluffy bunny! %%')
+    x3 = pair_list [n1, n2, n3, n4]
+    x4 = Nydp::StringFragmentCloseToken.new(' a purple cow!',' a purple cow!')
+
+    expected = pair_list([x1,x2,x3,x4])
+    actual   = parse_string "a fluffy bunny! %%(foo bar \"an embedded bunny :)\" zop) a purple cow!", '------->', :eof
+    expect(actual).to eq expected
+  end
+
+  it "should parse a string with embedded code containing a nested string containing more embedded code, delimited by eof" do
+    e1 = sym(:describe)
+    e2 = sym(:bunny)
+
+    s1 = sym('string-pieces')
+    s2 = Nydp::StringFragmentToken.new('a rather ','"a rather %%')
+    s3 = pair_list [e1, e2]
+    s4 = Nydp::StringFragmentCloseToken.new(' bunny :)',' bunny :)"')
+
+    n1 = sym(:foo)
+    n2 = sym(:bar)
+    n3 = pair_list [s1, s2, s3, s4]
+    n4 = sym(:zop)
+
+    x1 = sym('string-pieces')
+    x2 = Nydp::StringFragmentToken.new('a fluffy bunny! ','------->a fluffy bunny! %%')
+    x3 = pair_list [n1, n2, n3, n4]
+    x4 = Nydp::StringFragmentCloseToken.new(' a purple cow!',' a purple cow!')
+
+    expected = pair_list([x1,x2,x3,x4])
+    actual   = parse_string "a fluffy bunny! %%(foo bar \"a rather %%(describe bunny) bunny :)\" zop) a purple cow!", '------->', :eof
+    expect(actual).to eq expected
+  end
+
+end

data/spec/nypd_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe Nydp do
+  let(:root_ns)               { { } }
+  let(:parser)                { Nydp::Parser.new(root_ns) }
+  let(:vm)                    { Nydp::VM.new }
+
+  def sym name
+    Nydp::Symbol.mk name.to_sym, root_ns
+  end
+
+  def parse txt
+    tokens = Nydp::Tokeniser.new txt
+    expressions = []
+    expr = parser.expression(tokens)
+    while (expr != nil)
+      expressions << expr
+      expr = parser.expression(tokens)
+    end
+    expressions
+  end
+
+  def run txt
+    Nydp.setup root_ns
+    expressions = parse(txt)
+    result = nil
+    expressions.each do |expr|
+      result = Nydp.compile_and_eval vm, expr
+    end
+    result
+  end
+
+  it "should make a symbol from a string" do
+    expect(run '(sym "the-family")').to eq sym(:"the-family")
+  end
+
+  it "should sum integers" do
+    expect(run "(+ 1 2)").to eq 3
+  end
+
+  it "should add strings" do
+    expect(run '(+ "hello" " " "world")').to eq "hello world"
+  end
+
+  it "should add Pairs" do
+    expect(run "(+ '(a b) '(c d))").to eq Nydp::Pair.from_list([sym(:a), sym(:b), sym(:c), sym(:d)])
+  end
+
+  it "should add Pairs without recursing" do
+    alist = Nydp::Pair.from_list([sym(:a), sym(:a)])
+    blist = Nydp::Pair.from_list([sym(:b), sym(:b)])
+    clist = Nydp::Pair.from_list([sym(:c), sym(:c)])
+    dlist = Nydp::Pair.from_list([sym(:d), sym(:d)])
+    expect(run "(+ '((a a) (b b)) '((c c) (d d)))").to eq Nydp::Pair.from_list([alist, blist, clist, dlist])
+  end
+
+  it "should diff integers" do
+    expect(run "(- 144 121)").to eq 23
+  end
+
+  it "should multiply integers" do
+    expect(run "(* 7 11)").to eq 77
+  end
+
+  it "should convert items to strings" do
+    expect(run "(to-string 3.1415)").to eq "3.1415"
+  end
+
+  it "should compare integers" do
+    expect(run "(> 13 17)").to eq Nydp.NIL
+    expect(run "(> 29 23)").to eq Nydp.T
+    expect(run "(< 13 17)").to eq Nydp.T
+    expect(run "(< 29 23)").to eq Nydp.NIL
+  end
+
+  it "should execute an inline list function" do
+    expected = Nydp::Pair.from_list (1..3).to_a
+    expect(run "((fn a a) 1 2 3)").to eq expected
+  end
+
+  it "should execute an inline sum function" do
+    expect(run "((fn (a b) (+ a b)) 9 16)").to eq 25
+  end
+
+  it "should assign a function to a global variable and execute it" do
+    f1 = "(fn (a b) (+ a b))"
+    f2 = "(assign f1 #{f1})"
+    f3 = "(f1 36 64)"
+    result = run "#{f2} #{f3}"
+    expect(result).to eq 100
+  end
+
+  it "should call functions in a chain" do
+    f1 = "(fn (a b) (+ a b))"
+    f2 = "(assign f1 #{f1})"
+    f3 = "(fn (x y) (* x y))"
+    f4 = "(assign f3 #{f3})"
+    f5 = "(f1 (f3 6 6) (f3 8 8))"
+    result = run "#{f2} #{f4} #{f5}"
+    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)"
+    expected = parse "((contexts . 0) (instructions . 0) (args . 0))"
+    expect(run program).to eq expected.first
+  end
+
+  describe :cond do
+    it "should execute false conditionals" do
+      cond = "(cond (> 31 37) 'foo 'bar)"
+      expect(run cond).to eq sym(:bar)
+    end
+
+    it "should execute conditionals" do
+      cond = "(cond (> 37 31) 'foo 'bar)"
+      expect(run cond).to eq sym(:foo)
+    end
+  end
+
+  describe "eval" do
+    it "should eval the given expression and return the result" do
+      code = "(eval '(+ 2 (* 3 5)))"
+      expect(run code).to eq 17
+    end
+  end
+end

data/spec/pair_spec.rb

@@ -0,0 +1,102 @@
+require "spec_helper"
+
+describe Nydp::Pair do
+  let(: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(:foo)              { Nydp::Symbol.mk :foo,                ns }
+  let(:dot)              { Nydp::Symbol.mk ".".to_sym,          ns }
+
+  describe :== do
+    it "should be true for two empty lists" do
+      expect(Nydp::Pair.new(NIL, NIL)).to eq Nydp::Pair.new(NIL, NIL)
+    end
+
+    it "should be true for nested empty lists" do
+      e1 = Nydp::Pair.new(Nydp.NIL, Nydp.NIL)
+      e2 = Nydp::Pair.new(Nydp.NIL, Nydp.NIL)
+      e3 = Nydp::Pair.new(Nydp.NIL, Nydp.NIL)
+      e4 = Nydp::Pair.new(Nydp.NIL, Nydp.NIL)
+      expect(Nydp::Pair.new(e1, e2)).to eq Nydp::Pair.new(e3, e4)
+    end
+
+    it "should define #== to return true for an identical list" do
+      p1 = Nydp::Pair.from_list [:a, :b, :c, :d]
+      p2 = Nydp::Pair.from_list [:a, :b, :c, :d]
+      expect(p1).to eq p2
+    end
+
+    it "should define #== to return true for identical improper lists" do
+      p1 = Nydp::Pair.from_list [:a, :b, :c, :d], 4
+      p2 = Nydp::Pair.from_list [:a, :b, :c, :d], 4
+      expect(p1).to eq p2
+    end
+
+    it "should define #== to return false for a non-identical list" do
+      p1 = Nydp::Pair.from_list [:a, :b, :c, :d]
+      p2 = Nydp::Pair.from_list [:a, :b, :c, 22]
+      expect(p1).not_to eq p2
+    end
+
+    it "should define #== to return false for lists which differ only in their terminating element" do
+      p1 = Nydp::Pair.from_list [:a, :b, :c], :d
+      p2 = Nydp::Pair.from_list [:a, :b, :c], 22
+      expect(p1).not_to eq p2
+    end
+  end
+
+  it "should create a new pair" do
+    p = Nydp::Pair.mk :a, :b
+    expect(p.car).to eq :a
+    expect(p.cdr).to eq :b
+  end
+
+  it "should convert a ruby list" do
+    p = Nydp::Pair.from_list [:a, :b, :c, :d]
+    expect(p.car).to eq :a
+    p = p.cdr
+    expect(p.car).to eq :b
+    p = p.cdr
+    expect(p.car).to eq :c
+    p = p.cdr
+    expect(p.car).to eq :d
+    p = p.cdr
+    expect(p.car).to eq Nydp.NIL
+    expect(p.cdr).to eq Nydp.NIL
+    p = p.cdr
+    expect(p.car).to eq Nydp.NIL
+    expect(p.cdr).to eq Nydp.NIL
+  end
+
+  it "should have size zero when empty" do
+    expect(Nydp::Pair.from_list([]).size).to eq 0
+  end
+
+  it "should report the number of elements is contains" do
+    expect(Nydp::Pair.from_list([:a, :b, :c]).size).to eq 3
+  end
+
+  it "should report the number of elements in an improper list, excluding last item" do
+    expect(Nydp::Pair.from_list([:a, :b, :c, :d], :foo).size).to eq 4
+  end
+
+  it "should represent itself as a string" do
+    expect(Nydp::Pair.from_list([a, b, c, d]).to_s).to eq "(a b c d)"
+  end
+
+  it "should represent an improper list as a string" do
+    expect(Nydp::Pair.from_list([a, b, c, d], foo).to_s).to eq "(a b c d . foo)"
+  end
+
+  it "should parse a list" do
+    p = Nydp::Pair.from_list [a, b, c, d]
+    expect(Nydp::Pair.parse_list([a, b, c, d])).to eq p
+  end
+
+  it "should parse a list" do
+    p = Nydp::Pair.from_list [a, b, c, d], foo
+    expect(Nydp::Pair.parse_list([a, b, c, d, dot, foo])).to eq p
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+describe Nydp::Parser do
+
+  let(: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(: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(: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 }
+
+  def sym name
+    Nydp::Symbol.mk name.to_sym, ns
+  end
+
+  def parse txt
+    Nydp::Parser.new(ns).expression(Nydp::Tokeniser.new txt)
+  end
+
+  def pair_list xs, last=Nydp.NIL
+    Nydp::Pair.from_list xs, last
+  end
+
+  it "should return a stream of tokens" do
+    t = Nydp::Tokeniser.new ""
+    expect(t.next_token).to eq nil
+  end
+
+  it "should return another stream of tokens" do
+    t = Nydp::Tokeniser.new "(a b c 1 2 3)"
+    tt = []
+    tok = t.next_token
+    while tok
+      tt << tok
+      tok = t.next_token
+    end
+    expect(tt).to eq [[:left_paren, ""], [:symbol, "a"], [:symbol, "b"], [:symbol, "c"], [:number, 1.0], [:number, 2.0], [:number, 3.0], [:right_paren]]
+  end
+
+  it "should parse an empty expression" do
+    expect(parse "").to be_nil
+  end
+
+  it "should parse an empty expression" do
+    expect(parse "()").to eq Nydp.NIL
+  end
+
+  it "should parse a lisp expression" do
+    expect(parse "(foo bar)").to eq pair_list([foo, bar])
+  end
+
+  it "should parse numbers expression" do
+    expect(parse "(1 2 3)").to eq pair_list([1, 2, 3])
+  end
+
+  it "should parse an improper list" do
+    expect(parse "(1 2 3 . 4)").to eq pair_list([1, 2, 3], 4)
+  end
+
+  it "should parse a string" do
+    s1 = sym 'string-pieces'
+    s2 = Nydp::StringFragmentCloseToken.new "hello there", '"hello there"'
+
+    x1 = 1
+    x2 = "hello there"
+    x3 = 3
+
+    expected = pair_list [x1, x2, x3]
+
+    expect(parse '(1 "hello there" 3)').to eq expected
+  end
+
+  it "should parse a string" do
+    x1 = sym 'join'
+    x2 = " - "
+    x3 = 1
+    x4 = 2
+    x5 = 3
+
+    expected = pair_list [x1, x2, x3, x4, x5]
+
+    expect(parse '(join " - " 1 2 3)').to eq expected
+  end
+
+  it "should not get confused by embedded lisp in a string" do
+    s1 = sym 'string-pieces'
+    s2 = Nydp::StringFragmentCloseToken.new "hello (1 2 3) there", '"hello (1 2 3) there"'
+
+    x1 = 1
+    x2 = "hello (1 2 3) there"
+    x3 = 3
+
+    expected = pair_list [x1, x2, x3]
+
+    expect(parse '(1 "hello (1 2 3) there" 3)').to eq expected
+  end
+
+  it "should handle escaped quotes inside a string" do
+    s1 = sym 'string-pieces'
+    s2 = Nydp::StringFragmentCloseToken.new "hello there \"jimmy\"", '"hello there \"jimmy\""'
+
+    x1 = 1
+    x2 = "hello there \"jimmy\""
+    x3 = 3
+
+    expected = pair_list [x1, x2, x3]
+
+    expect(parse '(1 "hello there \"jimmy\"" 3)').to eq expected
+  end
+
+  it "should parse a plain symbol" do
+    expect(parse "foo").to eq foo
+  end
+
+  it "should parse a dotted symbol" do
+    expect(parse "foo.bar").to eq  pair_list([dotsyn, foo, bar])
+  end
+
+  it "should parse a colon-colon symbol" do
+    expect(parse "foo::bar").to eq  pair_list([cocosyn, foo, bar])
+  end
+
+  it "should parse a colon-symbol within a colon-colon within a dotted symbol" do
+    expect(parse "aa.foo:foo::bar:bar.zz").to eq pair_list([dotsyn, aa, pair_list([cocosyn, pair_list([colosyn, foo, foo]), pair_list([colosyn, bar, bar])]), zz])
+  end
+
+  it "should quote symbols" do
+    expect(parse "'foo").to eq pair_list([quote, foo])
+  end
+
+  it "should quote-unquote symbols" do
+    expect(parse "',foo").to eq pair_list([quote, pair_list([unquote, foo])])
+  end
+
+  it "should quote lists" do
+    expect(parse "'(foo)").to eq pair_list([quote, pair_list([foo])])
+  end
+
+  it "should unquote atoms" do
+    expect(parse ",foo").to eq pair_list([unquote, foo])
+  end
+
+  it "should unquote lists" do
+    expect(parse ",(bar)").to eq pair_list([unquote, pair_list([bar])])
+  end
+
+  it "should unquote-splicing atoms" do
+    expect(parse ",@foo").to eq pair_list([unquote_splicing, foo])
+  end
+
+  it "should unquote-splicing lists" do
+    expect(parse ",@(bar)").to eq pair_list([unquote_splicing, pair_list([bar])])
+  end
+
+  it "should quasiquote atoms" do
+    expect(parse "`foo").to eq pair_list([quasiquote, foo])
+  end
+
+  it "should quasiquote lists" do
+    expect(parse "`(bar)").to eq pair_list([quasiquote, pair_list([bar])])
+  end
+
+  it "should parse nested lists" do
+    expect(parse "(a b (c) d)").to eq pair_list([a, b, pair_list([c]), d])
+  end
+
+  it "should even parse comments" do
+    txt = "(def foo (bar)
+  ; here's a comment
+  (zab))
+"
+    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)
+    expr = pair_list([fdef, foo, fbar, c1, fzab])
+    expect(parse txt).to eq expr
+  end
+end