nydp 0.1.11 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e297c2db504d03a1ae69c9b084c42d2967c409f6
-  data.tar.gz: 14ef550b291308d9fe1b5804a17e82733df7d46e
+  metadata.gz: 39e2357b8393c54fc0eea68f0edd2a8d6728ad3a
+  data.tar.gz: 27f90d034ee3a3fa44fe7c24e3a08638ac5b6781
 SHA512:
-  metadata.gz: 9b0ee4357faaf3d0d4f2a7be37df48eac75877c3e717c32ac05ab1e57372d36764f2f1d185ba4acbba90e34bb5f73ea8c1165fc8db4d640762ee42bdaedf6985
-  data.tar.gz: 36bd8b57e1b6dfb3634129806931b5d0b4e69caaa7bff59f0540c68a34ad9fc18d96b11d360069a1f38aa474e279b5e75db54fd198bd10fb66553fc73519d760
+  metadata.gz: 18a8c415c0a4c6418a17122fd619cc840120e9a5d3fc0444185399e22d52fe4852c966f60cc67c304e7c2b38e7b449459d5cbac498caa67fe405de8eb56809a1
+  data.tar.gz: b959fde0c9b6e51957687eccdd7252cacea90e51a82d8d166242aaaa41835035ecec79987a3cbe4ee741b2097f131401f094739e5f1b4cb5e26789992cb31c95

data/lib/lisp/core-015-documentation.nydp

@@ -1,10 +1,16 @@
-((fn (dox examples)
+((fn (dox examples chapters)
      (def dox-add-doc (name what texts args src)
        (hash-set dox
                  name
                  (cons (list name what texts args src)
                        (hash-get dox sym))))
 
+     (def dox-add-to-chapter (chapter item)
+       (hash-set chapters
+                 item
+                 (cons item
+                       (hash-get chapters item))))
+
      (def dox-add-examples (name example-exprs)
        (hash-set examples
                  name
@@ -33,7 +39,7 @@
      (def dox-arg-names (name)
        (cond (dox? name)
              (cadddr (car (dox-lookup name))))))
- (hash) (hash))
+ (hash) (hash) (hash))
 
 (def isa-comment? (thing)
   (cond (pair? thing)

data/lib/lisp/core-030-syntax.nydp

@@ -218,7 +218,10 @@
       `(brace-list-mono ,(car args))
       (brace-list-build-hash args)))
 
+(mac returnlet (var val . body)
+  ; stores ,val in ,var, executes ,@body, returns ,var
+  `(let ,var ,val ,@body ,var))
+
 (mac returning (val . body)
   ; stores ,val, executes ,@body, and returns ,val.
-  (w/uniq retval
-          `(let ,retval ,val ,@body ,retval)))
+  (w/uniq retval `(returnlet ,retval ,val ,@body)))

data/lib/lisp/core-040-utils.nydp

@@ -29,14 +29,27 @@
                                   txt)))
 
 (def joinstr (txt . things)
-     (let joinables (flatten things)
-       (apply +
-              (to-string (car joinables))
-              (flatten (zip (map (fn (_) txt) (cdr joinables))
-                            (map to-string (cdr joinables)))))))
+  ; flatten 'things into a single list (ie unnest lists)
+  ; convert each item to a string
+  ; return a single string which is the concatenation of each
+  ; stringified item, with given 'txt inserted in between
+  ; each item
+  (let joinables (flatten things)
+    (apply +
+           (to-string (car joinables))
+           (flatten (zip (map (fn (_) txt) (cdr joinables))
+                         (map to-string (cdr joinables)))))))
+
+(def j items
+  ; delegate to 'joinstr with an empty join string
+  (joinstr ""  items))
 
 (def string-pieces pieces
-  (joinstr "" pieces))
+  ; string-interpolation syntax emits this form. Default implementation
+  ; is to delegate to 'j , but containing forms may use macros that
+  ; override this in order to provide specific interpolation behaviour
+  ; (for example, formatting numbers or stripping HTML tags)
+  (j pieces))
 
 (def collect (f things)
   ; if 'things is a list, return all the items in the list for which 'f returns non-nil

data/lib/lisp/core-100-utils.nydp

@@ -36,3 +36,24 @@
 (def uniqify (things)
   ; return a list containing all the elements of 'things, but with no duplicates
   (reject (seen?) things))
+
+(def group-by (f things)
+  ; return a hash of 'things keyed by (f thing) for
+  ; each thing in 'things
+  (returnlet hsh {}
+    (each thing things
+          (hash-cons hsh (f thing) thing))))
+
+(with (m2i λd(+ (* 12 d.year) (- d.month 1))
+       i2m λi(date (/ i 12) (+ 1 (mod i 12)) 1))
+      (def relative-months (anchor . mm)
+        ; 'anchor is a date
+        ; 'mm is a list of integers
+        ; for each m in 'mm, return the date at the beginning of
+        ; the month given by adding m months to 'anchor
+        (let mi (m2i anchor)
+          (map λm(i2m (+ mi m)) mm))))
+
+(mac auto-hash names
+  ; (auto-hash a b c) same as { a a b b c c }
+  `(brace-list ,@(flatten:map λn(list n n) names)))

data/lib/lisp/tests/auto-hash-examples.nydp

@@ -0,0 +1,5 @@
+(examples-for auto-hash
+  ("builds a hash from the existing lexical context"
+   (with (a 1 b 2 c 3)
+         (to-string (auto-hash a b c)))
+   "{a=>1, b=>2, c=>3}"))

data/lib/lisp/tests/boot-tests.nydp

@@ -85,7 +85,11 @@
 
   ("special combination with bang"
    (pre-compile '(!x:y a b))
-   ((fn args (no (x (apply y args)))) a b)))
+   ((fn args (no (x (apply y args)))) a b))
+
+  ("precedence over ampersand-syntax"
+   (pre-compile '(&attr:func a b))
+   ((fn args ((fn (obj) (hash-get obj (quote attr))) (apply func args))) a b)))
 
 (examples-for let
   ("expands 'let"

data/lib/lisp/tests/builtin-tests.nydp

@@ -81,3 +81,6 @@
   ("multiplies 2 floats"  (* 4.2 0.5)      2.1)
   ("multiplies 3 floats"  (* 4.2 -2.5)   -10.5)
   ("multiplies 4 floats"  (* 6.6 1.1 3.3) 23.958))
+
+(examples-for mod
+  ("modulus for two ints" (mod 64 6) 4))

data/lib/lisp/tests/date-examples.nydp

@@ -24,6 +24,11 @@
     (to-string (hash-get h (date 2015 11 8))))
   "on this day")
 
+ ("equals itself"              (eq? (date 2004 3 12) (date 2004 3 12))  t  )
+ ("does not equal another"     (eq? (date 2004 3 12) (date 2006 6 21))  nil)
+ ("does not equal nil"         (eq? (date 2004 3 12) nil             )  nil)
+ ("nil does not equal a date"  (eq? nil (date 2004 3 12)             )  nil)
+
  ("returns its year"      (let d (date 1999 12 31) d.year)     1999)
  ("returns its month"     (let d (date 1999 12 31) d.month)    12  )
  ("returns its day"       (let d (date 1999 12 31) d.day)      31  )

data/lib/lisp/tests/group-by-examples.nydp

@@ -0,0 +1,8 @@
+(examples-for group-by
+  ("create a hash keyed by value of given function"
+   (let h (group-by car
+                    (list '(a b c) '(a x y) '(b c d) '(z y x) '(z b a) '(1 2 3)))
+     (joinstr ", "
+              (map λk(j k " -> " (inspect:hash-get h k))
+                   (hash-keys h))))
+   "a -> ((a x y) (a b c)), b -> ((b c d)), z -> ((z b a) (z y x)), 1 -> ((1 2 3))"))

data/lib/lisp/tests/relative-months-examples.nydp

@@ -0,0 +1,4 @@
+(examples-for relative-months
+  ("finds dates around a given date"
+   (joinstr " - " (relative-months (date 2000 1 1) -32 -2 0 2 24))
+   "1997-05-01 - 1999-11-01 - 2000-01-01 - 2000-03-01 - 2002-01-01"))

data/lib/lisp/tests/returning-examples.nydp

@@ -4,3 +4,9 @@
      (returning x
        (= x 3)))
    2))
+
+(examples-for returnlet
+  ("it stores the given value in the given variable, executes body, returns the value assigned to the variable"
+   (let result (returnlet hsh (hash) (= hsh.a 1) (= hsh.b 2))
+     (list (hash-keys result) (hash-values result)))
+   ((a b) (1 2))))

data/lib/lisp/tests/string-tests.nydp

@@ -62,6 +62,14 @@
    (joinstr " - " '(1 2 3))
    "1 - 2 - 3"))
 
+(examples-for j
+  ("joins elements with empty string"
+   (j 1 2 3)
+   "123")
+  ("joins elements of a list with empty string"
+   (j '(1 2 3))
+   "123"))
+
 (examples-for string-strip
   ("removes leading whitespace"               (string-strip "    hello!")  "hello!" )
   ("removes trailing whitespace"              (string-strip "(world)   ") "(world)" )

data/lib/nydp/builtin/modulo.rb

@@ -0,0 +1,11 @@
+class Nydp::Builtin::Modulo
+  include Nydp::Builtin::Base
+
+  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/core.rb

@@ -30,6 +30,7 @@ module Nydp
       Symbol.mk(:/,     ns).assign(Nydp::Builtin::Divide.new)
       Symbol.mk(:>,     ns).assign(Nydp::Builtin::GreaterThan.new)
       Symbol.mk(:<,     ns).assign(Nydp::Builtin::LessThan.new)
+      Symbol.mk(:mod,   ns).assign(Nydp::Builtin::Modulo.new)
       Symbol.mk(:eval,  ns).assign(Nydp::Builtin::Eval.new(ns))
       Symbol.mk(:false, ns).assign(false)
       Symbol.mk(:hash,  ns).assign(Nydp::Builtin::Hash.new)

data/lib/nydp/date.rb

@@ -25,20 +25,14 @@ module Nydp
     def inspect   ; ruby_date.inspect ; end
     def nydp_type ; :date             ; end
     def + int     ; r2n(ruby_date + int            , nil) ; end
-    def > other   ; ruby_date > other.ruby_date           ; end
-    def < other   ; ruby_date < other.ruby_date           ; end
-    def == other  ; ruby_date == other.ruby_date          ; end
-    def <=> other ; ruby_date <=> other.ruby_date         ; end
+    def > other   ; is_date?(other) && ruby_date > other.ruby_date           ; end
+    def < other   ; is_date?(other) && ruby_date < other.ruby_date           ; end
+    def == other  ; is_date?(other) && ruby_date == other.ruby_date          ; end
+    def <=> other ; is_date?(other) && ruby_date <=> other.ruby_date         ; end
     def eql? d    ; self == d                             ; end
     def hash      ; ruby_date.hash                        ; end
-
-    def - other
-      if other.is_a? Nydp::Date
-        r2n(ruby_date - other.ruby_date, nil)
-      else
-        r2n(ruby_date - other, nil)
-      end
-    end
+    def is_date? other ; other.is_a? Nydp::Date                                            ; end
+    def -        other ; r2n(ruby_date - (is_date?(other) ? other.ruby_date : other), nil) ; end
 
     @@pass_through = %i{ monday? tuesday? wednesday? thursday? friday? saturday? sunday? }
     @@keys = Set.new %i{

data/lib/nydp/parser.rb

@@ -44,11 +44,11 @@ module Nydp
       [
         [ /%/,      "percent-syntax"    ],
         [ /\!/,     "bang-syntax"       ],
+        [ /::/,     "colon-colon-syntax"],
+        [ /:/,      "colon-syntax"      ],
         [ /&/,      "ampersand-syntax"  ],
         [ /\./,     "dot-syntax"        ],
         [ /\$/,     "dollar-syntax"     ],
-        [ /::/,     "colon-colon-syntax"],
-        [ /:/,      "colon-syntax"      ],
         [ /->/,     "arrow-syntax"      ],
         [ /[=][>]/, "rocket-syntax"     ],
       ]

data/lib/nydp/truth.rb

@@ -1,13 +1,15 @@
 module Nydp
   class Truth
-    def to_s      ; 't'              ; end
-    def inspect   ; 't[nydp::Truth]' ; end
-    def assign *_ ; self             ; end
-    def nydp_type ; :truth           ; end
-    def to_ruby   ; true             ; end
+    def init_with *; Nydp.T           ; end
+    def to_s       ; 't'              ; end
+    def inspect    ; 't[nydp::Truth]' ; end
+    def assign  *_ ; self             ; end
+    def nydp_type  ; :truth           ; end
+    def to_ruby    ; true             ; end
   end
 
   class Nil
+    def init_with * ; Nydp.NIL      ; end
     def car         ; self          ; end
     def cdr         ; self          ; end
     def size        ; 0             ; end

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.1.11"
+  VERSION = "0.1.12"
 end

data/spec/date_spec.rb

@@ -46,36 +46,56 @@ describe Nydp::Date do
       expect(diff).to eq 6
     end
 
-    it "works with builtin greater-than when true" do
-      f = Nydp::Builtin::GreaterThan.new
+    describe "'>" do
+      it "works with builtin greater-than when true" do
+        f = Nydp::Builtin::GreaterThan.new
 
-      f.invoke vm, pair_list([d1, d0])
+        f.invoke vm, pair_list([d1, d0])
 
-      expect(vm.pop_arg).to eq Nydp.T
-    end
+        expect(vm.pop_arg).to eq Nydp.T
+      end
 
-    it "works with builtin greater-than when false" do
-      f = Nydp::Builtin::GreaterThan.new
+      it "compares with nil" do
+        f = Nydp::Builtin::GreaterThan.new
 
-      f.invoke vm, pair_list([d0, d1])
+        f.invoke vm, pair_list([d1, Nydp.NIL])
 
-      expect(vm.pop_arg).to eq Nydp.NIL
-    end
+        expect(vm.pop_arg).to eq Nydp.NIL
+      end
 
-    it "works with builtin less-than when true" do
-      f = Nydp::Builtin::LessThan.new
+      it "works with builtin greater-than when false" do
+        f = Nydp::Builtin::GreaterThan.new
 
-      f.invoke vm, pair_list([d0, d1])
+        f.invoke vm, pair_list([d0, d1])
 
-      expect(vm.pop_arg).to eq Nydp.T
+        expect(vm.pop_arg).to eq Nydp.NIL
+      end
     end
 
-    it "works with builtin less-than when false" do
-      f = Nydp::Builtin::LessThan.new
+    describe "'<" do
+      it "works with builtin less-than when true" do
+        f = Nydp::Builtin::LessThan.new
+
+        f.invoke vm, pair_list([d0, d1])
+
+        expect(vm.pop_arg).to eq Nydp.T
+      end
+
+      it "works with builtin less-than when false" do
+        f = Nydp::Builtin::LessThan.new
+
+        f.invoke vm, pair_list([d1, d0])
+
+        expect(vm.pop_arg).to eq Nydp.NIL
+      end
+
+      it "compares with nil" do
+        f = Nydp::Builtin::LessThan.new
 
-      f.invoke vm, pair_list([d1, d0])
+        f.invoke vm, pair_list([d1, Nydp.NIL])
 
-      expect(vm.pop_arg).to eq Nydp.NIL
+        expect(vm.pop_arg).to eq Nydp.NIL
+      end
     end
 
     it "works with builtin plus" do

data/spec/foreign_hash_spec.rb

@@ -0,0 +1,88 @@
+require "spec_helper"
+
+describe Nydp::Hash do
+  let(:vm) { Nydp::VM.new }
+
+  describe "foreign hashes" do
+    let(:ahash) { Hash.new }
+
+    describe "hash set" do
+      it "returns a new Nydp hash" do
+        k    = Nydp::Symbol.mk "keysym", ns
+        v    = Nydp::StringAtom.new "foobar"
+        args = pair_list [ahash, k, v]
+        Nydp::Builtin::HashSet.new.invoke vm, args
+
+        expect(ahash[:keysym]).      to eq "foobar"
+        expect(ahash[:keysym].class).to eq String
+        expect(ahash.keys).          to eq [:keysym]
+
+        expect(vm.pop_arg).to eq v
+      end
+    end
+
+    describe "hash get" do
+      it "converts ruby value to nydp value" do
+        ahash[:keysym] = "avalue"
+        k              = sym("keysym")
+        args           = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+
+        expect(vm.pop_arg).to eq Nydp::StringAtom.new("avalue")
+      end
+
+      it "converts ruby nil to nydp value" do
+        k              = sym("keysym")
+        args           = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+
+        expect(vm.pop_arg).to eq Nydp.NIL
+      end
+
+      it "converts ruby true to nydp value" do
+        ahash[:keysym] = true
+        k              = sym("keysym")
+        args           = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+
+        expect(vm.pop_arg).to eq Nydp.T
+      end
+    end
+
+    describe "key?" do
+      it "returns t when key is present" do
+        ahash[:simon] = 24
+        k             = sym("simon")
+        args          = [ ahash, k ]
+
+        Nydp::Builtin::HashKeyPresent.new(ns).invoke vm, pair_list(args)
+
+        expect(vm.pop_arg).to eq Nydp.T
+      end
+
+      it "returns nil when key is absent" do
+        k             = sym("simon")
+        args          = [ ahash, k ]
+
+        Nydp::Builtin::HashKeyPresent.new(ns).invoke vm, pair_list(args)
+
+        expect(vm.pop_arg).to eq Nydp.NIL
+      end
+    end
+
+    describe "hash keys" do
+      it "returns a list of keys" do
+        ahash[:k0] = 42
+        ahash[:k1] = 84
+        args       = [ahash]
+
+        Nydp::Builtin::HashKeys.new(ns).invoke vm, pair_list(args)
+
+        expect(vm.pop_arg).to eq pair_list [sym("k0"), sym("k1")]
+      end
+    end
+  end
+end

data/spec/hash_non_hash_behaviour_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+describe Nydp::Hash do
+  let(:vm) { Nydp::VM.new }
+
+  describe "friendly non-hashes" do
+    let(:ahash) { TestThing.new 123, "hello there", "private" }
+
+    describe "hash get" do
+      it "returns a plain number" do
+        k      = Nydp::Symbol.mk "a", ns
+        args   = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+        expect(vm.pop_arg).to eq 123
+      end
+
+      it "converts ruby value to nydp value" do
+        k      = Nydp::Symbol.mk "b", ns
+        args   = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+        expect(vm.pop_arg).to eq Nydp::StringAtom.new("hello there")
+      end
+
+      it "converts string keys to method names" do
+        k      = Nydp::StringAtom.new "b"
+        args   = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+        expect(vm.pop_arg).to eq Nydp::StringAtom.new("hello there")
+      end
+
+      it "returns nil for unavailable methods" do
+        k      = Nydp::Symbol.mk "c", ns
+        args   = [ ahash, k ]
+
+        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+        expect(vm.pop_arg).to eq Nydp.NIL
+      end
+    end
+  end
+
+  describe "unfriendly non-hash" do
+    let(:ahash) { Nydp::StringAtom.new "this here ain't no hash, hombre" }
+
+    describe "hash set" do
+      it "does nothing, returns its value" do
+        k    = Nydp::Symbol.mk "keysym", ns
+        v    = Nydp::StringAtom.new "foobar"
+        args = pair_list [ahash, k, v]
+
+        begin
+          Nydp::Builtin::HashSet.new.invoke vm, args
+        rescue Exception => 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>"
+      end
+    end
+
+    describe "hash get" do
+      it "converts ruby value to nydp value" do
+        k      = Nydp::Symbol.mk "keysym", ns
+        args   = [ ahash, k ]
+
+        begin
+          Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
+        rescue Exception => 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>"
+      end
+    end
+  end
+end

data/spec/hash_spec.rb

@@ -130,89 +130,6 @@ describe Nydp::Hash do
     end
   end
 
-  describe "foreign hashes" do
-    let(:ahash) { Hash.new }
-
-    describe "hash set" do
-      it "returns a new Nydp hash" do
-        k    = Nydp::Symbol.mk "keysym", ns
-        v    = Nydp::StringAtom.new "foobar"
-        args = pair_list [ahash, k, v]
-        Nydp::Builtin::HashSet.new.invoke vm, args
-
-        expect(ahash[:keysym]).      to eq "foobar"
-        expect(ahash[:keysym].class).to eq String
-        expect(ahash.keys).          to eq [:keysym]
-
-        expect(vm.pop_arg).to eq v
-      end
-    end
-
-    describe "hash get" do
-      it "converts ruby value to nydp value" do
-        ahash[:keysym] = "avalue"
-        k              = sym("keysym")
-        args           = [ ahash, k ]
-
-        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
-
-        expect(vm.pop_arg).to eq Nydp::StringAtom.new("avalue")
-      end
-
-      it "converts ruby nil to nydp value" do
-        k              = sym("keysym")
-        args           = [ ahash, k ]
-
-        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
-
-        expect(vm.pop_arg).to eq Nydp.NIL
-      end
-
-      it "converts ruby true to nydp value" do
-        ahash[:keysym] = true
-        k              = sym("keysym")
-        args           = [ ahash, k ]
-
-        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
-
-        expect(vm.pop_arg).to eq Nydp.T
-      end
-    end
-
-    describe "key?" do
-      it "returns t when key is present" do
-        ahash[:simon] = 24
-        k             = sym("simon")
-        args          = [ ahash, k ]
-
-        Nydp::Builtin::HashKeyPresent.new(ns).invoke vm, pair_list(args)
-
-        expect(vm.pop_arg).to eq Nydp.T
-      end
-
-      it "returns nil when key is absent" do
-        k             = sym("simon")
-        args          = [ ahash, k ]
-
-        Nydp::Builtin::HashKeyPresent.new(ns).invoke vm, pair_list(args)
-
-        expect(vm.pop_arg).to eq Nydp.NIL
-      end
-    end
-
-    describe "hash keys" do
-      it "returns a list of keys" do
-        ahash[:k0] = 42
-        ahash[:k1] = 84
-        args       = [ahash]
-
-        Nydp::Builtin::HashKeys.new(ns).invoke vm, pair_list(args)
-
-        expect(vm.pop_arg).to eq pair_list [sym("k0"), sym("k1")]
-      end
-    end
-  end
-
   describe "get/set nil" do
     let(:ahash) { Nydp.NIL }
 
@@ -239,85 +156,4 @@ describe Nydp::Hash do
       end
     end
   end
-
-  describe "friendly non-hashes" do
-    let(:ahash) { TestThing.new 123, "hello there", "private" }
-
-    describe "hash get" do
-      it "returns a plain number" do
-        k      = Nydp::Symbol.mk "a", ns
-        args   = [ ahash, k ]
-
-        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
-        expect(vm.pop_arg).to eq 123
-      end
-
-      it "converts ruby value to nydp value" do
-        k      = Nydp::Symbol.mk "b", ns
-        args   = [ ahash, k ]
-
-        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
-        expect(vm.pop_arg).to eq Nydp::StringAtom.new("hello there")
-      end
-
-      it "converts string keys to method names" do
-        k      = Nydp::StringAtom.new "b"
-        args   = [ ahash, k ]
-
-        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
-        expect(vm.pop_arg).to eq Nydp::StringAtom.new("hello there")
-      end
-
-      it "returns nil for unavailable methods" do
-        k      = Nydp::Symbol.mk "c", ns
-        args   = [ ahash, k ]
-
-        Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
-        expect(vm.pop_arg).to eq Nydp.NIL
-      end
-    end
-  end
-
-  describe "non-hash" do
-    let(:ahash) { Nydp::StringAtom.new "this here ain't no hash, hombre" }
-
-    describe "hash set" do
-      it "does nothing, returns its value" do
-        k    = Nydp::Symbol.mk "keysym", ns
-        v    = Nydp::StringAtom.new "foobar"
-        args = pair_list [ahash, k, v]
-
-        begin
-          Nydp::Builtin::HashSet.new.invoke vm, args
-        rescue Exception => 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>"
-      end
-    end
-
-    describe "hash get" do
-      it "converts ruby value to nydp value" do
-        k      = Nydp::Symbol.mk "keysym", ns
-        args   = [ ahash, k ]
-
-        begin
-          Nydp::Builtin::HashGet.new(ns).invoke vm, pair_list(args)
-        rescue Exception => 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>"
-      end
-    end
-  end
 end

data/spec/parser_spec.rb

@@ -146,23 +146,20 @@ describe Nydp::Parser do
 
   it "should spot numbers hiding in special syntax" do
     parsed = parse("foo.2:3:4")
-    expect(parsed.inspect).to eq "(dot-syntax foo (colon-syntax 2 3 4))"
+    expect(parsed.inspect).to eq "(colon-syntax (dot-syntax foo 2) 3 4)"
 
-    numbers = parsed.cdr.cdr.car.cdr
-    two = numbers.car
-    three = numbers.cdr.car
-    four = numbers.cdr.cdr.car
-
-    expect([two, three, four].map &:class).to eq [Fixnum, Fixnum, Fixnum]
+    expect(parsed.map &:class).to eq [Nydp::Symbol, Nydp::Pair, Fixnum, Fixnum]
+    expect(parsed.cdr.car.map &:class).to eq [Nydp::Symbol, Nydp::Symbol, Fixnum]
   end
 
   it "should handle prefix and postfix syntax also" do
     parsed = parse(".foo123:")
-    expect(parsed.inspect).to eq "(dot-syntax || (colon-syntax foo123 ||))"
+    expect(parsed.inspect).to eq "(colon-syntax (dot-syntax || foo123) ||)"
   end
 
   it "should parse a dotted symbol" do
-    expect(parse "(list a b foo.bar c)").to eq  pair_list([sym(:list), a, b, pair_list([dotsyn, foo, bar]), c])
+    expected = parse "(list a b (dot-syntax foo bar) c)"
+    expect(parse "(list a b foo.bar c)").to eq expected
   end
 
   it "should parse a colon-colon symbol" do
@@ -170,7 +167,8 @@ describe Nydp::Parser do
   end
 
   it "should parse a colon-symbol within a colon-colon within a dotted symbol" do
-    expect(parse "aa.foo:foo::bar:bar.zz").to eq pair_list([dotsyn, aa, pair_list([cocosyn, pair_list([colosyn, foo, foo]), pair_list([colosyn, bar, bar])]), zz])
+    expected = parse "(colon-colon-syntax (colon-syntax (dot-syntax aa foo) foo) (colon-syntax bar (dot-syntax bar zz)))"
+    expect(parse "aa.foo:foo::bar:bar.zz").to eq expected
   end
 
   it "should quote symbols" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 0.1.12
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-23 00:00:00.000000000 Z
+date: 2016-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -99,6 +99,7 @@ files:
 - lib/lisp/core-090-hook.nydp
 - lib/lisp/core-100-utils.nydp
 - lib/lisp/tests/add-hook-examples.nydp
+- lib/lisp/tests/auto-hash-examples.nydp
 - lib/lisp/tests/best-examples.nydp
 - lib/lisp/tests/boot-tests.nydp
 - lib/lisp/tests/builtin-tests.nydp
@@ -117,6 +118,7 @@ files:
 - lib/lisp/tests/error-tests.nydp
 - lib/lisp/tests/explain-mac-examples.nydp
 - lib/lisp/tests/foundation-test.nydp
+- lib/lisp/tests/group-by-examples.nydp
 - lib/lisp/tests/hash-examples.nydp
 - lib/lisp/tests/include-examples.nydp
 - lib/lisp/tests/invocation-tests.nydp
@@ -129,6 +131,7 @@ files:
 - lib/lisp/tests/pretty-print-tests.nydp
 - lib/lisp/tests/quasiquote-examples.nydp
 - lib/lisp/tests/range-examples.nydp
+- lib/lisp/tests/relative-months-examples.nydp
 - lib/lisp/tests/returning-examples.nydp
 - lib/lisp/tests/rfnwith-tests.nydp
 - lib/lisp/tests/sort-examples.nydp
@@ -159,6 +162,7 @@ files:
 - lib/nydp/builtin/load_tests.rb
 - lib/nydp/builtin/millisecs.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
@@ -209,6 +213,8 @@ files:
 - spec/date_spec.rb
 - spec/embedded_spec.rb
 - spec/error_spec.rb
+- spec/foreign_hash_spec.rb
+- spec/hash_non_hash_behaviour_spec.rb
 - spec/hash_spec.rb
 - spec/literal_spec.rb
 - spec/nydp_spec.rb
@@ -247,6 +253,8 @@ test_files:
 - spec/date_spec.rb
 - spec/embedded_spec.rb
 - spec/error_spec.rb
+- spec/foreign_hash_spec.rb
+- spec/hash_non_hash_behaviour_spec.rb
 - spec/hash_spec.rb
 - spec/literal_spec.rb
 - spec/nydp_spec.rb