nydp 0.0.2 → 0.0.3

data/lib/nydp/function_invocation.rb

@@ -1,4 +1,7 @@
 module Nydp
+  class InvocationFailed < StandardError
+  end
+
   class InvokeFunctionInstruction
     def initialize arg_count, source_expression
       @source_expression = source_expression
@@ -8,24 +11,22 @@ module Nydp
     def execute vm
       args = vm.pop_args @arg_count
       args.car.invoke vm, args.cdr
+    rescue Nydp::Error => ne
+      raise ne
+    rescue InvocationFailed => i_f
+      raise i_f
     rescue Exception => e
-      puts "failed to execute fn #{args.inspect}"
-      puts "source was #{source}"
-      puts "function was #{args.car.inspect}"
-      vm.error e
-    end
-
-    def inspect
-      "#{self.class.name}:#{source}"
+      msg  =  "failed to execute invocation #{args.inspect}"
+      msg +=  "\nsource was #{source.inspect}"
+      msg +=  "\nfunction name was #{source.car.inspect}"
+      i_f = InvocationFailed.new "#{msg}\n#{vm.error}#{e.message}"
+      i_f.set_backtrace e.backtrace
+      raise i_f
     end
 
-    def source
-      @source_expression
-    end
-
-    def to_s
-      source
-    end
+    def inspect ; source.inspect     ; end
+    def source  ; @source_expression ; end
+    def to_s    ; source.to_s        ; end
   end
 
   class FunctionInvocation
@@ -44,9 +45,7 @@ module Nydp
       vm.push_instructions @argument_instructions, vm.peek_context
     end
 
-    def inspect; "#function_invocation:#{to_s}"; end
-    def to_s
-      @source.to_s
-    end
+    def inspect ; @source.inspect ; end
+    def to_s    ; @source.to_s    ; end
   end
 end

data/lib/nydp/interpreted_function.rb

@@ -73,7 +73,7 @@ module Nydp
 
     def inspect; to_s; end
     def to_s
-      "(fn #{arg_names.to_s} #{body.map { |b| b.to_s}.join(' ')})"
+      "(fn #{arg_names.to_s} #{body.map { |b| b.inspect}.join(' ')})"
     end
   end
 end

data/lib/nydp/pair.rb

@@ -12,10 +12,11 @@ class Nydp::Pair
     new a, b
   end
 
-  def caar; car.car; end
-  def cadr; cdr.car; end
-  def cdar; car.cdr; end
-  def cddr; cdr.cdr; end
+  def nydp_type ; :pair   ; end
+  def caar      ; car.car ; end
+  def cadr      ; cdr.car ; end
+  def cdar      ; car.cdr ; end
+  def cddr      ; cdr.cdr ; end
 
   def self.parse_list list
     if sym? list.slice(-2), "."

data/lib/nydp/parser.rb

@@ -10,8 +10,7 @@ module Nydp
       Nydp::Symbol.mk name.to_sym, ns
     end
 
-    def read_list token_stream, termination_token
-      list = []
+    def read_list token_stream, termination_token, list=[]
       token = token_stream.next_token
       while token != nil && token.first != termination_token
         list << next_form(token, token_stream)
@@ -51,19 +50,19 @@ module Nydp
         Pair.from_list [sym(:unquote), parse_symbol($1)]
       else
         syms = txt.to_s.split /\./
-        return split_sym syms, sym(:"dot-syntax") if syms.length > 1
+        return split_sym syms, sym("dot-syntax") if syms.length > 1
 
         syms = txt.split /::/
-        return split_sym syms, sym(:"colon-colon-syntax") if syms.length > 1
+        return split_sym syms, sym("colon-colon-syntax") if syms.length > 1
 
         syms = txt.split /:/
-        return split_sym syms, sym(:"colon-syntax") if syms.length > 1
+        return split_sym syms, sym("colon-syntax") if syms.length > 1
 
         syms = txt.split /->/
-        return split_sym syms, sym(:"arrow-syntax") if syms.length > 1
+        return split_sym syms, sym("arrow-syntax") if syms.length > 1
 
         syms = txt.split(/=>/)
-        return split_sym syms, sym(:"rocket-syntax") if syms.length > 1
+        return split_sym syms, sym("rocket-syntax") if syms.length > 1
 
         sym txt
       end
@@ -89,6 +88,8 @@ module Nydp
         string token_stream, token.last, close_delimiter_for(token.last)
       when :left_paren
         prefix_list token[1], read_list(token_stream, :right_paren)
+      when :left_brace
+        prefix_list token[1], read_list(token_stream, :right_brace, [sym("brace-list")])
       when :symbol
         parse_symbol token.last
       when :comment
@@ -105,16 +106,15 @@ module Nydp
     def string token_stream, open_delimiter, close_delimiter
       fragments = [sym(:"string-pieces")]
       string_token = token_stream.next_string_fragment(open_delimiter, close_delimiter)
-      fragments << string_token
+      fragments << Nydp::StringAtom.new(string_token.string, string_token)
       while !(string_token.is_a? StringFragmentCloseToken)
         fragments << expression(token_stream)
         string_token = token_stream.next_string_fragment('', close_delimiter)
-        fragments << string_token
+        fragments << Nydp::StringAtom.new(string_token.string, string_token)
       end
 
       if fragments.size == 2
-        tok = fragments[1]
-        return Nydp::StringAtom.new tok.string, tok
+        return fragments[1]
       else
         return Pair.from_list fragments
       end

data/lib/nydp/runner.rb

@@ -0,0 +1,66 @@
+module Nydp
+  class Runner
+    attr_accessor :vm, :ns
+
+    def initialize vm, ns
+      @vm = vm
+      @ns = ns
+      @precompile = Symbol.mk(:"pre-compile", ns)
+      @quote      = Symbol.mk(:quote, ns)
+    end
+
+    def compile_and_eval expr
+      vm.thread Pair.new(Compiler.compile(expr, Nydp.NIL), Nydp.NIL)
+    end
+
+    def quote expr
+      Pair.from_list [@quote, expr]
+    end
+
+    def precompile expr
+      Pair.from_list [@precompile, quote(expr)]
+    end
+
+    def pre_compile expr
+      compile_and_eval(precompile(expr))
+    end
+
+    def evaluate expr
+      compile_and_eval(pre_compile(expr))
+    end
+  end
+
+  class StreamRunner < Runner
+    attr_accessor :stream, :parser
+
+    def initialize vm, ns, stream
+      super vm, ns
+      @stream = stream
+      @parser = Nydp::Parser.new(ns)
+      @tokens = Nydp::Tokeniser.new stream
+    end
+
+    def prompt *_
+    end
+
+    def run
+      res = Nydp.NIL
+      prompt
+      while !@tokens.finished
+        expr = parser.expression(@tokens)
+        unless expr.nil?
+          res = evaluate expr
+          prompt res
+        end
+      end
+      res
+    end
+  end
+
+  class Repl < StreamRunner
+    def prompt val=nil
+      puts val if val
+      print "nydp > "
+    end
+  end
+end

data/lib/nydp/string_atom.rb

@@ -5,12 +5,11 @@ module Nydp
       @string, @token = string, token
     end
 
-    def to_s
-      string
-    end
+    def nydp_type ; :string ; end
+    def to_s      ;  string ; end
 
     def inspect
-      token ? token.rep : string.inspect
+      string.inspect
     end
 
     def == other
@@ -20,5 +19,6 @@ module Nydp
     def + other
       StringAtom.new "#{@string}#{other}"
     end
+
   end
 end

data/lib/nydp/string_token.rb

@@ -10,9 +10,7 @@ module Nydp
     end
 
     def == other
-      %i{ string rep class }.inject(true) { |bool, attr|
-          bool && (self.send(attr) == other.send(attr))
-        }
+      (self.class == other.class) && (self.string == other.string)
     end
   end
 

data/lib/nydp/symbol.rb

@@ -29,13 +29,8 @@ class Nydp::Symbol
     ns[name.to_sym]
   end
 
-  def inspect
-    "(sym #{name.to_s})"
-  end
-
-  def to_s
-    name.to_s
-  end
+  def inspect ; to_s      ; end
+  def to_s    ; name.to_s ; end
 
   def == other
     other.is_a?(Nydp::Symbol) && (self.name == other.name)

data/lib/nydp/tokeniser.rb

@@ -28,8 +28,12 @@ module Nydp
         if esc = s.scan(/\\/)
           rep    << esc
           ch = s.getch
-          string << ch
-          rep    << ch
+          case ch
+            when "n" ; string << "\n"
+            when "t" ; string << "\t"
+            else       string << ch
+          end
+          rep << ch
         elsif closer = close_delimiter?(s, close_delimiter)
           rep << closer
           return StringFragmentCloseToken.new(string, rep)
@@ -62,13 +66,15 @@ module Nydp
           tok = [:embed_suffix, embed_suffix]
         elsif list_prefix = s.scan(/[^\s()]*\(/)
           tok = [:left_paren, list_prefix[0...-1]]
+        elsif list_prefix = s.scan(/[^\s()]*\{/)
+          tok = [:left_brace, list_prefix[0...-1]]
         elsif s.scan(/\)/)
           tok = [:right_paren]
         elsif number = s.scan(/[-+]?[0-9]*\.[0-9]+([eE][-+]?[0-9]+)?/)
           tok = [:number, number.to_f]
         elsif integer = s.scan(/[-+]?[0-9]+/)
           tok = [:number, integer.to_i]
-        elsif atom = s.scan(/[^\s()]+/)
+        elsif atom = s.scan(/[^\s()"{}]+/)
           tok = [:symbol, atom]
         else
           s.getch

data/lib/nydp/truth.rb

@@ -3,22 +3,21 @@ module Nydp
     def to_s      ; 't'              ; end
     def inspect   ; 't[nydp::Truth]' ; end
     def assign *_ ; self             ; end
+    def nydp_type ; :truth           ; end
   end
 
   class Nil
     def car         ; self          ; end
     def cdr         ; self          ; end
     def size        ; 0             ; end
-    def is?   other ; other == self ; end
-    def isnt? other ; other != self ; end
-    def to_s        ; "nil"         ; end
+    def is?   other ; (self.equal? other) ; end
+    def isnt? other ; !is?(other)   ; end
+    def to_s        ; ""            ; end
     def + other     ; other         ; end
     def copy        ; self          ; end
     def assign *_   ; self          ; end
-
-    def inspect
-      "nil[Nydp::Nil]"
-    end
+    def inspect     ; "nil"         ; end
+    def nydp_type   ; :nil          ; end
 
     def execute vm
       vm.push_arg self
@@ -32,6 +31,9 @@ module Nydp
   @@nil = Nil.new
   @@t   = Truth.new
 
+  class Nil
+    def self.new ; raise "no" ; end
+  end
   def self.NIL; @@nil; end
   def self.T;   @@t;   end
 end

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/nydp/vm.rb

@@ -41,36 +41,29 @@ module Nydp
       end
     end
 
-    def error e
-      puts "     error"
-      puts e
-      puts "================="
-      puts
-      puts "instruction stack"
-      puts "================="
+    def error
+      msg = ""
+      msg << "\n"
+      msg << "\ninstruction stack"
+      msg << "\n================="
       instructions.each_with_index do |ii, ix|
-        puts "instructions##{ix} : #{ii} #{ii.source if ii.respond_to?(:source)}"
+        msg << "\ninstructions##{ix} : #{ii} #{ii.source if ii.respond_to?(:source)}"
       end
-      puts
-      puts
-      puts "context stack"
-      puts "================="
+      msg << "\n"
+      msg << "\n"
+      msg << "\ncontext stack"
+      msg << "\n================="
       contexts.each_with_index do |ctx, ix|
-        puts "context##{ix} : #{ctx}"
+        msg << "\ncontext##{ix} : #{ctx}"
       end
-      puts
-      puts
-      puts "ruby backtrace"
-      puts "================="
-      (e.backtrace || []).each_with_index do |ctx, ix|
-        puts "#{ctx}"
-      end
-      puts
-      puts
+      msg << "\n"
+      msg << "\n"
 
       instructions = []
       contexts     = []
       args = [Nydp.NIL]
+
+      msg
     end
   end
 end

data/spec/boot_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Nydp do
-  let(:ns)                    { { } }
   let(:vm)                    { Nydp::VM.new }
 
   before {
@@ -10,10 +9,6 @@ describe Nydp do
     Nydp::StreamRunner.new(vm, ns, File.new(boot_path)).run
   }
 
-  def sym name
-    Nydp::Symbol.mk name.to_sym, ns
-  end
-
   def list *things
     Nydp::Pair.from_list things.map { |thing|
       case thing
@@ -102,7 +97,7 @@ describe Nydp do
   describe :or do
     it "should produce some nested conds" do
       result = run "(reset-uniq-counter) (pre-compile '(or a b c))"
-      expect(result.to_s).to eq "((fn (ora-3) (cond ora-3 ora-3 ((fn (ora-4) (cond ora-4 ora-4 ((fn (ora-5) (cond ora-5 ora-5)) c))) b))) a)"
+      expect(result).to eq parse "((fn (ora-1) (cond ora-1 ora-1 ((fn (ora-2) (cond ora-2 ora-2 ((fn (ora-3) (cond ora-3 ora-3 nil)) c))) b))) a)"
     end
   end
 

data/spec/embedded_spec.rb

@@ -1,8 +1,6 @@
 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 }
@@ -21,18 +19,10 @@ describe Nydp::Parser do
   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 "%", '$', /%/
@@ -42,21 +32,23 @@ describe Nydp::Parser do
   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!"
+    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
     expect(actual)        .to eq "a fluffy bunny!"
-    expect(actual.inspect).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)
     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
@@ -71,8 +63,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)
     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
@@ -85,8 +79,10 @@ describe Nydp::Parser do
 
     s1 = sym('string-pieces')
     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 :)"')
+    s4 = Nydp::StringAtom.new(s4.string, s4)
 
     n1 = sym(:foo)
     n2 = sym(:bar)
@@ -95,8 +91,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)
     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