nydp 0.4.1 → 0.4.2

data/lib/nydp/hash.rb

@@ -1,10 +1,9 @@
 class Nydp::Hash < ::Hash
   include Nydp::Helper
 
-  def nydp_type ; :hash   ; end
-  def to_ruby
-    h = Hash.new
-    self.each { |k,v| h[n2r k] = n2r v }
-    h
-  end
+  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/helper.rb

@@ -1,34 +1,18 @@
 module Nydp
-  R2NHELPERS = {
-    ::Symbol   => ->(obj, ns) { Nydp::Symbol.mk(obj, ns)                            },
-    Array      => ->(obj, ns) { Nydp::Pair.from_list obj.map { |o| Nydp.r2n o, ns } },
-    String     => ->(obj, ns) { Nydp::StringAtom.new obj.to_s                       },
-    NilClass   => ->(obj, ns) { Nydp::NIL                                           },
-    FalseClass => ->(obj, ns) { Nydp::NIL                                           },
-    TrueClass  => ->(obj, ns) { Nydp::T                                             },
-    ::Date     => ->(obj, ns) { Nydp::Date.new obj                                  },
-  }
-
-  def self.n2r nydp
-    nydp.respond_to?(:to_ruby) ? nydp.to_ruby : nydp
+  module AutoWrap
+    def _nydp_wrapper ; self ; end
+    def to_ruby       ; self ; end
   end
 
-  def self.r2n ruby_obj, ns
-    return ruby_obj._nydp_wrapper(ns) if ruby_obj.respond_to? :_nydp_wrapper
-
-    rklass = ruby_obj.class
-    R2NHELPERS.each do |hklass, proc|
-      if rklass <= hklass
-        return proc.call ruby_obj, ns
-      end
-    end
-
-    ruby_obj
+  module Converter
+    def n2r         o ; o.respond_to?(:to_ruby) ? o.to_ruby : o ; end
+    def r2n o, ns=nil ; o._nydp_wrapper                         ; end
   end
 
+  extend Converter
+
   module Helper
-    def n2r obj     ; Nydp.n2r obj     ; end
-    def r2n obj, ns ; Nydp.r2n obj, ns ; end
+    include Converter
 
     def sig klass
       case klass

data/lib/nydp/string_atom.rb

@@ -5,28 +5,23 @@ module Nydp
       @string, @token = string, token
     end
 
-    def nydp_type  ; :string        ; end
-    def to_s       ;  string        ; end
-    def to_ruby    ;  string        ; end
-    def to_sym     ;  string.to_sym ; end
-    def eql? other ; self == other  ; end
-    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    ; StringAtom.new(string * other) ; end
-
-    def <=> other
-      self < other ? -1 : (self == other ? 0 : 1)
-    end
+    def nydp_type  ; :string                                     ; end
+    def to_s       ; string                                      ; end
+    def to_ruby    ; string                                      ; end
+    def to_sym     ; string.to_sym                               ; end
+    def to_date    ; ::Date.parse(@string)                       ; end
+    def eql? other ; self == other                               ; end
+    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 ; StringAtom.new(string * other)              ; end
+    def <=>  other ; self < other ? -1 : (self == other ? 0 : 1) ; end
+    def +    other ; StringAtom.new "#{@string}#{other}"         ; end
 
     def == other
       other.is_a?(Nydp::StringAtom) && (other.to_s == self.to_s)
     end
-
-    def + other
-      StringAtom.new "#{@string}#{other}"
-    end
   end
 end

data/lib/nydp/symbol.rb

@@ -1,19 +1,22 @@
 class Nydp::Symbol
   class Unbound < StandardError ; end
-
   EMPTY = :""
   attr_accessor :name
-  attr_reader   :hash
+
+  def self.new name
+    special(name.to_s.to_sym) || super
+  end
 
   def initialize name
     name = name.to_s
     @name = name.to_sym
-    @inspection = "|#{name}|" if untidy(name)
-    @hash       = name.hash
+    @inspection = "|#{name.gsub(/\|/, '\|')}|" if untidy(name)
   end
 
+  def hash ; name.hash ; end # can't cache this, it seems to break when unmarshalling
+
   def untidy str
-    (str == "") || (str == nil) || (str =~ /\s/)
+    (str == "") || (str == nil) || (str =~ /[\s\|,\(\)"]/)
   end
 
   def value context=nil
@@ -21,41 +24,51 @@ class Nydp::Symbol
     @value
   end
 
-  def self.mk name, ns
-    name = name.to_sym
+  def self.special name
     return Nydp::NIL if name == :nil
     return Nydp::T   if name == :t
-    sym = ns[name]
-    unless sym
-      sym = new(name)
-      ns[name] = sym
-    end
-    sym
+    nil
   end
 
+  def self.mk name, ns
+    name = name.to_s.to_sym
+    ns[name] ||= new(name)
+  end
 
   def self.find name, ns ; ns[name.to_sym] ;  end
 
-  def nydp_type  ; :symbol                  ; end
-  def inspect    ; @inspection || name.to_s ; end
-  def to_s       ; name.to_s                ; end
-  def to_sym     ; name                     ; end
-  def to_ruby    ; to_sym                   ; end
-  def eql? other ; self == other            ; end
-  def is? nm     ; self.name == nm.to_sym   ; end
-  def > other    ; self.name > other.name   ; end
-  def < other    ; self.name < other.name   ; end
-  def <=> other  ; self.name <=> other.name ; end
+  def nydp_type           ; :symbol                  ; end
+  def inspect             ; @inspection || name.to_s ; end
+  def to_s                ; name.to_s                ; end
+  def to_sym              ; name                     ; end
+  def to_ruby             ; to_sym                   ; end
+  def is?              nm ; self.name == nm.to_sym   ; end
+  def >             other ; self.name > other.name   ; end
+  def <             other ; self.name < other.name   ; end
+  def <=>           other ; self.name <=> other.name ; end
+  def assign value, _=nil ; @value = value           ; end
+  def execute          vm ; vm.push_arg self.value   ; end
 
   def == other
     other.is_a?(Nydp::Symbol) && (self.name == other.name)
   end
 
-  def execute vm
-    vm.push_arg self.value
+  alias eql? ==
+end
+
+class Nydp::FrozenSymbol < Nydp::Symbol
+  @@frozen = { }
+
+  def self.mk name
+    name = name.to_s.to_sym
+    @@frozen[name] ||= new(name)
+  end
+
+  def value _=nil
+    raise Unbound.new("frozen symbol: #{self.inspect}")
   end
 
-  def assign value, _=nil
-    @value = value
+  def assign v, _=nil
+    raise "can't assign to frozen: #{self.inspect}"
   end
 end

data/lib/nydp/truth.rb

@@ -9,10 +9,12 @@ module Nydp
     def assign  *_ ; self             ; end
     def nydp_type  ; :truth           ; end
     def to_ruby    ; true             ; end
+    def _nydp_get    a ; Nydp::T      ; end
+    def _nydp_set a, v ; Nydp::T      ; end
   end
 
   class Nil
-    include Singleton
+    include Singleton, Enumerable
     def init_with * ; Nydp::NIL     ; end
     def car         ; self          ; end
     def cdr         ; self          ; end
@@ -26,7 +28,12 @@ module Nydp
     def inspect     ; "nil"         ; end
     def nydp_type   ; :nil          ; end
     def to_ruby     ; nil           ; end
-    def execute vm  ; vm.push_arg self ; end
+    def execute     vm ; vm.push_arg self ; end
+    def _nydp_get    a ; Nydp::NIL        ; end
+    def _nydp_set a, v ; Nydp::NIL        ; end
+    def each           ;                  ; end # nil behaves like an empty list
+    def &        other ; self             ; end
+    def |        other ; other            ; end
   end
 
   NIL = Nil.instance

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

data/lib/nydp/vm.rb

@@ -15,8 +15,6 @@ module Nydp
       @ns           = ns
     end
 
-    def r2n              obj ; super obj, @ns              ; end
-
     def push_instructions ii, ctx
       if @current_instructions && NIL != @current_instructions
         @instructions.push @current_instructions

data/spec/date_spec.rb

@@ -7,7 +7,7 @@ describe Nydp::Date do
 
   it "converts ruby Date to Nydp::Date" do
     rd = Date.parse "2015-06-08"
-    nd = Nydp.r2n rd, ns
+    nd = Nydp.r2n rd
 
     expect(nd).        to be_a Nydp::Date
     expect(nd.to_s).   to eq "2015-06-08"
@@ -33,16 +33,16 @@ describe Nydp::Date do
 
   it "returns date components" do
     rd = Date.parse "2015-06-08"
-    nd = Nydp.r2n rd, ns
+    nd = Nydp.r2n rd
 
-    expect(nd[:year]). to eq 2015
-    expect(nd[:month]).to eq 6
-    expect(nd[:day]).  to eq 8
+    expect(nd._nydp_get(:year) ).to eq 2015
+    expect(nd._nydp_get(:month)).to eq 6
+    expect(nd._nydp_get(:day)  ).to eq 8
   end
 
   describe "date maths" do
-    let(:d0) { Nydp.r2n Date.today, ns       }
-    let(:d1) { Nydp.r2n (Date.today + 6), ns }
+    let(:d0) { Nydp.r2n Date.today       }
+    let(:d1) { Nydp.r2n (Date.today + 6) }
 
     it "works with builtin minus" do
       minus = Nydp::Builtin::Minus.instance
@@ -120,31 +120,31 @@ describe Nydp::Date do
 
   it "returns relative dates by year" do
     rd = Date.parse "2015-06-08"
-    nd = Nydp.r2n rd, ns
+    nd = Nydp.r2n rd
 
-    expect(nd[:"last-year"].to_s).          to eq "2014-06-08"
-    expect(nd[:"next-year"].to_s).          to eq "2016-06-08"
-    expect(nd[:"beginning-of-year"].to_s).  to eq "2015-01-01"
-    expect(nd[:"end-of-year"].to_s).        to eq "2015-12-31"
+    expect(nd._nydp_get(:"last-year").to_s).          to eq "2014-06-08"
+    expect(nd._nydp_get(:"next-year").to_s).          to eq "2016-06-08"
+    expect(nd._nydp_get(:"beginning-of-year").to_s).  to eq "2015-01-01"
+    expect(nd._nydp_get(:"end-of-year").to_s).        to eq "2015-12-31"
   end
 
   it "returns relative dates by month" do
     rd = Date.parse "2015-06-08"
-    nd = Nydp.r2n rd, ns
+    nd = Nydp.r2n rd
 
-    expect(nd[:"last-month"].to_s).          to eq "2015-05-08"
-    expect(nd[:"next-month"].to_s).          to eq "2015-07-08"
-    expect(nd[:"beginning-of-month"].to_s).  to eq "2015-06-01"
-    expect(nd[:"end-of-month"].to_s).        to eq "2015-06-30"
+    expect(nd._nydp_get(:"last-month").to_s).          to eq "2015-05-08"
+    expect(nd._nydp_get(:"next-month").to_s).          to eq "2015-07-08"
+    expect(nd._nydp_get(:"beginning-of-month").to_s).  to eq "2015-06-01"
+    expect(nd._nydp_get(:"end-of-month").to_s).        to eq "2015-06-30"
   end
 
   it "returns relative dates by week" do
     rd = Date.parse "2015-03-12"
-    nd = Nydp.r2n rd, ns
+    nd = Nydp.r2n rd
 
-    expect(nd[:"last-week"].to_s).          to eq "2015-03-05"
-    expect(nd[:"next-week"].to_s).          to eq "2015-03-19"
-    expect(nd[:"beginning-of-week"].to_s).  to eq "2015-03-09"
-    expect(nd[:"end-of-week"].to_s).        to eq "2015-03-15"
+    expect(nd._nydp_get(:"last-week").to_s).          to eq "2015-03-05"
+    expect(nd._nydp_get(:"next-week").to_s).          to eq "2015-03-19"
+    expect(nd._nydp_get(:"beginning-of-week").to_s).  to eq "2015-03-09"
+    expect(nd._nydp_get(:"end-of-week").to_s).        to eq "2015-03-15"
   end
 end

data/spec/hash_non_hash_behaviour_spec.rb

@@ -66,7 +66,7 @@ with args
   keysym
   \"foobar\""
 
-        expect(cleanup_err_msg error.cause.message).to eq "hash-set: Not a hash: Nydp::StringAtom"
+        expect(cleanup_err_msg error.cause.message).to eq "_nydp_get : not settable: keysym on Nydp::StringAtom"
       end
     end
 
@@ -86,7 +86,7 @@ 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"
+        expect(cleanup_err_msg error.cause.message).to eq "_nydp_get : not gettable: keysym on Nydp::StringAtom"
       end
     end
   end

data/spec/spec_helper.rb

@@ -37,5 +37,8 @@ class TestThing
     "(TestThing #{a.inspect} #{b.inspect})"
   end
 
-  def _nydp_safe_methods ; %i{ a b } ; end
+  def _nydp_get name
+    name = name.to_s.to_sym
+    send(name) if name == :a || name == :b
+  end
 end

data/spec/symbol_spec.rb

@@ -5,6 +5,37 @@ describe Nydp::Symbol do
   let(:foo) { Nydp::Symbol.mk :FOO, ns }
   let(:vm)  { Nydp::VM.new(ns)         }
 
+  describe "#inspect" do
+    it "wraps itself in pipe chars if empty" do
+      sym = Nydp::Symbol.mk "", ns
+      expect(sym.inspect).to eq "||"
+    end
+    it "wraps itself in pipe chars if nil" do
+      sym = Nydp::Symbol.mk nil, ns
+      expect(sym.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|"
+    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|'
+    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'|"
+    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"|'
+    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)|'
+    end
+  end
+
   it "returns a ruby symbol in #to_ruby" do
     sym = Nydp::Symbol.mk :foo, ns
     expect(sym.to_ruby).to eq :foo

data/spec/time_spec.rb

@@ -8,7 +8,7 @@ describe Nydp::Date do
 
   it "r2n does not convert ruby Time" do
     rd = Time.now
-    nd = Nydp.r2n rd, ns
+    nd = Nydp.r2n rd
 
     expect(nd).to be_a Time
     expect(nd).to eq rd

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-14 00:00:00.000000000 Z
+date: 2018-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -101,11 +101,13 @@ files:
 - lib/lisp/core-043-list-utils.nydp
 - lib/lisp/core-045-dox-utils.nydp
 - lib/lisp/core-050-test-runner.nydp
-- lib/lisp/core-060-benchmarking.nydp
 - lib/lisp/core-070-prefix-list.nydp
 - lib/lisp/core-080-pretty-print.nydp
 - lib/lisp/core-090-hook.nydp
 - lib/lisp/core-100-utils.nydp
+- lib/lisp/core-110-hash-utils.nydp
+- lib/lisp/core-120-settings.nydp
+- lib/lisp/core-900-benchmarking.nydp
 - lib/lisp/tests/accum-examples.nydp
 - lib/lisp/tests/add-hook-examples.nydp
 - lib/lisp/tests/aif-examples.nydp
@@ -117,6 +119,7 @@ files:
 - lib/lisp/tests/boot-tests.nydp
 - lib/lisp/tests/builtin-tests.nydp
 - lib/lisp/tests/car-examples.nydp
+- lib/lisp/tests/cdr-set-examples.nydp
 - lib/lisp/tests/collect-tests.nydp
 - lib/lisp/tests/cons-examples.nydp
 - lib/lisp/tests/curry-tests.nydp
@@ -165,6 +168,7 @@ files:
 - lib/lisp/tests/seqf-examples.nydp
 - lib/lisp/tests/set-intersection-examples.nydp
 - lib/lisp/tests/set-union-examples.nydp
+- lib/lisp/tests/settings-examples.nydp
 - lib/lisp/tests/sort-examples.nydp
 - lib/lisp/tests/string-tests.nydp
 - lib/lisp/tests/syntax-tests.nydp
@@ -172,6 +176,7 @@ files:
 - lib/lisp/tests/tuples-examples.nydp
 - lib/lisp/tests/type-of-examples.nydp
 - lib/lisp/tests/unparse-tests.nydp
+- lib/lisp/tests/zap-examples.nydp
 - lib/lisp/tests/zip-examples.nydp
 - lib/nydp.rb
 - lib/nydp/assignment.rb
@@ -227,6 +232,7 @@ files:
 - lib/nydp/cond.rb
 - lib/nydp/context_symbol.rb
 - lib/nydp/core.rb
+- lib/nydp/core_ext.rb
 - lib/nydp/date.rb
 - lib/nydp/error.rb
 - lib/nydp/function_invocation.rb