nydp 0.1.14 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4934e2de2e4ae2558056bd67df1bfb85e8285d80
-  data.tar.gz: 591950ecbf8f0d76ef6e7afd79a48138bb7164b4
+  metadata.gz: 2e6fd1dc5fc3149b5f11a0ebdde15b780b18961e
+  data.tar.gz: f0f7f42ba740494b00425e3c5200acc12b9483c9
 SHA512:
-  metadata.gz: e3efdac8cdb5dfdc6cf6908e2d4950430769d888af64252a2153c05e06d25dff99a47be81d48e36478a1716327d2544ad78f76bff7a9a7f7e717b3ba564a4dda
-  data.tar.gz: 13cb1296116e684380b86b0f887b13ca2b22aef929ce933429ad74f5d49d40f151cd5095ecb96eb934e57d0c94755f3f9cc55eb9377f9b8dc749dd98f3d89cca
+  metadata.gz: 20c231e32e8a611446082c2a3eb144ac5782226dcb15f44224a0a77813577d77bf538cf65f6d897f824f0d2c0e7a8a9f8e054c9d84d6b60b06781ede72d1cb1e
+  data.tar.gz: ba1e3bc4f43c7c10bd8e06bd0ce45e513413b75a8213f0365abcb6389114e42ddf1e0c7746fbe78fc0829c5e711b57726ce11d6c11594b6f83fc674d8b372252

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

@@ -0,0 +1,30 @@
+
+(hash-set macs 'if (fn args
+                       (cond (no args) nil
+                             (cond (cdr args)
+                                   (cond (cddr args)
+                                         `(cond ,(car args) ,(cadr args) (if ,@(cddr args)))
+                                         `(cond ,(car args) ,(cadr args)))
+                                   (car args)))))
+
+(def map (f things)
+  ; transforms the list 'things by applying 'f to each item
+  ; returns the resulting list
+  (if (no things)
+      nil
+      (pair? things)
+      (cons (f (car things)) (map f (cdr things)))
+      (map f (list things))))
+
+(def hash-cons (h k v)
+  ; push 'v onto the value for 'k in 'h
+  (hash-set h k (cons v (hash-get h k))))
+
+(def rev-accum (things acc)
+  (cond (no things)
+        acc
+        (rev-accum (cdr things)
+                   (cons (car things)
+                         acc))))
+
+(def rev (things) (rev-accum things nil))

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

@@ -1,21 +1,31 @@
-((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))))
+((fn (dox examples 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     )
+       (hash-set hsh 'texts    texts    )
+       (hash-set hsh 'args     args     )
+       (hash-set hsh 'src      src      )
+       (hash-set hsh 'chapters chapters )
+       hsh)
+
+     (def dox-new (item)
+       (hash-cons dox (hash-get item 'name) item)
+       (dox-add-to-chapters (hash-get item 'chapters) item))
+
+     (def dox-add-doc (name what texts args src chapters)
+       (dox-new (dox-build (hash) name what texts args src chapters)))
 
      (def dox-add-to-chapter (chapter item)
-       (hash-set chapters
-                 item
-                 (cons item
-                       (hash-get chapters item))))
+       (hash-cons chapters chapter item))
+
+     (def dox-add-to-chapters (chapters item)
+       (cond chapters
+             (do (dox-add-to-chapter  (car chapters) item)
+                 (dox-add-to-chapters (cdr chapters) item))
+             item))
 
      (def dox-add-examples (name example-exprs)
-       (hash-set examples
-                 name
-                 (cons example-exprs
-                       (hash-get examples name))))
+       (hash-cons examples name example-exprs))
 
      (def dox-lookup (sym) (hash-get dox sym))
 
@@ -23,65 +33,68 @@
 
      (def dox-names () (hash-keys dox))
 
-     (def dox-what-is? (name)
-       (cond (dox? name)
-             (cadr (car (dox-lookup name)))))
-
-     (def dox-src (name)
-       (cond (dox? name)
-             (car (cddr (cddr (car (dox-lookup name)))))))
-
-     (def dox-examples (name)
-       (hash-get examples name))
-
-     (def dox-example-names () (hash-keys examples))
-
-     (def dox-arg-names (name)
+     (def dox-get-attr (name attr)
        (cond (dox? name)
-             (cadddr (car (dox-lookup name))))))
- (hash) (hash) (hash))
-
-(def isa-comment? (thing)
-  (cond (pair? thing)
-        (eq? (car thing) 'comment)))
-
-(def rev-accum (things acc)
-  (cond (no things)
-        acc
-        (rev-accum (cdr things)
-                   (cons (car things)
-                         acc))))
-
-(def rev (things) (rev-accum things nil))
-
-(def dox-gather-comments (body acc)
-  (cond (isa-comment? (car body))
-        (dox-gather-comments (cdr body)
-                             (cons (cadar body)
-                                   acc))
-        (list (rev acc) body)))
-
-(def define-mac-expr (name args documentation body)
+             (hash-get (car (dox-lookup name)) attr)))
+
+     (def dox-what-is?  (name) (dox-get-attr name 'what ))
+     (def dox-src       (name) (dox-get-attr name 'src  ))
+     (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) nil)
+
+(def filter-form (hsh form)
+  ; if the car of 'form is a key of 'hsh, add the cdr of 'form to the value of the key in 'hsh
+  ; otherwise add the form to the list whose key is nil
+  (cond (cond (pair? form)
+              (hash-key? hsh (car form)))
+      (hash-cons hsh (car form) (cdr form))
+      (hash-cons hsh        nil form))
+  hsh)
+
+(def rev-value-key (key keys old new)
+  (hash-set new key (rev (hash-get old key)))
+  (rev-value-keys keys old new))
+
+(def rev-value-keys (keys old new)
+  (cond keys
+        (rev-value-key (car keys) (cdr keys) old new)
+        new))
+
+(def rev-values (hsh)
+  (rev-value-keys (hash-keys hsh) hsh (hash)))
+
+(def filter-forms (hsh forms)
+  ; group forms by their first element, if the first element
+  ; is already a key in hsh, collect all other elements under key nil
+  (cond forms
+        (filter-forms (filter-form hsh (car forms)) (cdr forms))
+        (rev-values hsh)))
+
+(def build-def-hash (hsh)
+  (hash-set hsh 'comment nil)
+  (hash-set hsh 'chapter nil)
+  hsh)
+
+(def define-mac-expr (name args body-forms)
   ; used internally by 'mac
-  `(do (hash-set macs ',name (fn ,args ,@body))
+  `(do (hash-set macs ',name (fn ,args ,@(hash-get body-forms nil)))
        (dox-add-doc ',name
                     'mac
-                    ',documentation
+                    ',(map car (hash-get body-forms 'comment))
                     ',args
-                    '(mac ,name ,args ,@body))))
+                    '(mac ,name ,args ,@(hash-get body-forms nil)))))
 
 (hash-set macs 'mac
           (fn (name args . body)
-              (apply define-mac-expr
-                     name
-                     args
-                     (dox-gather-comments body))))
+              (define-mac-expr name args (filter-forms (build-def-hash (hash)) body))))
 
 (dox-add-doc 'mac
              'mac
              '("define a new global macro")
              '(name args . body)
-             (dox-src 'define-mac-expr))
+             '`(hash-set macs ',name (fn ,ooargs ,@body)))
 
 (dox-add-doc 'do
              'mac
@@ -91,18 +104,15 @@
 
 (mac def-assign args `(assign ,@args))
 
-(def define-def-expr (name args documentation body)
+(def define-def-expr (name args body-forms)
   ; used internally by 'def
-  `(do (def-assign ,name (fn ,args ,@body))
+  `(do (def-assign ,name (fn ,args ,@(hash-get body-forms nil)))
        (dox-add-doc ',name
                     'def
-                    ',documentation
+                    ',(map car (hash-get body-forms 'comment))
                     ',args
-                    '(def ,name ,args ,@body))))
+                    '(def ,name ,args ,@(hash-get body-forms nil)))))
 
 (mac def (name args . body)
   ; define a new function in the global namespace
-  (apply define-def-expr
-         name
-         args
-         (dox-gather-comments body)))
+  (define-def-expr name args (filter-forms (build-def-hash (hash)) body)))

data/lib/lisp/core-017-builtin-dox.nydp

@@ -1,9 +1,16 @@
-(dox-add-doc 'cons  'def '("with args a and b, returns a new cons cell, (a . b)") '(a b) nil)
-(dox-add-doc 'car   'def '("with args a, where a is a cons cell (x . y), return x." "Commonly used to get the first element of a list") '(a) nil)
-(dox-add-doc 'cdr   'def '("with args a, where a is a cons cell (x . y), return y." "Commonly used to get contents of a list, excluding the first element") '(a) nil)
+(dox-add-doc 'cons  'def '("with args a and b, returns a new cons cell, (a . b)")                                                                            '(a b) nil)
+(dox-add-doc 'car   'def '("with args a, where a is a cons cell (x . y), return x." "Commonly used to get the first element of a list")                      '(a) nil)
+(dox-add-doc 'cdr   'def '("with args a, where a is a cons cell (x . y), return y." "Commonly used to get contents of a list, excluding the first element")  '(a) nil)
 (dox-add-doc '+     'def '("with rest-args things, return the sum of the elements of things." "Will also increment dates and concatenate strings and lists") 'things nil)
-(dox-add-doc '-     'def '("return the result of subtracting all other args from the first arg." "(- a b c d) is equivalent to (- a (+ b c d))") 'things nil)
-(dox-add-doc '*     'def '("with rest-args things, return the product of the elements of things.")    'things nil)
-(dox-add-doc '/     'def '("return the result of dividing all other args into the first arg." "(/ a b c d) is equivalent to (/ a (* b c d))") 'things nil)
-(dox-add-doc '>     'def '("true if each arg is greater than the next arg")                           'things nil)
-(dox-add-doc '<     'def '("true if each arg is less than the next arg")                              'things nil)
+(dox-add-doc '-     'def '("return the result of subtracting all other args from the first arg." "(- a b c d) is equivalent to (- a (+ b c d))")             'things nil)
+(dox-add-doc '*     'def '("with rest-args things, return the product of the elements of things.")                                                           'things nil)
+(dox-add-doc '/     'def '("return the result of dividing all other args into the first arg." "(/ a b c d) is equivalent to (/ a (* b c d))")                'things nil)
+(dox-add-doc '>     'def '("true if each arg is greater than the next arg")                                                                                  'things nil)
+(dox-add-doc '<     'def '("true if each arg is less than the next arg")                                                                                     'things nil)
+(dox-add-doc 'mod   'def '("return the remainder after diving a by b")                                                                                       '(a b) nil)
+(dox-add-doc 'eval  'def '("evaluate the given lisp expression")                                                                                             '(expr) nil)
+(dox-add-doc 'hash  'def '("create a new Hash instance")                                                                                                     nil nil)
+(dox-add-doc 'apply 'def '("invoke f with args 'args")                                                                                                       '(f . args) nil)
+(dox-add-doc 'date  'def '("create a new date instance")                                                                                                     '(year month day) nil)
+(dox-add-doc 'error 'def '("raise an exception")                                                                                                             'args nil)
+(dox-add-doc 'parse 'def '("parse the given string and return the corresponding lisp objects")                                                               '(str) nil)

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

@@ -1,22 +1,28 @@
-(mac if args
-  ; with arguments a,         return a
-  ; with arguments a b,       return b if a is true, otherwise nil
-  ; with arguments a b c,     return b if a is true, otherwise return c
-  ; with arguments a b c d,   return b if a is true, otherwise return d if c is true, otherwise nil
-  ; with arguments a b c d e, return b if a is true, otherwise return d if c is true, otherwise e
-  ; and so on for subsequent arguments
-  (cond (no args) nil
-        (cond (cdr args)
-              (cond (cddr args)
-                    `(cond ,(car args) ,(cadr args) (if ,@(cddr args)))
-                    `(cond ,(car args) ,(cadr args)))
-              (car args))))
+(dox-add-doc 'if
+             'mac
+             '("with arguments a,         return a"
+               "with arguments a b,       return b if a is true, otherwise nil"
+               "with arguments a b c,     return b if a is true, otherwise return c"
+               "with arguments a b c d,   return b if a is true, otherwise return d if c is true, otherwise nil"
+               "with arguments a b c d e, return b if a is true, otherwise return d if c is true, otherwise e"
+               "and so on for subsequent arguments")
+             'args
+             '(cond (no args) nil
+                    (cond (cdr args)
+                          (cond (cddr args)
+                                `(cond ,(car twargs) ,(cadr twargs) (if ,@(cddr twargs)))
+                                `(cond ,(car twargs) ,(cadr twargs)))
+                          (car args)))
+             '(flow-control))
 
-(def map (f things)
-  ; transforms the list 'things by applying 'f to each item
-  ; returns the resulting list
-  (if (no things)
-      nil
-      (pair? things)
-      (cons (f (car things)) (map f (cdr things)))
-      (map f (list things))))
+(dox-add-doc 'map
+             'def
+             '("transforms the list 'things by applying 'f to each item"
+               "returns the resulting list")
+             '(f things)
+             '(if (no things)
+                  nil
+                  (pair? things)
+                  (cons (f (car things)) (map f (cdr things)))
+                  (map f (list things)))
+             '(list-manipulation))

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

@@ -176,11 +176,16 @@
                ,(build-hash-get-key:car rnames)
                ,value-expr)))
 
+(def hash-get-assignment (lookup value)
+  `(hash-set ,@lookup ,value))
+
 (mac = (name value)
   (if (isa 'symbol name)
       `(assign ,name ,value)
       (caris 'dot-syntax name)
-      (dot-syntax-assignment (cdr name) value)))
+      (dot-syntax-assignment (cdr name) value)
+      (caris 'hash-get name)
+      (hash-get-assignment (cdr name) value)))
 
 (mac def-assign args `(= ,@args))
 

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

@@ -11,7 +11,7 @@
             (zip (cdr a) (cdr b)))))
 
 (mac push (x things)
-  `(assign ,things (cons ,x ,things)))
+  `(= ,things (cons ,x ,things)))
 
 (def flatten (things)
      (let acc nil
@@ -286,7 +286,3 @@
 
 (def min things (best < things))
 (def max things (best > things))
-
-(def hash-cons (h k v)
-  ; push 'v onto the value for 'k in 'h
-  (= h.,k (cons v h.,k)))

data/lib/lisp/core-045-dox-utils.nydp

@@ -58,7 +58,7 @@ Examples for ~name
          (if (no infos)
              (p "No documentation for" ',name)
              (each info infos
-                   (p:apply dox-show-info info)))
+                   (p (dox-show-info info.name info.what info.texts info.args))))
          (let examples (dox-examples ',name)
            (if (no examples)
                (p "No examples for" ',name)

data/lib/lisp/core-080-pretty-print.nydp

@@ -83,7 +83,7 @@
 
 (def pp/find-breaks/mac (form)
   (if (eq? (dox-what-is? (car form)) 'mac)
-      (let arg-count (list-length:dox-arg-names:car form)
+      (let arg-count (list-length:dox-args:car form)
         (cons (firstn arg-count form)
               (map list (nthcdr arg-count form))))))
 

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

@@ -71,3 +71,9 @@
 (def seqf (start incr)
   (let i (or incr 1)
     (fn () (returning start (++ start i)))))
+
+(def mapply (f args)
+  ; like 'map, but assumes each item in 'args is a list
+  ; of parameters for 'f. Effectively, calls (apply f item)
+  ; for each item in 'args
+  (map λa(apply f a) args))

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

@@ -12,96 +12,100 @@
 (def this-is-an-undocumented-def (a b c)
   (baz a b c))
 
-(examples-for isa-comment?
-  ("identifies a comment"
-   (isa-comment? '(comment "yes, it is"))
-   t)
-
-  ("identifies a non-comment"
-   (isa-comment? "not this time")
-   nil))
-
-(examples-for dox-gather-comments
-  ("find no comments"
-   (dox-gather-comments '((this) (that)))
-   (nil ((this) (that))))
-
-  ("finds one comment"
-   (dox-gather-comments '((comment "hello") (this) (that)))
-   (("hello") ((this) (that))))
-
-  ("finds more comments"
-   (dox-gather-comments '((comment "hello")
-                          (comment "more details")
-                          (comment "very rigourous")
-                          (this)
-                          (that)))
-   (("hello" "more details" "very rigourous") ((this) (that)))))
-
-(examples-for dox-show-info
-  ("shows each item"
-   (dox-show-info "bingo"
-                  'def
-                  '("there was a farmer had a dog" "and Bingo was his name-o")
-                  '(count)
-                  '(def bingo (count) (times count (bark))))
-   "Function : bingo
-
-args : (count)
-
-there was a farmer had a dog
-and Bingo was his name-o
-
-source
-======
-\(def bingo (count)
-    (times count (bark)))
-"))
+(examples-for dox-lookup
+  ("finds name for a documented macro"
+   (hash-get (car:dox-lookup 'this-is-a-well-documented-macro) 'name)
+   this-is-a-well-documented-macro)
+
+  ("finds type for a documented macro"
+   (hash-get (car:dox-lookup 'this-is-a-well-documented-macro) 'what)
+   mac)
+
+  ("finds documentation for a documented macro"
+   (hash-get (car:dox-lookup 'this-is-a-well-documented-macro) 'texts)
+   ("documentation for me!"))
+
+  ("finds arg names for a documented macro"
+   (hash-get (car:dox-lookup 'this-is-a-well-documented-macro) 'args)
+   (a b c))
+
+  ("finds source code for a documented macro"
+   (hash-get (car:dox-lookup 'this-is-a-well-documented-macro) 'src)
+   (mac this-is-a-well-documented-macro (a b c)
+     `(foo ,a ,b ,c)))
+
+  ("finds name for an undocumented macro"
+   (hash-get (car:dox-lookup 'this-is-an-undocumented-macro) 'name)
+   this-is-an-undocumented-macro)
+
+  ("finds type for an undocumented macro"
+   (hash-get (car:dox-lookup 'this-is-an-undocumented-macro) 'what)
+   mac)
+
+  ("finds no documentation for an undocumented macro"
+   (hash-get (car:dox-lookup 'this-is-an-undocumented-macro) 'texts)
+   nil)
+
+  ("finds arg names for an undocumented macro"
+   (hash-get (car:dox-lookup 'this-is-an-undocumented-macro) 'args)
+   (a b c))
+
+  ("finds source code for an undocumented macro"
+   (hash-get (car:dox-lookup 'this-is-an-undocumented-macro) 'src)
+   (mac this-is-an-undocumented-macro (a b c)
+     `(baz ,a ,b ,c))))
 
 (examples-for dox-lookup
-  ("finds info for a documented macro"
-   (dox-lookup 'this-is-a-well-documented-macro)
-   ((this-is-a-well-documented-macro
-     mac
-     ("documentation for me!")
-     (a b c)
-     (mac this-is-a-well-documented-macro (a b c)
-       `(foo ,a ,b ,c)))))
-
-  ("finds info for an undocumented macro"
-   (dox-lookup 'this-is-an-undocumented-macro)
-   ((this-is-an-undocumented-macro
-     mac
-     nil
-     (a b c)
-     (mac this-is-an-undocumented-macro (a b c)
-       `(baz ,a ,b ,c)))))
-
-  ("finds info for a documented def"
-   (dox-lookup 'this-is-a-well-documented-def)
-   ((this-is-a-well-documented-def
-     def
-     ("documentation for me!")
-     (a b c)
-     (def this-is-a-well-documented-def (a b c)
-       (foo a b c)))))
-
-  ("finds info for an undocumented def"
-   (dox-lookup 'this-is-an-undocumented-def)
-   ((this-is-an-undocumented-def
-     def
-     nil
-     (a b c)
-     (def this-is-an-undocumented-def (a b c)
-       (baz a b c))))))
-
-(examples-for dox-arg-names
+  ("finds name for a documented def"
+   (hash-get (car:dox-lookup 'this-is-a-well-documented-def) 'name)
+   this-is-a-well-documented-def)
+
+  ("finds type for a documented def"
+   (hash-get (car:dox-lookup 'this-is-a-well-documented-def) 'what)
+   def)
+
+  ("finds documentation for a documented def"
+   (hash-get (car:dox-lookup 'this-is-a-well-documented-def) 'texts)
+   ("documentation for me!"))
+
+  ("finds arg names for a documented def"
+   (hash-get (car:dox-lookup 'this-is-a-well-documented-def) 'args)
+   (a b c))
+
+  ("finds source code for a documented def"
+   (hash-get (car:dox-lookup 'this-is-a-well-documented-def) 'src)
+   (def this-is-a-well-documented-def (a b c)
+     (foo a b c)))
+
+  ("finds name for an undocumented def"
+   (hash-get (car:dox-lookup 'this-is-an-undocumented-def) 'name)
+   this-is-an-undocumented-def)
+
+  ("finds type for an undocumented def"
+   (hash-get (car:dox-lookup 'this-is-an-undocumented-def) 'what)
+   def)
+
+  ("finds no documentation for an undocumented def"
+   (hash-get (car:dox-lookup 'this-is-an-undocumented-def) 'texts)
+   nil)
+
+  ("finds arg names for an undocumented def"
+   (hash-get (car:dox-lookup 'this-is-an-undocumented-def) 'args)
+   (a b c))
+
+  ("finds source code for an undocumented def"
+   (hash-get (car:dox-lookup 'this-is-an-undocumented-def) 'src)
+   (def this-is-an-undocumented-def (a b c)
+     (baz a b c))))
+
+
+(examples-for dox-args
   ("macro"
-   (dox-arg-names 'this-is-a-well-documented-macro)
+   (dox-args 'this-is-a-well-documented-macro)
    (a b c))
 
   ("function def"
-   (dox-arg-names 'this-is-a-well-documented-def)
+   (dox-args 'this-is-a-well-documented-def)
    (a b c)))
 
 (examples-for dox-src

data/lib/lisp/tests/filter-forms-examples.nydp

@@ -0,0 +1,46 @@
+(examples-for filter-forms
+  ("groups forms by their 'car if the 'car is a key in the given hash"
+   (let ff (filter-forms { car nil comment nil mac nil }
+                         '(let x 1
+                            ; first comment
+                            (mac push foo bar)
+                            (car that)
+                            ; another comment
+                            (car engine)
+                            (drive faster)
+                            (mac more macaroni)
+                            (car wheels)
+                            (mac and cheese)
+                            ; ok enough cheese
+                            (finish cheese)
+                            (car go)))
+     (list (hash-keys ff)
+           ff.car
+           ff.comment
+           ff.mac
+           (hash-get ff nil)))
+   ((car comment mac nil)
+    ((that) (engine) (wheels) (go))
+    (("first comment") ("another comment") ("ok enough cheese"))
+    ((push foo bar) (more macaroni) (and cheese))
+    (let x 1 (drive faster) (finish cheese))))
+
+
+
+  ("find no comments"
+   (hash-values (filter-forms { comment nil } '((this) (that))))
+   (nil ((this) (that))))
+
+  ("finds one comment"
+   (hash-values (filter-forms { comment nil }
+                              '((comment "hello") (this) (that))))
+   ((("hello")) ((this) (that))))
+
+  ("finds more comments"
+   (hash-values (filter-forms { comment nil }
+                               '((comment "hello")
+                                 (comment "more details")
+                                 (comment "very rigourous")
+                                 (this)
+                                 (that))))
+   ((("hello") ("more details") ("very rigourous")) ((this) (that)))))

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

@@ -8,3 +8,8 @@
                       { name "b" age  7 }
                       { name "c" age 12 }))
    29))
+
+(examples-for mapply
+  ("applies each list to the given function"
+   (mapply + '((1 2 3) (4 5 6) (7 8 9)))
+   (6 15 24)))

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

@@ -0,0 +1,25 @@
+(examples-for push
+  ("push a value onto the beginning of a list"
+   (let x nil
+     (push 'c x)
+     (push 'b x)
+     (push 'a x)
+     x)
+   (a b c))
+
+  ("push a value onto the beginning of a list stored in a hash"
+   (let x {}
+     (push 'c x.stuff)
+     (push 'b x.stuff)
+     (push 'a x.stuff)
+     (list (hash-keys x) x.stuff))
+   ((stuff) (a b c)))
+
+  ("push a value onto the beginning of a list using a hash-get expression"
+   (let x {}
+     (push 1 (hash-get x 'foo))
+     (push 2 (hash-get x 'foo))
+     (push 3 (hash-get x nil))
+     (push 4 (hash-get x nil))
+     (list (hash-keys x) x.foo (hash-get x nil)))
+   ((foo nil) (2 1) (4 3))))

data/lib/nydp/tokeniser.rb

@@ -27,7 +27,7 @@ module Nydp
 
     def next_string_fragment open_delimiter, close_delimiter, interpolation_sign, interpolation_escapes={ }
       s = @scanner
-      rep = "#{open_delimiter}"
+      rep = open_delimiter.to_s
       string = ""
       while (!no_more?)
         if esc = s.scan(/\\/)

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.1.14"
+  VERSION = "0.1.15"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 0.1.15
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-21 00:00:00.000000000 Z
+date: 2016-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,6 +86,7 @@ files:
 - bin/nydp-tests
 - lib/lisp/core-000.nydp
 - lib/lisp/core-010-precompile.nydp
+- lib/lisp/core-012-utils.nydp
 - lib/lisp/core-015-documentation.nydp
 - lib/lisp/core-017-builtin-dox.nydp
 - lib/lisp/core-020-utils.nydp
@@ -118,6 +119,7 @@ files:
 - lib/lisp/tests/empty-examples.nydp
 - lib/lisp/tests/error-tests.nydp
 - lib/lisp/tests/explain-mac-examples.nydp
+- lib/lisp/tests/filter-forms-examples.nydp
 - lib/lisp/tests/foundation-test.nydp
 - lib/lisp/tests/group-by-examples.nydp
 - lib/lisp/tests/hash-examples.nydp
@@ -131,6 +133,7 @@ files:
 - lib/lisp/tests/plus-plus-examples.nydp
 - lib/lisp/tests/pre-compile-examples.nydp
 - lib/lisp/tests/pretty-print-tests.nydp
+- lib/lisp/tests/push-examples.nydp
 - lib/lisp/tests/quasiquote-examples.nydp
 - lib/lisp/tests/range-examples.nydp
 - lib/lisp/tests/relative-months-examples.nydp