nydp 0.5.1 → 0.6.0

data/spec/symbol_spec.rb

@@ -1,108 +1,83 @@
 require 'spec_helper'
 
 describe Nydp::Symbol do
-  let(:bar) { Nydp::Symbol.mk :BAR, ns }
-  let(:foo) { Nydp::Symbol.mk :FOO, ns }
-  let(:vm)  { Nydp::VM.new(ns)         }
+  let(:bar) { :BAR }
+  let(:foo) { :FOO }
 
   describe "#inspect" do
     it "wraps itself in pipe chars if empty" do
-      sym = Nydp::Symbol.mk "", ns
-      expect(sym.inspect).to eq "||"
+      sym = :""
+      expect(sym._nydp_inspect).to eq "||"
     end
     it "wraps itself in pipe chars if nil" do
-      sym = Nydp::Symbol.mk nil, ns
-      expect(sym.inspect).to eq "||"
+      sym = nil.to_s.to_sym
+      expect(sym._nydp_inspect).to eq "||"
     end
     it "wraps itself in pipe chars if it has spaces" do
-      sym = Nydp::Symbol.mk "hello world", ns
-      expect(sym.inspect).to eq "|hello world|"
+      sym = :"hello world"
+      expect(sym._nydp_inspect).to eq "|hello world|"
     end
     it "wraps itself in pipe chars if it has pipe chars" do
-      sym = Nydp::Symbol.mk "hello|world", ns
-      expect(sym.inspect).to eq '|hello\|world|'
+      sym = :"hello|world"
+      expect(sym._nydp_inspect).to eq '|hello\|world|'
     end
     it "wraps itself in pipe chars if it contains quote chars" do
-      sym = Nydp::Symbol.mk "hello 'world'", ns
-      expect(sym.inspect).to eq "|hello 'world'|"
+      sym = :"hello 'world'"
+      expect(sym._nydp_inspect).to eq "|hello 'world'|"
     end
     it "wraps itself in pipe chars if it contains doublequote chars" do
-      sym = Nydp::Symbol.mk 'hello "world"', ns
-      expect(sym.inspect).to eq '|hello "world"|'
+      sym = :'hello "world"'
+      expect(sym._nydp_inspect).to eq '|hello "world"|'
     end
     it "wraps itself in pipe chars if it has other punctuation" do
-      sym = Nydp::Symbol.mk 'hello,(world)', ns
-      expect(sym.inspect).to eq '|hello,(world)|'
+      sym = :'hello,(world)'
+      expect(sym._nydp_inspect).to eq '|hello,(world)|'
     end
   end
 
-  it "returns a ruby symbol in #to_ruby" do
-    sym = Nydp::Symbol.mk :foo, ns
-    expect(sym.to_ruby).to eq :foo
-  end
-
-  it "should not recognise an unknown symbol" do
-    sym = Nydp::Symbol.find :foo, ns
-    expect(sym).to eq nil
-  end
-
-  it "should create a new symbol" do
-    sym = Nydp::Symbol.mk :foo, ns
-    expect(sym.name).to eq :foo
-  end
-
-  it "should not create a new symbol when the symbol already exists" do
-    sym1 = Nydp::Symbol.mk :baz, ns
-    sym2 = Nydp::Symbol.mk :baz, ns
-
-    expect(sym1).to eq sym2
-    expect(sym1).to equal sym2
-  end
-
   it "should consider symbols == when they share the same name" do
     ns1 = { }
     ns2 = { }
 
-    sym1 = Nydp::Symbol.mk :baz, ns1
-    sym2 = Nydp::Symbol.mk :baz, ns2
+    sym1 = :baz
+    sym2 = :baz
 
     expect(sym1.hash).to eq sym2.hash
 
     expect(sym1 ==     sym2).to eq true
     expect(sym1.eql?   sym2).to eq true
-    expect(sym1.equal? sym2).to eq false
+    expect(sym1.equal? sym2).to eq true
   end
 
   it "works with builtin greater-than when true" do
     f = Nydp::Builtin::GreaterThan.instance
 
-    f.invoke vm, pair_list([foo, bar])
+    a = f.call foo, bar
 
-    expect(vm.args.pop).to eq bar
+    expect(a).to eq bar
   end
 
   it "works with builtin greater-than when false" do
     f = Nydp::Builtin::GreaterThan.instance
 
-    f.invoke vm, pair_list([bar, foo])
+    a = f.call bar, foo
 
-    expect(vm.args.pop).to eq Nydp::NIL
+    expect(a).to eq Nydp::NIL
   end
 
   it "works with builtin less-than when true" do
     f = Nydp::Builtin::LessThan.instance
 
-    f.invoke vm, pair_list([bar, foo])
+    a = f.call bar, foo
 
-    expect(vm.args.pop).to eq foo
+    expect(a).to eq foo
   end
 
   it "works with builtin less-than when false" do
     f = Nydp::Builtin::LessThan.instance
 
-    f.invoke vm, pair_list([foo, bar])
+    a = f.call foo, bar
 
-    expect(vm.args.pop).to eq Nydp::NIL
+    expect(a).to eq Nydp::NIL
   end
-
 end

data/spec/thread_local_spec.rb

@@ -1,21 +1,36 @@
 require 'spec_helper'
 
 describe Nydp do
-  def run vm, txt
-    Nydp::Runner.new(vm, ns, Nydp::StringReader.new(txt)).run
+  def run txt
+    Nydp::Runner.new(ns, Nydp::StringReader.new("test", txt)).run
   end
 
   it "should isolate threadlocal values" do
+
+    # note : this test is mostly on principle, it can't guarantee
+    # correctness insofar as it doesn't guarantee that the threads
+    # run in a way such that they would interfere with each other
+    # if thread_locals were not used...
+
     Nydp.setup ns
 
-    vm0 = Nydp::VM.new ns
-    vm1 = Nydp::VM.new ns
 
-    run vm0, "(hash-set (thread-locals) 'testing (+ 1 2 3))"
-    run vm1, "(hash-set (thread-locals) 'testing (+ 6 7 8))"
+    t0 = Thread.new {
+      run "(hash-set (thread-locals) 'testing (+ 1 2 3))"
+      sleep 0.1
+      run "(hash-get (thread-locals) 'testing)"
+    }
+
+    t1 = Thread.new {
+      run "(hash-set (thread-locals) 'testing (+ 6 7 8))"
+      run "(hash-get (thread-locals) 'testing)"
+    }
+
+    t0.join
+    t1.join
 
-    val0 = run vm0, "(hash-get (thread-locals) 'testing)"
-    val1 = run vm1, "(hash-get (thread-locals) 'testing)"
+    val0 = t0.value
+    val1 = t1.value
 
     expect(val0).to eq 6
     expect(val1).to eq 21

data/spec/time_spec.rb

@@ -2,8 +2,6 @@ require 'spec_helper'
 
 describe Nydp::Date do
 
-  let(:ns)    { { }                          }
-  let(:vm)    { Nydp::VM.new(ns)             }
   let(:timef) { Nydp::Builtin::Time.instance }
 
   it "r2n does not convert ruby Time" do
@@ -15,16 +13,14 @@ describe Nydp::Date do
   end
 
   it "creates a new Time instance" do
-    timef.invoke vm, Nydp::Pair.from_list([2015, 11, 18, 18, 30, 17])
-    nd = vm.args.pop
+    nd = timef.call 2015, 11, 18, 18, 30, 17
     expect(nd).to be_a Time
     expect(nd).to eq Time.new(2015, 11, 18, 18, 30, 17)
   end
 
   it "creates a new Time instance for #now" do
     t0 = Time.now
-    timef.invoke_1 vm
-    nd = vm.args.pop
+    nd = timef.call
     t1 = Time.now
     expect(nd).to be_a Time
     expect(nd).to be_between(t0, t1)
@@ -32,16 +28,14 @@ describe Nydp::Date do
 
   it "creates a new Time instance for #now plus offset" do
     t0 = Time.now
-    timef.invoke_2 vm, 3.14
-    nd = vm.args.pop
+    nd = timef.call 3.14
     t1 = Time.now
     expect(nd).to be_a Time
     expect(nd).to be_between((t0 + 3.14), (t1 + 3.14))
   end
 
   it "creates a new Time instance for a given Date" do
-    timef.invoke_2 vm, Nydp::Date.new(Date.parse "2006-06-21")
-    nd = vm.args.pop
+    nd = timef.call Date.parse "2006-06-21"
     expect(nd).to be_a Time
     expect(nd).to eq Time.new(2006, 6, 21)
   end

data/spec/tokeniser_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe "tokenising" do
   it "should return another stream of tokens" do
     tt = []
-      reader = Nydp::StringReader.new "(a b c 1 2 3)"
+      reader = Nydp::StringReader.new "test", "(a b c 1 2 3)"
       t = Nydp::Tokeniser.new reader
       tt = []
       tok = t.next_token
@@ -22,7 +22,7 @@ describe "tokenising" do
   end
 
   it "should return a stream of tokens, including whitespace before right-paren" do
-    reader = Nydp::StringReader.new "foo )"
+    reader = Nydp::StringReader.new "test", "foo )"
     t = Nydp::Tokeniser.new reader
     tt = []
     tok = t.next_token
@@ -35,33 +35,33 @@ describe "tokenising" do
   end
 
   it "returns nothing at all" do
-    s = Nydp::StringReader.new ""
+    s = Nydp::StringReader.new "test", ""
     tkz = Nydp::Tokeniser.new s
     expect(tkz.next_token).to be_nil
   end
 
   it "returns a whitespace token" do
-    s = Nydp::StringReader.new "  "
+    s = Nydp::StringReader.new "test", "  "
     tkz = Nydp::Tokeniser.new s
     expect(tkz.next_token).to be_nil
   end
 
   it "returns a symbol token" do
-    s = Nydp::StringReader.new "hello"
+    s = Nydp::StringReader.new "test", "hello"
     tkz = Nydp::Tokeniser.new s
     expect(tkz.next_token).to eq [:symbol, "hello"]
     expect(tkz.next_token).to be_nil
   end
 
   it "returns symbol then whitespace" do
-    s = Nydp::StringReader.new "hello  "
+    s = Nydp::StringReader.new "test", "hello  "
     tkz = Nydp::Tokeniser.new s
     expect(tkz.next_token).to eq [:symbol, "hello"]
     expect(tkz.next_token).to be_nil
   end
 
   it "returns whitespace symbol whitespace symbol whitespace" do
-    s = Nydp::StringReader.new " hello world "
+    s = Nydp::StringReader.new "test", " hello world "
     tkz = Nydp::Tokeniser.new s
     expect(tkz.next_token).to eq [:symbol, "hello"]
     expect(tkz.next_token).to eq [:symbol, "world"]
@@ -69,7 +69,7 @@ describe "tokenising" do
   end
 
   it "returns whitespace left_paren symbol whitespace symbol right_paren whitespace" do
-    s = Nydp::StringReader.new " (hello world) "
+    s = Nydp::StringReader.new "test", " (hello world) "
     tkz = Nydp::Tokeniser.new s
     expect(tkz.next_token).to eq [:left_paren, ""]
     expect(tkz.next_token).to eq [:symbol, "hello"]
@@ -79,7 +79,7 @@ describe "tokenising" do
   end
 
   it "returns whitespace left_paren with prefix symbol whitespace symbol right_paren whitespace" do
-    s = Nydp::StringReader.new " %w(hello world) "
+    s = Nydp::StringReader.new "test", " %w(hello world) "
     tkz = Nydp::Tokeniser.new s
     expect(tkz.next_token).to eq [:left_paren, "%w"]
     expect(tkz.next_token).to eq [:symbol, "hello"]
@@ -89,7 +89,7 @@ describe "tokenising" do
   end
 
   it "returns a comment" do
-    s = Nydp::StringReader.new "hello
+    s = Nydp::StringReader.new "test", "hello
 ; observe!
 world"
     tkz = Nydp::Tokeniser.new s

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-02 00:00:00.000000000 Z
+date: 2024-04-11 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12'
+        version: '13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12'
+        version: '13'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -82,6 +96,7 @@ files:
 - lib/lisp/core-120-settings.nydp
 - lib/lisp/core-130-validations.nydp
 - lib/lisp/core-900-benchmarking.nydp
+- lib/lisp/tests/000-empty-args-examples.nydp
 - lib/lisp/tests/accum-examples.nydp
 - lib/lisp/tests/add-hook-examples.nydp
 - lib/lisp/tests/aif-examples.nydp
@@ -147,6 +162,7 @@ files:
 - lib/lisp/tests/relative-months-examples.nydp
 - lib/lisp/tests/returning-examples.nydp
 - lib/lisp/tests/rfnwith-tests.nydp
+- lib/lisp/tests/rotate-2d-array-examples.nydp
 - lib/lisp/tests/seqf-examples.nydp
 - lib/lisp/tests/set-difference-examples.nydp
 - lib/lisp/tests/set-intersection-examples.nydp
@@ -181,12 +197,12 @@ files:
 - lib/nydp/builtin/inspect.rb
 - lib/nydp/builtin/is_equal.rb
 - lib/nydp/builtin/less_than.rb
+- lib/nydp/builtin/log.rb
 - lib/nydp/builtin/math_ceiling.rb
 - lib/nydp/builtin/math_floor.rb
 - lib/nydp/builtin/math_power.rb
 - lib/nydp/builtin/math_round.rb
 - lib/nydp/builtin/minus.rb
-- lib/nydp/builtin/modulo.rb
 - lib/nydp/builtin/parse.rb
 - lib/nydp/builtin/parse_in_string.rb
 - lib/nydp/builtin/plus.rb
@@ -195,16 +211,13 @@ files:
 - lib/nydp/builtin/quit.rb
 - lib/nydp/builtin/rand.rb
 - lib/nydp/builtin/random_string.rb
-- lib/nydp/builtin/regexp.rb
+- lib/nydp/builtin/rng.rb
 - lib/nydp/builtin/ruby_wrap.rb
 - lib/nydp/builtin/script_run.rb
 - lib/nydp/builtin/set_intersection.rb
 - lib/nydp/builtin/set_union.rb
 - lib/nydp/builtin/sort.rb
-- lib/nydp/builtin/sqrt.rb
 - lib/nydp/builtin/string_match.rb
-- lib/nydp/builtin/string_pad_left.rb
-- lib/nydp/builtin/string_pad_right.rb
 - lib/nydp/builtin/string_replace.rb
 - lib/nydp/builtin/string_split.rb
 - lib/nydp/builtin/sym.rb
@@ -224,13 +237,13 @@ files:
 - lib/nydp/date.rb
 - lib/nydp/error.rb
 - lib/nydp/function_invocation.rb
-- lib/nydp/hash.rb
 - lib/nydp/helper.rb
-- lib/nydp/image_store.rb
 - lib/nydp/interpreted_function.rb
 - lib/nydp/lexical_context.rb
 - lib/nydp/lexical_context_builder.rb
 - lib/nydp/literal.rb
+- lib/nydp/loop.rb
+- lib/nydp/namespace.rb
 - lib/nydp/pair.rb
 - lib/nydp/parser.rb
 - lib/nydp/plugin.rb
@@ -243,7 +256,6 @@ files:
 - lib/nydp/tokeniser.rb
 - lib/nydp/truth.rb
 - lib/nydp/version.rb
-- lib/nydp/vm.rb
 - lib/tasks/tests.rake
 - nydp.gemspec
 - spec/date_spec.rb
@@ -283,7 +295,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: A civilised yet somewhat dangerous kind of Lisp for a new generation

data/lib/nydp/builtin/modulo.rb

@@ -1,11 +0,0 @@
-class Nydp::Builtin::Modulo
-  include Nydp::Builtin::Base, Singleton
-
-  def invoke_3 vm, a0, a1     ; vm.push_arg(a0 % a1)      ; end
-
-  def builtin_invoke vm, args
-    invoke_3 vm, args.car, args.cdr.car
-  end
-
-  def name ; "mod" ; end
-end

data/lib/nydp/builtin/regexp.rb

@@ -1,7 +0,0 @@
-class Nydp::Builtin::Regexp
-  include Nydp::Builtin::Base, Singleton
-
-  def builtin_invoke vm, args
-    vm.push_arg Regexp.compile(args.car.to_s)
-  end
-end

data/lib/nydp/builtin/sqrt.rb

@@ -1,7 +0,0 @@
-class Nydp::Builtin::Sqrt
-  include Nydp::Builtin::Base, Singleton
-
-  def builtin_invoke vm, args
-    vm.push_arg Math.sqrt args.car
-  end
-end

data/lib/nydp/builtin/string_pad_left.rb

@@ -1,7 +0,0 @@
-class Nydp::Builtin::StringPadLeft
-  include Nydp::Builtin::Base, Singleton
-
-  def builtin_invoke_4 vm, str, len, padding
-    vm.push_arg str.to_s.rjust(len, padding.to_s)
-  end
-end

data/lib/nydp/builtin/string_pad_right.rb

@@ -1,7 +0,0 @@
-class Nydp::Builtin::StringPadRight
-  include Nydp::Builtin::Base, Singleton
-
-  def builtin_invoke_4 vm, str, len, padding
-    vm.push_arg str.to_s.ljust(len, padding.to_s)
-  end
-end

data/lib/nydp/hash.rb

@@ -1,9 +0,0 @@
-class Nydp::Hash < ::Hash
-  include Nydp::Helper
-
-  def nydp_type      ; :hash                                             ; end
-  def to_ruby        ; each_with_object({}) {|(k,v),h| h[n2r k] = n2r v} ; end
-  def _nydp_get a    ; self[a]                                           ; end
-  def _nydp_set a, v ; self[a] = v                                       ; end
-  def _nydp_keys     ; keys                                              ; end
-end

data/lib/nydp/image_store.rb

@@ -1,21 +0,0 @@
-require 'digest'
-
-module Nydp
-  class ImageStore
-    attr_accessor :store
-
-    def initialize store=nil
-      @store = store
-      FileUtils.mkdir_p(store, mode: 0775) if store
-    end
-
-    def digest          ; Digest::MD5.hexdigest(Nydp.all_files.map { |f| File.read f }.join) ; end
-    def file_name    id ; File.join @store, "#{id}.nydp_image"                               ; end
-    def load?     fname ; File.binread(fname) if File.exists?(fname)                         ; end
-    def load         id ; load?(file_name id) if @store                                      ; end
-    def store id, image ; File.open(file_name(id), "wb") { |f| f.write(image) } if @store    ; end
-    def generate     id ; Marshal.dump(::Nydp.build_nydp).tap { |im| store id, im }          ; end
-    def resurrect    id ; load(id) || generate(id)                                           ; end
-    def get             ; Marshal.load(@image ||= resurrect(digest))                         ; end
-  end
-end

data/lib/nydp/vm.rb

@@ -1,129 +0,0 @@
-module Nydp
-  class VM
-    NIL = Nydp::NIL
-    include Helper
-    attr_accessor :instructions, :args, :contexts, :current_context, :locals, :unhandled_error, :last_error, :ns, :thisi
-
-    module Finally     ; end
-    module HandleError ; end
-
-    def initialize ns
-      @instructions = []
-      @args         = []
-      @contexts     = []
-      @locals       = Nydp::Hash.new
-      @ns           = 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_with_expr expr
-      @current_instructions = expr
-      thread
-    end
-
-    def thread
-      while @current_instructions
-        begin
-          if NIL == @current_instructions
-            @current_instructions = @instructions.pop
-            @current_context      = @contexts.pop
-          else
-            now = @current_instructions.car
-            @current_instructions = @current_instructions.cdr
-            now.execute(self)
-          end
-
-        rescue StandardError => e
-          handle_error e
-        end
-      end
-
-      if @unhandled_error
-        e = @unhandled_error
-        @unhandled_error = nil
-        raise e
-      end
-
-      args.pop
-    end
-
-    def handle_error ex
-      @unhandled_error = ex
-
-      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
-        end
-
-        @instructions.pop
-        @contexts.pop
-      end
-
-      while protecti.length > 0
-        push_instructions protecti.pop, protectc.pop
-      end
-    end
-
-    def push_arg a   ; args.push a                                               ; end
-    def args!        ; args.empty? ? (raise "illegal operation: no args") : args ; end
-    def peek_arg     ; args!.last                                                ; end
-
-    def pop_args count, tail=Nydp::NIL
-      case count
-      when 0
-        tail
-      else
-        pop_args(count - 1, cons(args.pop, tail))
-      end
-    end
-
-    def vm_info
-      msg = ""
-      msg << "\n"
-      msg << "\ninstruction stack"
-      msg << "\n================="
-      instructions.each_with_index do |ii, ix|
-        msg << "\ninstructions##{ix} : #{ii} #{ii.source if ii.respond_to?(:source)}"
-      end
-      msg << "\n"
-      msg << "\n"
-      msg << "\ncontext stack"
-      msg << "\n================="
-      contexts.each_with_index do |ctx, ix|
-        msg << "\ncontext##{ix} :\n#{ctx}"
-      end
-      msg << "\n"
-      msg << "\n"
-      msg << "\nargs stack"
-      msg << "\n================="
-      args.each_with_index do |args, ix|
-        msg << "\args##{ix} :\n#{args}"
-      end
-      msg << "\n"
-      msg << "\n"
-      msg
-    end
-  end
-end