nydp 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93571312813f5383bd47d92b298cd95b0239f07e
-  data.tar.gz: 242349e0186b701a602e94cbfdba9a1adfb5d5bb
+  metadata.gz: 1a6a8e0215b81d92423402f9933413c58ebcdad9
+  data.tar.gz: eeb8d8bb621ed6349d2e9d4e7823c3be5e875d04
 SHA512:
-  metadata.gz: 47e4c03909bcc94e0440d35f6a8e4f3cf36241832a89042456d18d556c6f8a34953d10382e2b5c17df6d28a7c530f9347c505cb6cf66931b9dcf18b34c2df88d
-  data.tar.gz: c899014050d46f2a093dec88a62f6a44ff70fffdd6bc66392338c33699f49c92e4ef0239d49e337685190757b318409d614a9319463dedd0bba1883526e78dc6
+  metadata.gz: 1f32b55812f569e1329b657eed211054be4e275fcd778671ec7e251fe2b98fc7390531a9742ca819c9eb076aeb9bb34ffd2390c0fd5ebe43ddfc35d75e0eae95
+  data.tar.gz: 2f5cad91e0551afb32c410751c56b11e1b55158218a8bdab8eb5db3d2b38719d3cfb63cc04ca961b7e1436075dbaf10ad3d5d82bf75a61f1fc1d91fd25c03a3f

data/lib/lisp/core-010-precompile.nydp

@@ -1,17 +1,12 @@
-(assign mac-expand (fn (names macfn expr)
-  (cond macfn
-        (pre-compile-with names
-                          (apply macfn (cdr expr)))
-        expr)))
+(assign mac-expand
+        (fn (names macfn expr)
+            (cond macfn
+                  (pre-compile-with names
+                                    (apply macfn (cdr expr)))
+                  expr)))
 
 (assign macs (hash))
 
-(assign pre-compile-expr
-        (fn (names expr)
-            (mac-expand names
-                        (hash-get names (car expr))
-                        expr)))
-
 (assign pre-compile-each
         (fn (names args)
             (cond args
@@ -33,7 +28,10 @@
                   (cond (eq? (car arg) 'quote)
                         arg
                         (pre-compile-each names
-                                          (pre-compile-expr names arg)))
+                                          (mac-expand names
+                                                      (hash-get names
+                                                                (car arg))
+                                                      arg)))
                   arg)))
 
 (assign pre-compile-debug

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

@@ -8,7 +8,7 @@
                                    (car args))
                              nil)))
 
-(def map-helper-0 (f things lc _)
+(def map-helper-0 (f things lc)
   (if (pair? things)
       (map-helper-0 f (cdr things) (cdr-set lc (cons (f (car things)))))
       things

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

@@ -64,7 +64,7 @@
 (assign this-script nil)
 (assign this-plugin "Nydp Core")
 
-((fn (dox examples chapters types dox-new dox-build)
+((fn (dox examples chapters types types-chapters dox-new dox-build)
      (def dox-build (hsh name what texts args src chapters)
        (hash-set hsh 'name     name        )
        (hash-set hsh 'what     what        )
@@ -79,16 +79,17 @@
      (def dox-new (item)
        (hash-cons dox (hash-get item 'name) item)
        (hash-cons types (hash-get item 'what) item)
-       (dox-add-to-chapters item (hash-get item 'chapters)))
+       (dox-add-to-chapters item (hash-get item 'what) (hash-get item 'chapters)))
 
      (def dox-add-doc (name what texts args src chapters more)
        (cond (no (privately))
              (dox-new (dox-build (if more more (hash)) name what texts args src chapters))))
 
-     (def dox-add-to-chapters (item chapters)
+     (def dox-add-to-chapters (item type chapters)
        (cond chapters
              (do (chapter-add-item    item (car chapters))
-                 (dox-add-to-chapters item (cdr chapters)))
+                 (hash-cons types-chapters (cons type (car chapters)) item)
+                 (dox-add-to-chapters item type (cdr chapters)))
              item))
 
      (def dox-add-examples (name example-exprs)
@@ -102,6 +103,9 @@
      (def dox-types () (hash-keys types))
      (def dox-items-by-type (type) (hash-get types type))
 
+     (def dox-items-by-type-and-chapter (type chapter)
+       (hash-get types-chapters (cons type chapter)))
+
      (def dox-get-attr (name attr)
        (cond (dox? name)
              (hash-get (car (dox-lookup name)) attr)))
@@ -111,7 +115,7 @@
      (def dox-examples  (name) (hash-get examples name  ))
      (def dox-args      (name) (dox-get-attr name 'args ))
      (def dox-example-names () (hash-keys examples      )))
- (hash) (hash) (hash) (hash) nil)
+ (hash) (hash) (hash) (hash) (hash) nil)
 
 (def plugin-start (name) (assign this-plugin name) (chapter-end))
 (def plugin-end   (name) (assign this-plugin nil ) (chapter-end))

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

@@ -116,6 +116,16 @@ scoping, assignment, anonymous functions and more...")
        (assign ,name (fun ,(map car ppairs) ,@body))
        (,name ,@(map cadr ppairs)))))
 
+;; (andify a b c) is equivalent to
+;; (fn args (and (apply a args) (apply b args) (apply c args)))
+;; or more simply
+;; (fn (x) (and (a x) (b x) (c x)))
+(def andify args
+  (fn args2 (rfnwith self (ands args)
+                     (if ands (if (apply (car ands) args2)
+                                  (self (cdr ands)))
+                         t))))
+
 (let uniq-counter 0
   (def uniq (prefix)
     (assign uniq-counter (+ uniq-counter 1))
@@ -283,16 +293,19 @@ scoping, assignment, anonymous functions and more...")
 ; (eg hash), the mutated value will be returned. See also 'returnlet
 (mac returning (val . body) (w/uniq retval `(returnlet ,retval ,val ,@body)))
 
-(mac aif (expr . body)
-  ; like if, except the value of each condition is locally bound to the variable 'it
-  ; eg (aif (find thing) (show it))
-  ; source: arc.arc
-  `(let it ,expr
-     (if it
+(mac ifv (var expr . body)
+  `(let ,var ,expr
+     (if ,var
          ,@(if (cddr body)
-               `(,(car body) (aif ,@(cdr body)))
+               `(,(car body) (ifv ,var ,@(cdr body)))
                body))))
 
+; like if, except the value of each condition is locally bound to the variable 'it
+; eg (aif (find thing) (show it))
+; source: arc.arc
+(mac aif (expr . body)
+  `(ifv it ,expr ,@body))
+
 (def destructure/with (var args n)
   ; provides the argument expression to 'with when
   ; destructuring arguments are present in a 'fun definition
@@ -315,18 +328,18 @@ scoping, assignment, anonymous functions and more...")
       `(fn ,(rev new-args given-args) ,@body)))
 
 
-(def fun/approve-arg-names (orig args)
+(def fun/approve-arg-names (orig args body)
   (if (pair? args)
-      (do (fun/approve-arg-names orig (car args))
-          (fun/approve-arg-names orig (cdr args)))
+      (do (fun/approve-arg-names orig (car args) body)
+          (fun/approve-arg-names orig (cdr args) body))
       args
       (if (hash-get macs args)
-          (warnings/new 'arg-shadows-macro "arg " args " shadows macro " args " in arg list " orig))))
+          (warnings/new 'arg-shadows-macro "arg " args " shadows macro " args " in arg list " orig " and body " body))))
 
 (mac fun (args . body)
   ; build a 'fn form, changing 'args and 'body to
   ; properly handle any destructuring args if present
-  (fun/approve-arg-names args args)
+  (fun/approve-arg-names args args body)
   (destructure/build args nil body))
 
 ; assign (f place) to place

data/lib/lisp/core-037-list-utils.nydp

@@ -29,6 +29,7 @@
           (rfnwith flattenize (x things)
                    (if (pair? x)
                        (eachr flattenize x)
+                       x
                        (push (f x) acc)))
           acc))
 

data/lib/lisp/core-042-date-utils.nydp

@@ -1,5 +1,9 @@
 (chapter-start 'date-time "utilities for retrieving and manipulating dates and times")
 
+;; return a date for the current day
 (def today ()
-  ; return a date for the current day
   (date))
+
+;; return a Time object representing the time 's seconds ago
+(def seconds-ago (s)
+  (- (time) s))

data/lib/lisp/core-043-list-utils.nydp

@@ -48,9 +48,8 @@
 
 (assign select collect)
 
-(def compact (things)
-  ; return a new list containing only non-nil items from the given list
-  (collect present? things))
+; return a new list containing only 'present? items from the given list
+(def compact (things) (collect present? things))
 
 (def +nz args
   ; return the sum of all non-nil values (consider nil as zero)
@@ -215,3 +214,14 @@
 
 ; given an arg 'f, invoke 'f with no args
 (def self-invoke (f) (f))
+
+;; returns the first element of 'things iff it is the only element of 'things
+(def list-single-element (things)
+  (if (no (cdr things)) (car things)))
+
+;; like map, but function 'f takes two arguments: the thing and the 0-based index of the thing
+(def map-with-index (f things)
+  (let i -1
+    (map (fn (thing)
+             (f thing (++ i)))
+         things)))

data/lib/lisp/core-090-hook.nydp

@@ -35,7 +35,15 @@
     (each hook (hooks-for hook-name)
           (apply hook args))))
 
-(add-hook 'warnings/new λw(apply p w))
+; install a hook for a particular kind of event
+;
+; example
+; (on transaction (account amount) (update account total (+ account.total amount)))
+;
+; same as (add-hook 'transaction (fn (account amount) (update account total (+ account.total amount))))
+;
+(mac on (event args . body)
+  `(add-hook ',event (fn ,args ,@body)))
 
 (let super warnings/new
   (def warnings/new (kind . info)
@@ -43,3 +51,5 @@
     (chapter nydp/warnings)
     (apply super kind info)
     (run-hooks 'warnings/new (cons kind info))))
+
+(on warnings/new w (apply p w))

data/lib/lisp/core-110-hash-utils.nydp

@@ -1,7 +1,23 @@
 (chapter-start 'hash-manipulation "utilities for manipulating, accessing and altering hash objects")
 
 ; return values for each key in hash 'h
-(def hash-values (h) (map (fn (k) h.,k) (hash-keys h)))
+(def hash-values (h)
+  (map λk(hash-get h k)
+       (hash-keys h)))
 
 ; (auto-hash a b c) same as { a a b b c c }
-(mac auto-hash names `(brace-list ,@(flatten:map λn(list n n) names)))
+(mac auto-hash names
+  `(brace-list ,@(flatten:map λn(list n n) names)))
+
+;; like 'map, but for a hash instead of a list ; provided function 'f takes three arguments,
+;; a key, the corresponding value from the given hash, and the index of the item in the list
+(def map-hash (f h pre)
+  (map-with-index λki(f k (hash-get h k) i)
+                  ((or pre x1) (hash-keys h))))
+
+;; Return a new hash where keys are (map f things) and values are the corresponding things.
+;; No attempt is made to avoid clobbering items. Use 'group-by if there are duplicate keys.
+(def hashify (f things)
+  (returnlet hsh {}
+             (each thing things
+                   (hash-set hsh (f thing) thing))))

data/lib/lisp/core-120-settings.nydp

@@ -29,7 +29,9 @@
                       { setting { default ',initial context ',context name ',name } })
          (set-setting ,(sym name) ,initial))))
 
-; get the value of the given setting
+; get the value of the given setting. Raises an error if the setting is unknown
 (def setting (name)
-  (on-err (error "can't get value of setting ~name")
-          ((hash-get settings (sym name)) name)))
+  (aif (hash-get settings (sym name))
+       (on-err (error "can't get value of setting ~name")
+               (it name))
+       (error "unknown setting ~(inspect name)")))

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

@@ -12,9 +12,14 @@
    "hello world")
 
   ("recurses as necessary"
-   (explain-mac 1 '(aif (a) (b) (c) (d) (e)))
-   (let it (a) (if it (b) (aif (c) (d) (e)))))
+   (explain-mac 2 '(aif (a) (b) (c) (d) (e)))
+   (let it (a) (if it (b) (ifv it (c) (d) (e)))))
+
+  ("assigns each successive condition to 'it"
+   (aif (eq? 1 2) nil
+        42        (list it it))
+   (42 42))
 
   ("avoids unnecessary expansion"
-   (explain-mac 1 '(aif (a) (b) (c)))
+   (explain-mac 2 '(aif (a) (b) (c)))
    (let it (a) (if it (b) (c)))))

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

@@ -0,0 +1,7 @@
+(examples-for andify
+  ("takes a list of functions A and returns a function that applies its arguments to each f in A in turn, returning the logical AND of the set of return values"
+   (with (even?   λn(eq? (mod n 2) 0)
+          triple? λn(eq? (mod n 3) 0)
+          big?    λn(> n 10))
+         (select (andify even? triple? big?) (range -10 31)))
+   (12 18 24 30)))

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

@@ -84,3 +84,12 @@
 
 (examples-for mod
   ("modulus for two ints" (mod 64 6) 4))
+
+(examples-for inspect
+  ("truth"            (inspect t)        "t")
+  ("nil"              (inspect nil)      "nil")
+  ("number"           (inspect 42)       "42")
+  ("string"           (inspect "hello")  "\"hello\"")
+  ("list"             (inspect '(fn (x) (this that))) "(fn (x) (this that))")
+  ("list with string" (inspect '(fn (x) (this "string"))) "(fn (x) (this \"string\"))")
+  ("list with sym"    (inspect '(fn (x) (this 'quoted))) "(fn (x) (this (quote quoted)))"))

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

@@ -66,12 +66,12 @@
    (do (without-hooks 'warnings/new
                       λ(on-err nil
                                (pre-compile '(fun (aif (and or) . when)
-                                                  "ignore"))))
+                                                  ignore))))
        warnings/list)
-   ((arg-shadows-macro "arg " when " shadows macro " when " in arg list " (aif (and or) . when))
-    (arg-shadows-macro "arg " or " shadows macro " or " in arg list " (aif (and or) . when))
-    (arg-shadows-macro "arg " and " shadows macro " and " in arg list " (aif (and or) . when))
-    (arg-shadows-macro "arg " aif " shadows macro " aif " in arg list " (aif (and or) . when))))
+   ((arg-shadows-macro "arg " when " shadows macro " when " in arg list " (aif (and or) . when) " and body " (ignore) )
+    (arg-shadows-macro "arg "   or " shadows macro "   or " in arg list " (aif (and or) . when) " and body " (ignore) )
+    (arg-shadows-macro "arg "  and " shadows macro "  and " in arg list " (aif (and or) . when) " and body " (ignore) )
+    (arg-shadows-macro "arg "  aif " shadows macro "  aif " in arg list " (aif (and or) . when) " and body " (ignore) )))
 
   ("implicit in 'let and 'with"
    (with ((a b)       (list "h" "e")

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

@@ -10,6 +10,12 @@
   ("  t for a hash"    (hash? {a 1 b 2})       t  )
   ("nil for a symbol"  (hash? 'foo)            nil))
 
+(examples-for hash-slice
+  ("returns a new hash containing only the specified keys"
+   (let h (hash-slice { a 1 b 2 c 3 d 4 } '(a b e f))
+     (list (hash-keys h) (hash-values h)))
+   ((a b) (1 2))))
+
 (examples-for hash-merge
   ("merge with symbol keys"
    (let h (hash-merge { a 1 b 2 c 3 } { a 99 c 98 d 97 })
@@ -29,7 +35,8 @@
 
   ("returns date operations"
    (sort:hash-keys (date 2015 11 18))
-   (beginning_of_month
+   (age
+    beginning_of_month
     beginning_of_week
     beginning_of_year
     day

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

@@ -1,3 +1,17 @@
+(examples-for list-single-element
+  ("returns nothing from an empty list"
+   (list-single-element nil)
+   nil)
+
+  ("returns first item from a list with one item"
+   (list-single-element '(x))
+   x)
+
+  ("returns nothing from a list with more than one item"
+   (list-single-element '(x y z))
+   nil))
+
+
 (examples-for iso
   ("(nil) is not the same as nil"
    (iso '(nil) nil)
@@ -37,7 +51,11 @@
    (g f (c d e) b a)))
 
 (examples-for flatten
-  ("'flatten returns a flat list of things"
+  ("removes empty lists and nil"
+   (flatten '(a b nil (c d () e nil) f ()))
+   (a b c d e f))
+
+  ("returns a flat list of things"
    (flatten '((poo (x) (* x x)) (1 2 3)))
    (poo x * x x 1 2 3)))
 

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

@@ -0,0 +1,11 @@
+(examples-for map-hash
+  ("iterates over key-value pairs"
+   (map-hash (fn (k v i) "pos.~i : ~k is for ~v")
+             { a 42 b 729 c 1024 })
+   ("pos.0 : a is for 42" "pos.1 : b is for 729" "pos.2 : c is for 1024"))
+
+  ("sorts keys before iterating"
+   (map-hash (fn (k v i) "pos.~i : ~k is for ~v")
+             { "aa" 1 "bbb" 2 "c" 3 }
+             (fn (keys) (sort-by len keys)))
+   ("pos.0 : c is for 3" "pos.1 : aa is for 1" "pos.2 : bbb is for 2" )))

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

@@ -9,9 +9,14 @@
   ("parses an empty symbol"         (parse "||")               (||) )
   ("parses a colon-syntax symbol"   (parse "this:that")        ((colon-syntax this that)) )
   ("parses a percent-syntax symbol" (parse "this%that")        ((percent-syntax this that)) )
+  ("parses combined percent-colon"  (parse "%this:%that")      ((colon-syntax (percent-syntax || this) (percent-syntax || that))) )
   ("parses a prefix dollar"         (parse "$this")            ((dollar-syntax || this)))
   ("parses a prefix dollar-dot"     (parse "$.this")           ((dot-syntax (dollar-syntax || ||) this)))
 
+  ("parses combined percent-colon-dot"
+   (parse "%this.foo:%that.bar")
+   ((colon-syntax (percent-syntax || (dot-syntax this foo)) (percent-syntax || (dot-syntax that bar)))) )
+
   ("parse custom prefix-lists with a special-syntax prefix"
    (parse "x.y(1 2 3)")
    ((prefix-list "x.y" (1 2 3))))

data/lib/lisp/tests/pretty-print-tests.nydp

@@ -206,13 +206,12 @@ toto")
    (pp '(def yoohoo (it) (wrangle "foobar" it)))
    "(def yoohoo (it) (wrangle \"foobar\" it))")
 
-  ("a 'let form"
-   (pp '(let acc nil
-            (rfnwith flattenize (x things)
-                     (if (pair? x)
-                         (eachr flattenize x)
-                         (push x acc)))
-            acc))
+  ("something with a nil and t literal"
+   (pp '(def yoohoo (it) (wrangle nil t it)))
+   "(def yoohoo (it) (wrangle nil t it))")
+
+  ("a 'let form squished into one line"
+   (pp '(let acc nil (rfnwith flattenize (x things) (if (pair? x) (eachr flattenize x) (push x acc))) acc))
    "(let acc nil
      (rfnwith flattenize (x things)
               (if (pair? x)
@@ -221,13 +220,11 @@ toto")
      acc)")
 
 
-  ("a real-life example from utils"
+  ("a real-life example from utils with improper 'if formatting"
    (pp '(def flatten (things)
           (let acc nil
             (rfnwith flattenize (x things)
-                     (if (pair? x)
-                         (eachr flattenize x)
-                         (push x acc)))
+                     (if (pair? x) (eachr flattenize x) (push x acc)))
             acc)))
    "(def flatten (things)
      (let acc nil

data/lib/lisp/tests/set-difference-examples.nydp

@@ -0,0 +1,8 @@
+(examples-for -
+  ("returns elements of first that are not in second"
+   (- '(a b c e) '(a b d))
+   (c e))
+
+  ("returns all of first if second is nil"
+   (- '(a b c) nil)
+   (a b c)))

data/lib/nydp/builtin/hash.rb

@@ -56,3 +56,16 @@ class Nydp::Builtin::HashMerge
     vm.push_arg hash_0.merge hash_1
   end
 end
+
+class Nydp::Builtin::HashSlice
+  include Nydp::Helper, Nydp::Builtin::Base, Singleton
+
+  def builtin_invoke vm, args
+    old   = args.car
+    h     = old.class.new
+    slice = args.cdr.car
+    slice = slice.map { |k| n2r k } unless old.is_a? Nydp::Hash
+    slice.each { |k| h[k] = old[k] if old.key?(k) }
+    vm.push_arg h
+  end
+end

data/lib/nydp/core.rb

@@ -71,6 +71,7 @@ module Nydp
       Symbol.mk(:"hash-keys",   ns).assign(Nydp::Builtin::HashKeys.instance)
       Symbol.mk(:"hash-key?",   ns).assign(Nydp::Builtin::HashKeyPresent.instance)
       Symbol.mk(:"hash-merge",  ns).assign(Nydp::Builtin::HashMerge.instance)
+      Symbol.mk(:"hash-slice",  ns).assign(Nydp::Builtin::HashSlice.instance)
       Symbol.mk(:"vm-info",     ns).assign Nydp::Builtin::VmInfo.instance
       Symbol.mk(:"pre-compile" , ns).assign Nydp::Builtin::PreCompile.instance
       Symbol.mk(:"script-run"  , ns).assign Nydp::Builtin::ScriptRun.instance

data/lib/nydp/date.rb

@@ -38,7 +38,7 @@ module Nydp
       last_year  next_year  beginning_of_year  end_of_year
       last_month next_month beginning_of_month end_of_month
       last_week  next_week  beginning_of_week  end_of_week
-      yesterday  tomorrow
+      yesterday  tomorrow   age
     } + @@pass_through
 
     def year               y, m, d, w ; y ; end
@@ -64,6 +64,13 @@ module Nydp
     def yesterday          y, m, d, w ; ruby_date - 1                ; end
     def tomorrow           y, m, d, w ; ruby_date + 1                ; end
 
+    def age y,m,d,w # args not used
+      interval = (::Date.today - ruby_date) / 365.0
+      age_in_years = interval.to_i
+      extra_months = (12 * (interval - age_in_years)).to_i
+      { years: age_in_years, months: extra_months }
+    end
+
     @@pass_through.each do |n|
       class_eval "def #{n} * ; ruby_date.#{n} ; end"
     end

data/lib/nydp/function_invocation.rb

@@ -24,7 +24,7 @@ module Nydp
           raise
         else
           if e.is_a?(NoMethodError) && !f.respond_to?(invoker)
-            raise InvocationFailed.new("#{f.inspect} is not a function: args were #{args.inspect}")
+            raise InvocationFailed.new("#{f.inspect} is not a function: args were #{args.inspect} in #{source.inspect}")
           else
             msg  = args.map { |a| "  #{a.inspect}"}.join("\n")
             msg  =  "failed to execute invocation #{f.inspect}\n#{msg}"

data/lib/nydp/pair.rb

@@ -24,6 +24,7 @@ class Nydp::Pair
   def inspect    ; "(#{inspect_rest})"                        ; end
   def &    other ; self.class.from_list((Set.new(self) & other).to_a)           ; end
   def |    other ; self.class.from_list((Set.new(self) | other).to_a)           ; end
+  def -    other ; self.class.from_list((Set.new(self) - other).to_a)           ; end
   def proper?    ; Nydp::NIL.is?(cdr) || (cdr.is_a?(Nydp::Pair) && cdr.proper?) ; end
 
   # returns Array of elements after calling #n2r on each element

data/lib/nydp/parser.rb

@@ -45,11 +45,11 @@ module Nydp
 
     SYMBOL_OPERATORS =
       [
-        [ /%/,      "percent-syntax"    ],
         [ /\!/,     "bang-syntax"       ],
         [ /::/,     "colon-colon-syntax"],
         [ /:/,      "colon-syntax"      ],
         [ /&/,      "ampersand-syntax"  ],
+        [ /%/,      "percent-syntax"    ],
         [ /\./,     "dot-syntax"        ],
         [ /\$/,     "dollar-syntax"     ],
         [ /->/,     "arrow-syntax"      ],
@@ -129,11 +129,11 @@ module Nydp
       fragments = [sym(:"string-pieces")]
       string_token = token_stream.next_string_fragment(open_delimiter, close_delimiter, INTERPOLATION_SIGN, INTERPOLATION_ESCAPES)
       raise "unterminated string" if string_token.nil?
-      fragments << Nydp::StringAtom.new(string_token.string, string_token)
+      fragments << Nydp::StringAtom.new(string_token.string)
       while !(string_token.is_a? StringFragmentCloseToken)
         fragments << expression(token_stream)
         string_token = token_stream.next_string_fragment('', close_delimiter, INTERPOLATION_SIGN, INTERPOLATION_ESCAPES)
-        fragments << Nydp::StringAtom.new(string_token.string, string_token)
+        fragments << Nydp::StringAtom.new(string_token.string)
       end
 
       if fragments.size == 2

data/lib/nydp/string_atom.rb

@@ -1,9 +1,8 @@
 module Nydp
   class StringAtom
-    attr_accessor :string, :token
-    def initialize string, token=nil
-      @string, @token = string, token
-    end
+    attr_accessor :string
+
+    def initialize string ; @string = string ; end
 
     def nydp_type  ; :string                                     ; end
     def to_s       ; string                                      ; end

data/lib/nydp/tokeniser.rb

@@ -3,7 +3,7 @@ require "strscan"
 module Nydp
   class Tokeniser
     BACKSLASH = /\\/.freeze
-    COMMENT   = /;.*$/.freeze
+    COMMENT   = /;;?.*$/.freeze
     QUOTE     = /"/.freeze
     PIPE      = /\|/.freeze
     LIST_PFX  = /[^\s()]*\(/.freeze
@@ -89,7 +89,7 @@ module Nydp
           @finished = true
           return nil
         elsif comment = s.scan(COMMENT)
-          tok = [:comment, comment[1..-1].strip]
+          tok = [:comment, comment.gsub(/^;;?\s*/, '').strip]
         elsif open_str = s.scan(QUOTE)
           tok = [:string_open_delim, open_str]
         elsif open_sym = s.scan(PIPE)

data/lib/nydp/truth.rb

@@ -3,14 +3,14 @@ require 'singleton'
 module Nydp
   class Truth
     include Singleton
-    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
-    def _nydp_get    a ; Nydp::T      ; end
-    def _nydp_set a, v ; Nydp::T      ; end
+    def init_with *; Nydp::T     ; end
+    def to_s       ; 't'         ; end
+    def inspect    ; 't'         ; end
+    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

data/lib/nydp/version.rb

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

data/spec/date_spec.rb

@@ -147,4 +147,18 @@ describe Nydp::Date do
     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
+
+  it "returns age relative to today" do
+    rd = Date.parse "2014-03-12"
+    nd = Nydp.r2n rd
+    allow(::Date).to receive_messages(today: Date.parse("2016-06-21"))
+    expect(nd._nydp_get(:age)).to eq({ years: 2, months: 3 })
+  end
+
+  it "returns a negative age relative to today for a date in the future" do
+    rd = Date.parse "2094-11-18"
+    nd = Nydp.r2n rd
+    allow(::Date).to receive_messages(today: Date.parse("2016-06-21"))
+    expect(nd._nydp_get(:age)).to eq({ years: -78, months: -5 })
+  end
 end

data/spec/embedded_spec.rb

@@ -46,10 +46,10 @@ describe Nydp::Parser do
   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)
+    x2 = Nydp::StringAtom.new(x2.string)
     x3 = sym('expr')
     x4 = Nydp::StringFragmentCloseToken.new(' a purple cow!',' a purple cow!')
-    x4 = Nydp::StringAtom.new(x4.string, x4)
+    x4 = Nydp::StringAtom.new(x4.string)
 
     expected = pair_list([x1,x2,x3,x4])
     actual   = parse_string "a fluffy bunny! ~expr a purple cow!"
@@ -64,10 +64,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)
+    x2 = Nydp::StringAtom.new(x2.string)
     x3 = pair_list [n1, n2, n3, n4]
     x4 = Nydp::StringFragmentCloseToken.new(' a purple cow!',' a purple cow!')
-    x4 = Nydp::StringAtom.new(x4.string, x4)
+    x4 = Nydp::StringAtom.new(x4.string)
 
     expected = pair_list([x1,x2,x3,x4])
     actual   = parse_string 'a fluffy bunny! ~(foo bar "an embedded bunny :)" zop) a purple cow!'
@@ -80,10 +80,10 @@ describe Nydp::Parser do
 
     s1 = sym('string-pieces')
     s2 = Nydp::StringFragmentToken.new('a rather ','a rather ~')
-    s2 = Nydp::StringAtom.new(s2.string, s2)
+    s2 = Nydp::StringAtom.new(s2.string)
     s3 = pair_list [e1, e2]
     s4 = Nydp::StringFragmentCloseToken.new(' bunny :)',' bunny :)"')
-    s4 = Nydp::StringAtom.new(s4.string, s4)
+    s4 = Nydp::StringAtom.new(s4.string)
 
     n1 = sym(:foo)
     n2 = sym(:bar)
@@ -92,10 +92,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)
+    x2 = Nydp::StringAtom.new(x2.string)
     x3 = pair_list [n1, n2, n3, n4]
     x4 = Nydp::StringFragmentCloseToken.new(' a purple cow!',' a purple cow!')
-    x4 = Nydp::StringAtom.new(x4.string, x4)
+    x4 = Nydp::StringAtom.new(x4.string)
 
     expected = pair_list([x1,x2,x3,x4])
     actual   = parse_string "a fluffy bunny! ~(foo bar \"a rather ~(describe bunny) bunny :)\" zop) a purple cow!"

data/spec/foreign_hash_spec.rb

@@ -84,5 +84,17 @@ describe Nydp::Hash do
         expect(vm.args.pop).to eq pair_list [sym("k0"), sym("k1")]
       end
     end
+
+    describe "hash-slice" do
+      it "returns a new hash containing only the given keys from the old hash" do
+        ahash[:k0] = 42
+        ahash[:k1] = 84
+        args       = [ahash, pair_list([sym("k0"), sym("k1")])]
+
+        Nydp::Builtin::HashSlice.instance.invoke vm, pair_list(args)
+
+        expect(vm.args.pop).to eq({ k0: 42, k1: 84 })
+      end
+    end
   end
 end

data/spec/hash_spec.rb

@@ -143,4 +143,26 @@ describe Nydp::Hash do
       end
     end
   end
+
+  describe "hash-slice" do
+    it "returns a new hash containing only the given keys from the old hash" do
+      hash = Nydp::Hash.new
+      sfoo = sym "foo"
+      sbar = sym "bar"
+      syak = sym "yak"
+      szeb = sym "zeb"
+
+      h = Nydp::Hash.new
+
+      h[sfoo] = 16
+      h[sbar] = 42
+      h[szeb] = 99
+
+      args       = [h, pair_list([sbar, syak, szeb])]
+
+      Nydp::Builtin::HashSlice.instance.invoke vm, pair_list(args)
+
+      expect(vm.args.pop).to eq({ sbar => 42, szeb => 99 })
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-12 00:00:00.000000000 Z
+date: 2018-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -113,6 +113,7 @@ files:
 - lib/lisp/tests/aif-examples.nydp
 - lib/lisp/tests/all-examples.nydp
 - lib/lisp/tests/ampersand-syntax-examples.nydp
+- lib/lisp/tests/andify-examples.nydp
 - lib/lisp/tests/any-examples.nydp
 - lib/lisp/tests/auto-hash-examples.nydp
 - lib/lisp/tests/best-examples.nydp
@@ -150,6 +151,7 @@ files:
 - lib/lisp/tests/list-gsub-examples.nydp
 - lib/lisp/tests/list-match-examples.nydp
 - lib/lisp/tests/list-tests.nydp
+- lib/lisp/tests/map-hash-examples.nydp
 - lib/lisp/tests/mapreduce-examples.nydp
 - lib/lisp/tests/mapsum-examples.nydp
 - lib/lisp/tests/none-examples.nydp
@@ -166,6 +168,7 @@ files:
 - lib/lisp/tests/returning-examples.nydp
 - lib/lisp/tests/rfnwith-tests.nydp
 - lib/lisp/tests/seqf-examples.nydp
+- lib/lisp/tests/set-difference-examples.nydp
 - lib/lisp/tests/set-intersection-examples.nydp
 - lib/lisp/tests/set-union-examples.nydp
 - lib/lisp/tests/settings-examples.nydp