nydp 0.3.0 → 0.4.0

data/lib/nydp/truth.rb

@@ -17,8 +17,8 @@ module Nydp
     def car         ; self          ; end
     def cdr         ; self          ; end
     def size        ; 0             ; end
-    def is?   other ; other.class == self.class ; end
-    def isnt? other ; other.class != self.class ; end
+    def is?   other ; self == other ; end
+    def isnt? other ; self != other ; end
     def to_s        ; ""            ; end
     def + other     ; other         ; end
     def copy        ; self          ; end

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/nydp/vm.rb

@@ -1,7 +1,8 @@
 module Nydp
   class VM
+    NIL = Nydp::NIL
     include Helper
-    attr_accessor :instructions, :args, :contexts, :current_context, :locals, :unhandled_error, :last_error, :ns
+    attr_accessor :instructions, :args, :contexts, :current_context, :locals, :unhandled_error, :last_error, :ns, :thisi
 
     module Finally     ; end
     module HandleError ; end
@@ -14,36 +15,56 @@ module Nydp
       @ns           = ns
     end
 
-    def r2n obj
-      super obj, self.ns
+    def r2n              obj ; super obj, @ns              ; end
+
+    def push_instructions ii, ctx
+      if @current_instructions && NIL != @current_instructions
+        @instructions.push @current_instructions
+        @contexts.push @current_context
+      end
+
+      @current_instructions = ii
+      @current_context = ctx
+    end
+
+    def push_ctx_instructions ii
+      if @current_instructions && NIL != @current_instructions
+        @instructions.push @current_instructions
+        @contexts.push @current_context
+      end
+
+      @current_instructions = ii
     end
 
-    def thread expr=nil
-      instructions.push expr if expr
-      while instructions.first
+    def thread_with_expr expr
+      @current_instructions = expr
+      thread
+    end
+
+    def thread
+      while @current_instructions
         begin
-          thisi = instructions.pop
-          if thisi.cdr.is_a? Nydp::Nil
-            self.current_context = contexts.pop
+          if NIL == @current_instructions
+            @current_instructions = @instructions.pop
+            @current_context      = @contexts.pop
           else
-            self.current_context = contexts.last
-            instructions.push thisi.cdr
+            now = @current_instructions.car
+            @current_instructions = @current_instructions.cdr
+            now.execute(self)
           end
-          thisi.car.execute(self)
+
         rescue StandardError => e
           handle_error e
         end
       end
-      raise_unhandled_error
-      args.pop
-    end
 
-    def raise_unhandled_error
-      if unhandled_error
-        e = unhandled_error
-        self.unhandled_error = nil
+      if @unhandled_error
+        e = @unhandled_error
+        @unhandled_error = nil
         raise e
       end
+
+      args.pop
     end
 
     def handle_error ex
@@ -52,19 +73,18 @@ module Nydp
       protecti = []
       protectc = []
 
-      while (instructions.length > 0) && !(instructions.last.car.is_a? HandleError)
-        if instructions.last.car.is_a? Finally
-          protecti << instructions.last
-          protectc << contexts.last
+      while (@instructions.length > 0) && !(@instructions.last.car.is_a? HandleError)
+        if @instructions.last.car.is_a? Finally
+          protecti << @instructions.last
+          protectc << @contexts.last
         end
 
-        instructions.pop
-        contexts.pop
+        @instructions.pop
+        @contexts.pop
       end
 
       while protecti.length > 0
-        instructions.push protecti.pop
-        contexts.push protectc.pop
+        push_instructions protecti.pop, protectc.pop
       end
     end
 

data/spec/date_spec.rb

@@ -60,7 +60,7 @@ describe Nydp::Date do
 
         f.invoke vm, pair_list([d1, d0])
 
-        expect(vm.args.pop).to eq Nydp::T
+        expect(vm.args.pop).to eq d0
       end
 
       it "compares with nil" do
@@ -86,7 +86,7 @@ describe Nydp::Date do
 
         f.invoke vm, pair_list([d0, d1])
 
-        expect(vm.args.pop).to eq Nydp::T
+        expect(vm.args.pop).to eq d1
       end
 
       it "works with builtin less-than when false" do

data/spec/embedded_spec.rb

@@ -19,40 +19,40 @@ describe Nydp::Parser do
   let(:cocosyn)          { Nydp::Symbol.mk :"colon-colon-syntax", ns }
   let(:colosyn)          { Nydp::Symbol.mk :"colon-syntax",       ns }
 
-  def parse_string txt, open_delim, close_delim
+  def parse_string txt
     reader = Nydp::StringReader.new txt
-    Nydp::Parser.new(ns).string(Nydp::Tokeniser.new(reader), open_delim, close_delim)
+    Nydp.new_parser(ns).embedded(Nydp.new_tokeniser(reader))
   end
 
   it "should parse empty string" do
-    expected = pair_list([sym('string-pieces'), Nydp::StringFragmentCloseToken.new('','$%')])
-    actual   = parse_string "%", '$', /%/
+    expected = pair_list([sym('string-pieces'), Nydp::StringFragmentCloseToken.new('','')])
+    actual   = parse_string ""
     expect(actual).to eq Nydp::StringAtom.new ''
   end
 
   it "should parse external text" do
-    actual   = parse_string "a fluffy bunny!", 'EAT ', /!/
-    expect(actual)        .to eq Nydp::StringAtom.new "a fluffy bunny"
-    expect(actual.inspect).to eq '"a fluffy bunny"'
+    actual   = parse_string "a fluffy bunny!"
+    expect(actual)        .to eq Nydp::StringAtom.new "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!", '', :eof
+    actual   = parse_string "a fluffy bunny!"
     expect(actual)        .to eq Nydp::StringAtom.new "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::StringFragmentToken.new('a fluffy bunny! ','a fluffy bunny! ~')
     x2 = Nydp::StringAtom.new(x2.string, x2)
     x3 = sym('expr')
     x4 = Nydp::StringFragmentCloseToken.new(' a purple cow!',' a purple cow!')
     x4 = Nydp::StringAtom.new(x4.string, x4)
 
     expected = pair_list([x1,x2,x3,x4])
-    actual   = parse_string "a fluffy bunny! ~expr a purple cow!", ':', :eof
+    actual   = parse_string "a fluffy bunny! ~expr a purple cow!"
     expect(actual).to eq expected
   end
 
@@ -63,14 +63,14 @@ describe Nydp::Parser do
     n4 = sym(:zop)
 
     x1 = sym('string-pieces')
-    x2 = Nydp::StringFragmentToken.new('a fluffy bunny! ','------->a fluffy bunny! ~')
+    x2 = Nydp::StringFragmentToken.new('a fluffy bunny! ','a fluffy bunny! ~')
     x2 = Nydp::StringAtom.new(x2.string, x2)
     x3 = pair_list [n1, n2, n3, n4]
     x4 = Nydp::StringFragmentCloseToken.new(' a purple cow!',' a purple cow!')
     x4 = Nydp::StringAtom.new(x4.string, x4)
 
     expected = pair_list([x1,x2,x3,x4])
-    actual   = parse_string "a fluffy bunny! ~(foo bar \"an embedded bunny :)\" zop) a purple cow!", '------->', :eof
+    actual   = parse_string 'a fluffy bunny! ~(foo bar "an embedded bunny :)" zop) a purple cow!'
     expect(actual).to eq expected
   end
 
@@ -79,7 +79,7 @@ describe Nydp::Parser do
     e2 = sym(:bunny)
 
     s1 = sym('string-pieces')
-    s2 = Nydp::StringFragmentToken.new('a rather ','"a rather ~')
+    s2 = Nydp::StringFragmentToken.new('a rather ','a rather ~')
     s2 = Nydp::StringAtom.new(s2.string, s2)
     s3 = pair_list [e1, e2]
     s4 = Nydp::StringFragmentCloseToken.new(' bunny :)',' bunny :)"')
@@ -91,19 +91,19 @@ describe Nydp::Parser do
     n4 = sym(:zop)
 
     x1 = sym('string-pieces')
-    x2 = Nydp::StringFragmentToken.new('a fluffy bunny! ','------->a fluffy bunny! ~')
+    x2 = Nydp::StringFragmentToken.new('a fluffy bunny! ','a fluffy bunny! ~')
     x2 = Nydp::StringAtom.new(x2.string, x2)
     x3 = pair_list [n1, n2, n3, n4]
     x4 = Nydp::StringFragmentCloseToken.new(' a purple cow!',' a purple cow!')
     x4 = Nydp::StringAtom.new(x4.string, x4)
 
     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
+    actual   = parse_string "a fluffy bunny! ~(foo bar \"a rather ~(describe bunny) bunny :)\" zop) a purple cow!"
     expect(actual).to eq expected
   end
 
   it "parses a string that looks like html with little bits of embedded code in it" do
-    parsed = parse_string "<div id='item_~{id}'><label>~{data-label-1}</label> ~{data-content-1}</div>", '', :eof
+    parsed = parse_string "<div id='item_~{id}'><label>~{data-label-1}</label> ~{data-content-1}</div>"
     expect(parsed.inspect).to eq '(string-pieces "<div id=\'item_" (brace-list id) "\'><label>" (brace-list data-label-1) "</label> " (brace-list data-content-1) "</div>")'
   end
 end

data/spec/error_spec.rb

@@ -21,7 +21,7 @@ describe Nydp::VM do
       expect(error).to be_a Nydp::Error
       expect(error.message).to eq "failed to eval dflkjdgjeirgjeoi"
 
-      expect(error.cause).to be_a Nydp::Error
+      expect(error.cause).to be_a Nydp::Symbol::Unbound
       expect(error.cause.message).to eq "unbound symbol: dflkjdgjeirgjeoi"
 
       expect(vm.unhandled_error).to eq nil

data/spec/nydp_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Nydp do
-  let(:parser) { Nydp::Parser.new(ns) }
+  let(:parser) { Nydp.new_parser(ns) }
   let(:vm)     { Nydp::VM.new(ns)     }
 
   def run txt
@@ -9,6 +9,10 @@ describe Nydp do
     Nydp.eval_src ns, txt
   end
 
+  it "invokes a zero-arg function" do
+    expect(run('(to-string)').to_s).to eq ""
+  end
+
   it "should make a symbol from a string" do
     expect(run '(sym "the-family")').to eq sym(:"the-family")
   end
@@ -47,8 +51,8 @@ describe Nydp do
 
   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 23
+    expect(run "(< 13 17)").to eq 17
     expect(run "(< 29 23)").to eq Nydp::NIL
   end
 
@@ -80,7 +84,12 @@ describe Nydp do
   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)"
+    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

data/spec/parser_spec.rb

@@ -19,25 +19,14 @@ 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(:string_pieces)    { Nydp::Symbol.mk :"string-pieces",      ns }
 
   it "should return a stream of tokens" do
     reader = Nydp::StringReader.new ""
-    t = Nydp::Tokeniser.new reader
+    t = Nydp.new_tokeniser reader
     expect(t.next_token).to eq nil
   end
 
-  it "should return another stream of tokens" do
-    reader = Nydp::StringReader.new "(a b c 1 2 3)"
-    t = Nydp::Tokeniser.new reader
-    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
@@ -75,8 +64,11 @@ describe Nydp::Parser do
     expect(parse "(1 2 3 . 4)").to eq pair_list([1, 2, 3], 4)
   end
 
+  it "should parse an improper list containing symbols" do
+    expect(parse "(foo foo . bar)").to eq pair_list([foo, foo], bar)
+  end
+
   it "should parse a string" do
-    s1 = sym 'string-pieces'
     s2 = Nydp::StringFragmentCloseToken.new "hello there", '"hello there"'
 
     x1 = 1
@@ -101,7 +93,6 @@ describe Nydp::Parser do
   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
@@ -114,7 +105,6 @@ describe Nydp::Parser do
   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
@@ -255,6 +245,37 @@ describe Nydp::Parser do
     expect(parse "(a b (c) d)").to eq pair_list([a, b, pair_list([c]), d])
   end
 
+  it "parses a simple string" do
+    expect(parse '"foo"').to eq Nydp::StringAtom.new("foo")
+  end
+
+  it "parses a string with a simple interpolation" do
+    str = Nydp::StringAtom.new("foo ")
+    empty = Nydp::StringAtom.new("")
+    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")
+    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")
+
+    nested = pair_list [string_pieces, strf, foo, strb]
+    expr   = pair_list [foo, nested, bar]
+
+    expect(parse '"foo ~(foo "foo ~foo bar" bar) bar"').to eq pair_list([string_pieces, strf, expr, strb])
+  end
+
+  it "parses a string with only an interpolation" do
+    empty = Nydp::StringAtom.new("")
+    expect(parse '"~foo"').to eq pair_list([string_pieces, empty, foo, empty])
+  end
+
   it "should even parse comments" do
     txt = "(def foo (bar)
   ; here's a comment
@@ -267,4 +288,30 @@ describe Nydp::Parser do
     expr = pair_list([fdef, foo, fbar, c1, fzab])
     expect(parse txt).to eq expr
   end
+
+  it "parses an expression with whitespace before closing paren" 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)]"
+  end
+
+  it "parses a more complete expression" do
+    txt = <<NYDP
+(mac def (name args . body)
+  ; define a new function in the global namespace
+  (chapter nydp-core)
+  (define-def-expr name args (filter-forms (build-def-hash (hash)) body)))
+NYDP
+    parsed = parse(txt).to_a
+    expect(parsed[0]).to eq sym("mac")
+    expect(parsed[1]).to eq sym("def")
+    args = parsed[2].to_a
+    expect(args[0]).to eq sym("name")
+    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[4].to_a).to eq [sym("chapter"), sym("nydp-core")]
+  end
 end

data/spec/spec_helper.rb

@@ -7,8 +7,7 @@ module SpecHelper
   end
 
   def parse txt
-    reader = Nydp::StringReader.new txt
-    Nydp::Parser.new(ns).expression(Nydp::Tokeniser.new reader)
+    Nydp.new_parser(ns).expression(Nydp.new_tokeniser Nydp::StringReader.new(txt))
   end
 
   def pair_list xs, last=Nydp::NIL

data/spec/string_atom_spec.rb

@@ -32,7 +32,7 @@ describe Nydp::StringAtom do
 
     f.invoke vm, pair_list([foo, bar])
 
-    expect(vm.args.pop).to eq Nydp::T
+    expect(vm.args.pop).to eq bar
   end
 
   it "works with builtin greater-than when false" do
@@ -48,7 +48,7 @@ describe Nydp::StringAtom do
 
     f.invoke vm, pair_list([bar, foo])
 
-    expect(vm.args.pop).to eq Nydp::T
+    expect(vm.args.pop).to eq foo
   end
 
   it "works with builtin less-than when false" do