nydp 0.2.3 → 0.2.5

data/lib/nydp/pair.rb

@@ -8,21 +8,32 @@ class Nydp::Pair
     @car, @cdr = car, 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 car= thing ; @car = thing ; @_hash = nil      ; end
-  def cdr= thing ; @cdr = thing ; @_hash = nil      ; end
-  def hash       ; @_hash ||= (car.hash + cdr.hash) ; end
-  def eql? other ; self == other                    ; 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 car= thing ; @car = thing ; @_hash = nil                ; end
+  def cdr= thing ; @cdr = thing ; @_hash = nil                ; end
+  def hash       ; @_hash ||= (car.hash + cdr.hash)           ; end
+  def eql? other ; self == other                              ; end
+  def copy       ; cons(car, cdr.copy)                        ; end
+  def +    other ; copy.append other                          ; end
+  def size       ; 1 + (cdr.is_a?(Nydp::Pair) ? cdr.size : 0) ; end
+  def inspect    ; "(#{inspect_rest})"                        ; end
+
+  # returns Array of elements after calling #n2r on each element
   def to_ruby list=[]
     list << n2r(car)
     cdr.is_a?(Nydp::Pair) ? cdr.to_ruby(list) : list
   end
 
+  # returns Array of elements as they are
+  def to_a list=[]
+    list << car
+    cdr.is_a?(Nydp::Pair) ? cdr.to_a(list) : list
+  end
+
   def self.parse_list list
     if sym? list.slice(-2), "."
       from_list(list[0...-2], list.slice(-1))
@@ -39,20 +50,8 @@ class Nydp::Pair
     end
   end
 
-  def copy
-    cons(car, cdr.copy)
-  end
-
-  def + other
-    copy.append other
-  end
-
   def == other
-    (other.respond_to? :car) && (self.car == other.car) && (self.cdr == other.cdr)
-  end
-
-  def size
-    1 + (cdr.is_a?(Nydp::Pair) ? cdr.size : 0)
+    Nydp::NIL.isnt?(other) && (other.respond_to? :car) && (self.car == other.car) && (self.cdr == other.cdr)
   end
 
   def proper?
@@ -64,10 +63,6 @@ class Nydp::Pair
     cdr.each(&block) unless Nydp::NIL.is?(cdr)
   end
 
-  def inspect
-    "(#{inspect_rest})"
-  end
-
   def to_s
     if car.is_a?(Nydp::Symbol) && car.is?(:quote)
       if Nydp::NIL.is? cdr.cdr
@@ -117,15 +112,19 @@ class Nydp::Pair
   end
 
   def inspect_rest
-    cdr_s = if cdr.is_a?(self.class)
-              cdr.inspect_rest
-            elsif cdr == Nydp::NIL
-              nil
-            else
-              ". #{cdr.inspect}"
-            end
-
-    [car.inspect, cdr_s].compact.join " "
+    res = [car.inspect]
+    it = cdr
+    while it && it != Nydp::NIL
+      if it.is_a?(self.class)
+        res << it.car.inspect
+        it = it.cdr
+      else
+        res << "."
+        res << it.inspect
+        it = nil
+      end
+    end
+    res.compact.join " "
   end
 
   def append thing

data/lib/nydp/parser.rb

@@ -4,6 +4,9 @@ module Nydp
 
     def initialize ns
       @ns = ns
+      # TODO pre-initialize all the hard-coded syms used here, eg
+      # @quote = sym(:quote)
+      # @quasiquote = sym(:quasiquote)
     end
 
     def sym name

data/lib/nydp/runner.rb

@@ -50,22 +50,13 @@ module Nydp
     def compile_and_eval expr
       begin
         vm.thread Pair.new(Compiler.compile(expr, Nydp::NIL), Nydp::NIL)
-      rescue Exception => e
-        new_msg = "failed to eval #{expr.inspect}\nerror was #{Nydp.indent_text e.message}"
-        raise e.class, new_msg, e.backtrace
+      rescue StandardError => e
+        raise Nydp::Error, "failed to eval #{expr.inspect}"
       end
     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))
+      compile_and_eval(Pair.from_list [@precompile, Pair.from_list([@quote, expr])])
     end
 
     def evaluate expr
@@ -85,26 +76,13 @@ module Nydp
       @printer.puts val.inspect if @printer
     end
 
-    def handle_run_error e
-      puts e.message
-      e.backtrace.each do |b|
-        puts b
-      end
-    end
-
     def run
       Nydp.apply_function ns, :"script-run", :"script-start", name
       res = Nydp::NIL
       begin
         while !@tokens.finished
           expr = @parser.expression(@tokens)
-          unless expr.nil?
-            begin
-              print(res = evaluate(expr))
-            rescue Exception => e
-              handle_run_error e
-            end
-          end
+          print(res = evaluate(expr)) unless expr.nil?
         end
       ensure
         Nydp.apply_function ns, :"script-run", :"script-end", name
@@ -112,10 +90,4 @@ module Nydp
       res
     end
   end
-
-  class ExplodeRunner < Runner
-    def handle_run_error e
-      raise e
-    end
-  end
 end

data/lib/nydp/string_atom.rb

@@ -13,8 +13,9 @@ module Nydp
     def inspect    ; string.inspect ; end
     def hash       ; string.hash    ; end
     def length     ; string.length  ; end
-    def > other    ; self.string > other.string ; end
-    def < other    ; self.string < other.string ; end
+    def > other    ; self.string > other.string     ; end
+    def < other    ; self.string < other.string     ; end
+    def * other    ; StringAtom.new(string * other) ; end
 
     def <=> other
       self < other ? -1 : (self == other ? 0 : 1)

data/lib/nydp/symbol.rb

@@ -15,7 +15,7 @@ class Nydp::Symbol
   end
 
   def value context=nil
-    raise "unbound symbol: #{self.inspect}" if @value == nil
+    raise Nydp::Error.new("unbound symbol: #{self.inspect}") if @value == nil
     @value
   end
 

data/lib/nydp/symbol_lookup.rb

@@ -4,7 +4,15 @@ module Nydp
   class SymbolLookup
     extend Helper
 
+    def self.skip_empty bindings
+      while Nydp::NIL.isnt?(bindings) && bindings.car.empty?
+        bindings = bindings.cdr
+      end
+      bindings
+    end
+
     def self.build name, bindings
+      bindings = skip_empty bindings
       depth = 0
       while Nydp::NIL.isnt? bindings
         here = bindings.car
@@ -13,7 +21,7 @@ module Nydp
           return ContextSymbol.build(depth, name, binding_index)
         else
           depth += 1
-          bindings = bindings.cdr
+          bindings = skip_empty bindings.cdr
         end
       end
       name

data/lib/nydp/truth.rb

@@ -18,7 +18,7 @@ module Nydp
     def cdr         ; self          ; end
     def size        ; 0             ; end
     def is?   other ; other.class == self.class ; end
-    def isnt? other ; !is?(other)   ; end
+    def isnt? other ; other.class != self.class ; 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.2.3"
+  VERSION = "0.2.5"
 end

data/lib/nydp/vm.rb

@@ -1,7 +1,7 @@
 module Nydp
   class VM
     include Helper
-    attr_accessor :instructions, :args, :contexts, :current_context, :locals, :unhandled_error, :ns
+    attr_accessor :instructions, :args, :contexts, :current_context, :locals, :unhandled_error, :last_error, :ns
 
     module Finally     ; end
     module HandleError ; end
@@ -30,7 +30,7 @@ module Nydp
             instructions.push thisi.cdr
           end
           thisi.car.execute(self)
-        rescue Exception => e
+        rescue StandardError => e
           handle_error e
         end
       end

data/nydp.gemspec

@@ -20,6 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency 'rspec', '~> 2.9'
+  spec.add_development_dependency 'rspec', '~> 3.1'
   spec.add_development_dependency 'rspec_numbering_formatter'
 end

data/spec/error_spec.rb

@@ -6,14 +6,24 @@ describe Nydp::VM do
 
   def run txt
     Nydp.setup ns
-    Nydp::ExplodeRunner.new(vm, ns, Nydp::StringReader.new(txt)).run
+    Nydp::Runner.new(vm, ns, Nydp::StringReader.new(txt)).run
   end
 
   describe "unhandled_error" do
     it "raises a helpful error" do
-      proc = Proc.new { run "dflkjdgjeirgjeoi" }
-      msg  = "failed to eval dflkjdgjeirgjeoi\nerror was   unbound symbol: dflkjdgjeirgjeoi"
-      expect(proc).to raise_error RuntimeError, msg
+      error = nil
+      begin
+        run "dflkjdgjeirgjeoi"
+      rescue StandardError => e
+        error = e
+      end
+
+      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.message).to eq "unbound symbol: dflkjdgjeirgjeoi"
+
       expect(vm.unhandled_error).to eq nil
     end
 

data/spec/hash_non_hash_behaviour_spec.rb

@@ -44,6 +44,10 @@ describe Nydp::Hash do
   describe "unfriendly non-hash" do
     let(:ahash) { Nydp::StringAtom.new "this here ain't no hash, hombre" }
 
+    def cleanup_err_msg txt
+      txt.gsub(/at \/.*:in `builtin_invoke'/, '<error info>')
+    end
+
     describe "hash set" do
       it "does nothing, returns its value" do
         k    = Nydp::Symbol.mk "keysym", ns
@@ -52,15 +56,17 @@ describe Nydp::Hash do
 
         begin
           Nydp::Builtin::HashSet.instance.invoke vm, args
-        rescue Exception => e
+        rescue StandardError => e
           error = e
         end
 
-        expect(error.message.gsub(/at \/.*:in `builtin_invoke'/, '<error info>')).to eq "Called builtin/hash-set
-with args (\"this here ain't no hash, hombre\" keysym \"foobar\")
-raised
-  hash-set: Not a hash: Nydp::StringAtom
-<error info>"
+        expect(cleanup_err_msg error.message).to eq "Called builtin/hash-set
+with args
+  \"this here ain't no hash, hombre\"
+  keysym
+  \"foobar\""
+
+        expect(cleanup_err_msg error.cause.message).to eq "hash-set: Not a hash: Nydp::StringAtom"
       end
     end
 
@@ -71,15 +77,16 @@ raised
 
         begin
           Nydp::Builtin::HashGet.instance.invoke vm, pair_list(args)
-        rescue Exception => e
+        rescue StandardError => e
           error = e
         end
 
-        expect(error.message.gsub(/at \/.*:in `ruby_call'/, '<error info>')).to eq "Called builtin/hash-get
-with args (\"this here ain't no hash, hombre\" keysym)
-raised
-  hash-get: Not a hash: Nydp::StringAtom
-<error info>"
+        expect(cleanup_err_msg error.message).to eq "Called builtin/hash-get
+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"
       end
     end
   end

data/spec/hash_spec.rb

@@ -2,19 +2,6 @@ require "spec_helper"
 
 describe Nydp::Hash do
 
-  class TestThing
-    attr_accessor :a, :b, :c
-    def initialize a, b, c
-      @a, @b, @c = a, b, c
-    end
-
-    def inspect
-      "(TestThing #{a.inspect} #{b.inspect})"
-    end
-
-    def _nydp_safe_methods ; %i{ a b } ; end
-  end
-
   let(:vm) { Nydp::VM.new(ns) }
 
   describe "#to_ruby" do

data/spec/pair_spec.rb

@@ -21,6 +21,14 @@ describe Nydp::Pair do
       expect(Nydp::Pair.new(NIL, NIL)).to eq Nydp::Pair.new(NIL, NIL)
     end
 
+    it "there is no empty list, only NIL" do
+      expect(Nydp::Pair.from_list([])).to eq Nydp::NIL
+    end
+
+    it "is false for (nil) == nil" do
+      expect(Nydp::Pair.from_list([Nydp::NIL]) == Nydp::NIL).to eq false
+    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)
@@ -77,10 +85,16 @@ describe Nydp::Pair do
     expect(p.cdr).to eq Nydp::NIL
   end
 
-  it "should convert to a ruby list" do
-    pair = pair_list [:a, :b, :c, :d]
+  it "#to_ruby converts self and each element to ruby equivalent" do
+    pair = pair_list [a, b, pair_list([a, b]), c, d]
     ruby = pair.to_ruby
-    expect(ruby).to eq [:a, :b, :c, :d]
+    expect(ruby).to eq [:a, :b, [:a, :b], :c, :d]
+  end
+
+  it "#to_a converts to a ruby Array without converting elements" do
+    pair = pair_list [a, b, pair_list([a, b]), c, d]
+    ruby = pair.to_a
+    expect(ruby).to eq [a, b, pair_list([a, b]), c, d]
   end
 
   it "should have size zero when empty" do

data/spec/spec_helper.rb

@@ -21,10 +21,22 @@ module SpecHelper
 end
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
   config.order = 'random'
   config.include Nydp::Helper
   config.include SpecHelper
 end
+
+class TestThing
+  attr_accessor :a, :b, :c
+  def initialize a, b, c
+    @a, @b, @c = a, b, c
+  end
+
+  def inspect
+    "(TestThing #{a.inspect} #{b.inspect})"
+  end
+
+  def _nydp_safe_methods ; %i{ a b } ; end
+end

data/spec/symbol_spec.rb

@@ -17,7 +17,7 @@ describe Nydp::Symbol do
 
   it "should create a new symbol" do
     sym = Nydp::Symbol.mk :foo, ns
-    expect(sym.name.should).to eq :foo
+    expect(sym.name).to eq :foo
   end
 
   it "should not create a new symbol when the symbol already exists" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-28 00:00:00.000000000 Z
+date: 2017-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.9'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.9'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rspec_numbering_formatter
   requirement: !ruby/object:Gem::Requirement
@@ -106,6 +106,8 @@ files:
 - lib/lisp/core-100-utils.nydp
 - lib/lisp/tests/accum-examples.nydp
 - lib/lisp/tests/add-hook-examples.nydp
+- lib/lisp/tests/all-examples.nydp
+- lib/lisp/tests/any-examples.nydp
 - lib/lisp/tests/auto-hash-examples.nydp
 - lib/lisp/tests/best-examples.nydp
 - lib/lisp/tests/boot-tests.nydp
@@ -133,8 +135,11 @@ files:
 - lib/lisp/tests/invocation-tests.nydp
 - lib/lisp/tests/isa-examples.nydp
 - lib/lisp/tests/len-examples.nydp
+- lib/lisp/tests/list-gsub-examples.nydp
+- lib/lisp/tests/list-match-examples.nydp
 - lib/lisp/tests/list-tests.nydp
 - lib/lisp/tests/mapsum-examples.nydp
+- lib/lisp/tests/none-examples.nydp
 - lib/lisp/tests/orequal-examples.nydp
 - lib/lisp/tests/parser-tests.nydp
 - lib/lisp/tests/plus-plus-examples.nydp