nydp 0.4.6 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: '06876fcb6832d6737b4763607cfe7b4c0ca003c3'
-  data.tar.gz: b45d30570c913940f93585241c1dad9cc71c5872
+SHA256:
+  metadata.gz: '0389044de6d7b6230da9315bc8dde967e1ddf8ed77df2b8ef4106ce9bfc3e93a'
+  data.tar.gz: 133567982e2fbb734ea429e98197e4b7d5bc49c2130f64ec630c095adcd1f250
 SHA512:
-  metadata.gz: d874e4fbbba55a5995f699451bbf305fe7667f4058cdab2e713fe64900bc96ed285fe5ae8d0c460c73001f0a44fb22699c634c2017a723e9c79d818779d38b7e
-  data.tar.gz: 5d5f3aeb4e7c0e65af1024990fdfa5f73a8f4657a06dfd11aaeec172709615a3879f0bdff0efd19475a223add58ee1dd6379951548979eda5b80f30861967e61
+  metadata.gz: 2516bbc0473796915710786bb8b43ac339df657438e5a35d8f8d38cb5a7b46c1663b09a8cea266369b168530b63a1f249daf882d2712cd8558febb167bc648ef
+  data.tar.gz: 2548a1e1259f053ff25bc490d13f44579720be5f0ea7954915917092a04d0619f0b014221f55ed6b1f86f5046f5a6a7244348ff4805a2282ece150c3993be71f

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

@@ -21,7 +21,9 @@
 
 (hash-set macs 'do
           (fn forms
-              `((fn nil ,@forms))))
+              (if (no (cdr forms))
+                  (car forms)
+                  `((fn nil ,@forms)))))
 
 ((fn (this-chapter-name chapters chapter-new chapter-build chapter-add-to-chapter)
      (assign chapters (hash))
@@ -169,10 +171,20 @@
         (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 filter-remove (key forms keyforms otherforms)
+  (cond forms
+        (cond (cond (pair? forms) (cond (pair? (car forms)) (eq? key (caar forms))))
+              (filter-remove key (cdr forms) (cons (car forms) keyforms) otherforms)
+              (filter-remove key (cdr forms) keyforms (cons (car forms) otherforms)))
+        (list (rev keyforms) (rev otherforms))))
+
+(assign DEF-FORMS '(comment chapter))
+
+(def build-def-hash ()
+  ((fn (h)
+       (map (fn (k) (hash-set h k nil)) DEF-FORMS)
+       h)
+   (hash)))
 
 (def dox-build-def-name (name) name)
 
@@ -188,7 +200,7 @@
 
 (hash-set macs 'mac
           (fn (name args . body)
-              (define-mac-expr name args (filter-forms (build-def-hash (hash)) body))))
+              (define-mac-expr name args (filter-forms (build-def-hash) body))))
 
 (dox-add-doc 'mac
              'mac
@@ -204,11 +216,15 @@
              '`((fn nil ,@args))
              '(nydp-core))
 
+;; override later to use '= instead of 'assign, giving us hash-assignment and other goodies for free
 (mac def-assign args `(assign ,@args))
 
 ;; used internally by 'def
 (def define-def-expr (name args body-forms)
-  `(do (def-assign ,name (fun ,args ,@(filter-comments (hash-get body-forms nil))))
+  `(do (def-assign ,name
+         ((fn (self-name)
+              (fun ,args ,@(filter-comments (hash-get body-forms nil))))
+          ',name))
        (dox-add-doc ',(dox-build-def-name name)
                     'def
                     ',(+ (fetch-and-clear-comments) (map car (hash-get body-forms 'comment)))
@@ -219,7 +235,7 @@
 ;; define a new function in the global namespace
 (mac def (name args . body)
   (chapter nydp-core)
-  (define-def-expr name args (filter-forms (build-def-hash (hash)) body)))
+  (define-def-expr name args (filter-forms (build-def-hash) body)))
 
 (mac comment (txt)
   (assign comments (cons txt comments))

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

@@ -46,6 +46,7 @@
                                      "with 1 arg, an integer less than arg"
                                      "with two args, an integer >= arg 0 and < arg 1")                                                                           'args                      nil '(math))
 (dox-add-doc 'random-string   'def '("return a random string of length 'len (default 10)")                                                                       '(len)                     nil '(string-manipulation))
+(dox-add-doc 'regexp          'def '("return a regular expression compiled from the given string")                                                               '(str)                     nil '(string-manipulation))
 (dox-add-doc 'to-string       'def '("return a human-readable string representation of 'arg")                                                                    '(arg)                     nil '(string-manipulation))
 (dox-add-doc 'string-length   'def '("return the length of 'arg")                                                                                                '(arg)                     nil '(string-manipulation))
 (dox-add-doc 'string-replace  'def '("replace 'pattern with 'replacement in 'str")                                                                               '(pattern replacement str) nil '(string-manipulation))

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

@@ -97,14 +97,14 @@ scoping, assignment, anonymous functions and more...")
 ;; like 'let, but creates and assigns multiple local variables.
 ;; for example, "(with (a 1 b 2) (+ a b))" returns 3
 (mac with (parms . body)
-     `((fun ,(map car (pairs parms))
-            ,@body)
-       ,@(map cadr (pairs parms))))
+  `((fun ,(map car (pairs parms))
+         ,@body)
+    ,@(map cadr (pairs parms))))
 
-;; same as ( (fn (var) body) val ) -> ie create a lexical scope
+;; create a lexical scope
 ;; where val is assigned to var, execute 'body in that scope
 (mac let (var val . body)
-  `(with (,var ,val) ,@body))
+  `((fun (,var) ,@body) ,val))
 
 (mac rfn (name parms . body)
   ; creates a named, locally-scoped function
@@ -119,12 +119,12 @@ scoping, assignment, anonymous functions and more...")
   ; same as 'rfn, but using the name 'self
   `(rfn self ,parms ,@body))
 
+;; a mix of rfn and with; creates a locally-scoped named function with
+;; the given parameter names, and invokes it with the given parameter
+;; values. It is possible to reference the function by its name from
+;; within the function (to pass as an argument or for recursive
+;; invocation)
 (mac rfnwith (name params . body)
-  ; a mix of rfn and with; creates a locally-scoped named function with
-  ; the given parameter names, and invokes it with the given parameter
-  ; values. It is possible to reference the function by its name from
-  ; within the function (to pass as an argument or for recursive
-  ; invocation)
   (let ppairs (pairs params)
     `(let ,name nil
        (assign ,name (fun ,(map car ppairs) ,@body))
@@ -148,9 +148,9 @@ scoping, assignment, anonymous functions and more...")
   (def reset-uniq-counter ()
     (assign uniq-counter 0)))
 
+;; creates a lexical scope with a unique symbol assigned to
+;; each variable in 'vars ; executes the 'body.
 (mac w/uniq (vars . body)
-  ; creates a lexical scope with a unique symbol assigned to
-  ; each variable in 'vars ; executes the 'body.
   (if (pair? vars)
       `(with ,(apply + (map (fn (n) `(,n (uniq ',n))) vars))
              ,@body)
@@ -228,25 +228,46 @@ scoping, assignment, anonymous functions and more...")
 ;; 'place is ((ampersand-syntax || (dot-syntax key subkey)) (expr))
 ;; we need (hash-set (hash-get (expr) 'key) 'subkey (val))
 (def ampersand-expression-assignment (place value)
-  (with (k   (cadr:cdar place)
-         hsh (cadr place))
-    (if (caris 'dot-syntax k)
-        (dot-syntax-assignment (cons hsh (cdr k)) value)
-        `(hash-set ,hsh ',k ,value))))
+  (let k (cadr:cdar place)
+    (let hsh (cadr place)
+      (if (caris 'dot-syntax k)
+          (dot-syntax-assignment (cons hsh (cdr k)) value)
+          `(hash-set ,hsh ',k ,value)))))
+
+;; used internally by 'destructuring-assign
+(def destructuring-assigns (names values acc)
+  (if names
+      (if (pair? names)
+          (destructuring-assigns
+            (cdr names)
+            `(cdr ,values)
+            (cons `(= ,(car names) (car ,values)) acc))
+          (cons `(= ,names ,values) acc))
+      (rev acc)))
+
+;; used internally by 'assign-expr
+(def destructuring-assign (name value)
+  (w/uniq destructuring-assign
+          `(let ,destructuring-assign ,value
+             ,@(destructuring-assigns name destructuring-assign))))
 
 ;; used internally by '= macro
-(def assign-expr (name value)
-  (if (isa 'symbol name)
-      `(assign ,name ,value)
-      (caris 'dot-syntax name)
-      (dot-syntax-assignment (cdr name) value)
-      (caris 'hash-get name)
-      (hash-get-assignment (cdr name) value)
-      (ampersand-expression? name)
-      (ampersand-expression-assignment name value)
-      (caris 'at-syntax name)
-      `(hash-set @ ',(caddr name) ,value)
-      (error "unknown assignment to place: ~(inspect name)")))
+(def assign-expr (nv)
+  (let name  (car nv)
+    (let value (cadr nv)
+      (if (isa 'symbol name)
+          `(assign ,name ,value)
+          (caris 'dot-syntax name)
+          (dot-syntax-assignment (cdr name) value)
+          (caris 'hash-get name)
+          (hash-get-assignment (cdr name) value)
+          (ampersand-expression? name)
+          (ampersand-expression-assignment name value)
+          (caris 'at-syntax name)
+          `(hash-set @ ',(caddr name) ,value)
+          (pair? name)
+          (destructuring-assign name value)
+          (error "unknown assignment to place: " (inspect name))))))
 
 ;; generic assignment which unlike builtin 'assign, knows how to assign
 ;; to hash keys
@@ -255,10 +276,18 @@ scoping, assignment, anonymous functions and more...")
 ;; (= h.j.k (val))                 => (hash-set (hash-get h 'j) 'k (val))
 ;; (= (&key (expr)) (val))         => (hash-set (expr) 'key (val))
 ;; (= (&j.k (expr)) (val))         => (hash-set (hash-get (expr) 'j) 'k (val))
-(mac = (name value . more)
-  (if more
-      `(do ,(assign-expr name value) (= ,@more))
-      (assign-expr name value)))
+(mac = assignments
+  `(do ,@(map assign-expr (pairs assignments))))
+
+;; like 'let, but creates and assigns multiple local variables.
+;; for example, "(with (a 1 b 2) (+ a b))" returns 3
+;;
+;; later variables can references earlier ones:
+;; (with (a 1 b 2 c (+ a b)) (list a b c)) ;; returns (1 2 3)
+(mac with (assignments . body)
+  `((fun ,(map car (pairs assignments))
+     (= ,@assignments)
+     ,@body) nil))
 
 ;; quiet assignment ; like =, but expression returns nil
 (mac #= (name value)
@@ -334,6 +363,12 @@ scoping, assignment, anonymous functions and more...")
 (mac aif (expr . body)
   `(ifv it ,expr ,@body))
 
+;; returns the n-th item in the list 'things
+(def nth (n things)
+  (if (eq? n 0)
+      (car things)
+      (nth (- n 1) (cdr things))))
+
 (def destructure/with (var args n)
   ; provides the argument expression to 'with when
   ; destructuring arguments are present in a 'fun definition
@@ -342,33 +377,51 @@ scoping, assignment, anonymous functions and more...")
       args
       `(,args (nthcdr ,n ,var))))
 
-(def destructure/build (given-args new-args body)
-  ; used internally by 'fun
+;; issue a warning if any arg name is the name of a macro
+(def fun/approve-arg-names (orig args body)
+  (if (pair? 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 " and body " body))))
+
+;; used internally by 'fun
+(def destructure/build (given-args new-args body next)
   (if (pair? given-args)
       (if (sym? (car given-args))
           (destructure/build (cdr given-args)
                              (cons (car given-args) new-args)
-                             body)
+                             body
+                             next)
           (w/uniq destructure
                   (destructure/build (cdr given-args)
                                      (cons destructure new-args)
-                                     `((with ,(destructure/with destructure (car given-args) 0) ,@body)))))
-      `(fn ,(rev new-args given-args) ,@body)))
+                                     `((with ,(destructure/with destructure (car given-args) 0) ,@body))
+                                     next)))
+      (next (rev new-args given-args) body)))
 
+(def fun/destructuring-args (args body next)
+  (fun/approve-arg-names args args body)
+  (destructure/build args nil body next))
 
-(def fun/approve-arg-names (orig args body)
-  (if (pair? 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 " and body " body))))
+(assign fun/expanders
+        (list
+         (cons 'destructuring-args fun/destructuring-args)
+         (cons 'core-builder       (fn (args body next) `(fn ,args ,@body)))))
+
+(def fun/expand (args body expanders)
+  (if expanders
+      ((cdar expanders)
+       args
+       body
+       (fn (a b)
+           (fun/expand a b (cdr expanders))))))
 
 ;; build a 'fn form, changing 'args and 'body to
 ;; properly handle any destructuring args if present
 (mac fun (args . body)
-  (fun/approve-arg-names args args body)
-  (destructure/build args nil body))
+  (fun/expand args body fun/expanders))
 
 ;; assign (f place) to place
 (mac zap (f place . args)

data/lib/lisp/core-035-flow-control.nydp

@@ -13,9 +13,9 @@
   `(ensuring (fn () ,protection)
              (fn ()    ,@body)))
 
+;; tests 'test, as long as 'test is non-nil,
+;; repeatedly executes 'body
 (mac while (test . body)
-  ; tests 'test, as long as 'test is non-nil,
-  ; repeatedly executes 'body
   (w/uniq (rfname pred)
     `(rfnwith ,rfname (,pred ,test)
         (when ,pred
@@ -65,13 +65,31 @@
                  (let ,v (hash-get ,h ,k)
                    (or ,v (returnlet ,v ,val (hash-set ,h ,k ,v)))))))
 
+;; same as 'def, but caches the result, keyed on args, so for a given set of args the result
+;; is only ever calculated once
+;;
+;; WARNING: in current incarnation, won't work with destructuring args
 (mac defmemo (name args . body)
-  ; same as 'def, but caches the result, keyed on args, so for a given set of args the result
-  ; is only ever calculated once
-  (let forms (filter-forms (build-def-hash (hash)) body)
+  (let forms (filter-forms (build-def-hash) body)
     (w/uniq h
             `(let ,h (hash)
                (def ,name ,args
                  ,@(map (fn (c) (cons 'comment c)) forms.comment)
                  ,@(map (fn (c) (cons 'chapter c)) forms.chapter)
                  (cache-get ,h (list ,@args) (do ,@(hash-get forms nil))))))))
+
+;; memoises a function expression
+;; args: the function arguments
+;; body: a list of function body expressions
+;; next: a function to assemble a function expression from 'args and 'body
+;; returns whatever 'next returns, where 'body is memoised based on the value of 'args
+(def memoise (args body next)
+  (let (memo newbody) (filter-remove '#memoise body)
+    (if memo
+        (w/uniq h
+                `(let ,h (hash) ,(next args `((cache-get ,h (list ,@args) (do ,@newbody))))))
+        (next args body))))
+
+(assign fun/expanders
+        (cons
+         (cons 'memoise memoise) fun/expanders))

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

@@ -101,3 +101,13 @@
                (dp ,@(cdr args))
                ,nearg)))
       nil))
+
+;; returns a function that returns a number sequence. Example:
+;; (let c (counter)
+;;   (p (c))           ;;=> 0
+;;   (p (c))           ;;=> 1
+;;   (p (c)))          ;;=> 2
+;;
+(def counter ()
+  (let i -1
+    (fn () (++ i))))

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

@@ -57,20 +57,21 @@
 (def reject (f things)
   (collect !f things))
 
-;; returns the n-th item in the list 'things
-(def nth (n things)
-  (if (eq? n 0)
-      (car things)
-      (nth (- n 1) (cdr things))))
+(def each/build-expression (var things body othervars otherparams)
+  (w/uniq (xs c)
+          `(rfnwith ,c (,xs ,things ,@othervars)
+               (if (pair? ,xs)
+                   (let ,var (car ,xs)
+                     ,@body
+                     (,c (cdr ,xs) ,@otherparams))))))
 
 ;; repeatedly assigns an element of 'things to 'var,
 ;; and executes 'body each time
 (mac each (var things . body)
-  (w/uniq (xs c)
-          `(rfnwith ,c (,xs ,things)
-               (if (pair? ,xs)
-                   (do (let ,var (car ,xs) ,@body)
-                       (,c (cdr ,xs)))))))
+  (each/build-expression var things body))
+
+(mac each-with-index (ivar var things . body)
+  (each/build-expression var things body `(,ivar 0) `((+ ,ivar 1))))
 
 (def reduce (f things)
   (rfnwith rd (acc (car things) list (cdr things))
@@ -243,7 +244,6 @@
 
 ;; 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)))
+  (let c (counter)
+    (map (fn (thing) (f thing (c)))
          things)))

data/lib/lisp/core-070-prefix-list.nydp

@@ -29,5 +29,5 @@
 (define-prefix-list-macro "^λ.*" vars expr
   ;; allows (map λa(upcase a.name) people)
   ;; as shortcut for (map (fn (a) (upcase a.name)) people)
-  (let var-list (map sym (collect !empty? (cdr:string-split vars)))
+  (let var-list (map sym (collect !empty? (cdr:string-split vars "")))
     `(fn ,var-list ,expr)))

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

@@ -43,6 +43,8 @@
   (fn (thing)
       (if (isa 'string thing)
           (pp/esc-str-literal thing)
+          (isa 'symbol thing)
+          "\~|~(just thing)|"
           "\~~(pp thing)")))
 
 (def pp/string-pieces (pp things) "\"~(joinstr "" (map (pp/string-piece pp) things))\"")

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

@@ -20,25 +20,25 @@
 
 (examples-for destructure/build
   ("with no args"
-   (destructure/build nil nil '(x))
+   (destructure/build nil nil '(x) (fn (a b) `(fn ,a ,@b)))
    (fn nil x))
 
   ("with one arg"
-   (destructure/build '(a) nil '(x))
+   (destructure/build '(a) nil '(x) (fn (a b) `(fn ,a ,@b)))
    (fn (a) x))
 
   ("with one rest-arg"
-   (destructure/build 'args nil '(x))
+   (destructure/build 'args nil '(x) (fn (a b) `(fn ,a ,@b)))
    (fn args x))
 
   ("with one destructuring arg"
    (do (reset-uniq-counter)
-        (destructure/build '((a b)) nil '(x)))
+        (destructure/build '((a b)) nil '(x) (fn (a b) `(fn ,a ,@b))))
    (fn (destructure-1) (with (a (nth 0 destructure-1) b (nth 1 destructure-1)) x)))
 
   ("with complex args"
    (do (reset-uniq-counter)
-       (destructure/build '(a (b c) (d (e f)) g . h) nil '(x)))
+       (destructure/build '(a (b c) (d (e f)) g . h) nil '(x) (fn (a b) `(fn ,a ,@b))))
    (fn (a destructure-1 destructure-2 g . h)
        (with (d     (nth 0 destructure-2)
               (e f) (nth 1 destructure-2))
@@ -49,12 +49,23 @@
 (examples-for fun
   ("complete expansion, handles recursive destructures"
    (do (reset-uniq-counter)
-       (pre-compile '(fun ((a (b c)) d . e) x)))
+       (pre-compile '(fun ((a (b c)) d . e) (do-the-thing a b c d e))))
    (fn (destructure-1 d . e)
        ((fn (a destructure-2)
-            ((fn (b c) x)
-             (nth 0 destructure-2)
-             (nth 1 destructure-2))) (nth 0 destructure-1) (nth 1 destructure-1))))
+            ((fn (b c)
+                 ((fn nil
+                      (assign b (nth 0 destructure-2))
+                      (assign c (nth 1 destructure-2))))
+                 ((fn nil
+                      (assign a (nth 0 destructure-1))
+                      ((fn (destructuring-assign-3)
+                           (assign b (car destructuring-assign-3))
+                           (assign c (car (cdr destructuring-assign-3))))
+                       (nth 1 destructure-1))))
+                 (do-the-thing a b c d e))
+             nil))
+        nil)))
+
 
   ("nested improper arguments"
    (let (a (b c . d) e) (list "A" (list "B" "C" "D0" "D1" "D2") "E")
@@ -79,3 +90,24 @@
           (let (g (h (i j) k)) (list "w" (list "o" (list "r" "l") "d"))
             (string-pieces a b c d e f g h i j k)))
    "hello world"))
+
+(examples-for =
+  ("destructures LHS"
+   (let a 1
+     (let b 2
+       (let c 3
+         (let d 4
+           (let e 5
+             (= (a (b e) c . d) (list 'this '(that those) 'another 11 22 33))
+             (list a b c d e))))))
+   (this that another (11 22 33) those)))
+
+(examples-for with
+  ("destructures its args, also allows references to earlier args"
+   (with ((a (b . c) d . e) '(1 (2 3 4 5) 6 7 8 9)
+          x         a
+          y         c
+          z         (fn (n) (if (eq? n 1) 1 (* n (z (- n 1)))))
+          g         (z 6))
+         (list a b c d e x y g))
+   (1 2 (3 4 5) 6 (7 8 9) 1 (3 4 5) 720)))

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

@@ -2,3 +2,8 @@
   ("iterates over each item in list"
    (let acc 0 (each x '(1 2 3 4) (assign acc (+ x acc))) acc)
    10))
+
+(examples-for each-with-index
+  ("iterates over each item in list"
+   (returnlet acc nil (each-with-index i x '(a b c d) (push (list i x) acc)))
+   ( (3 d) (2 c) (1 b) (0 a) )))

data/lib/lisp/tests/explain-mac-examples.nydp

@@ -13,7 +13,7 @@
 
   ("expands thrice for n = 3"
    (explain-mac 3 '(afn (a) (let b (+ 2 a) (* b b))))
-   (with (self nil) (assign self (fn (a) (let b (+ 2 a) (* b b))))))
+   ((fun (self) (assign self (fn (a) (let b (+ 2 a) (* b b))))) nil))
 
   ("expands four times for n = 4"
    (explain-mac 4 '(afn (a) (let b (+ 2 a) (* b b))))

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

@@ -1,3 +1,18 @@
+(examples-for filter-remove
+  ("removes (memoise) from a list of forms"
+   (filter-remove 'memoise '((trace)
+                             ;; this is a comment
+                             (memoise)
+                             (let x a
+                               (+ x b)
+                               (bingo dingbat))))
+   (((memoise))
+    ((trace)
+     (comment "this is a comment")
+     (let x a
+       (+ x b)
+       (bingo dingbat))))))
+
 (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 }

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

@@ -70,6 +70,10 @@
    (parse-in-string (joinstr "" (list "hello, " '~ "(world), take me to your " '~ "dealer please")))
    (string-pieces "hello, " (world) ", take me to your " dealer " please"))
 
+  ("parses a plain string whose entire content is a single interpolation"
+   (parse-in-string (joinstr "" (list '~ "(hello world)")))
+   (hello world))
+
   ("parses a plain string of html text with interpolations"
    (parse-in-string "<div id='content_item_~~{id}'><label>~~{data-name-1}</label> ~~{data-text-1}</div>")
    (string-pieces "<div id='content_item_" (brace-list id) "'><label>" (brace-list data-name-1) "</label> " (brace-list data-text-1) "</div>"))

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

@@ -279,7 +279,7 @@ toto")
 
   ("special syntax"
    (pp '(string-pieces "hello " (bang-syntax || (dot-syntax x y (ampersand-syntax foo bar))) " and welcome to " (prefix-list "%%" (a b c d)) " and friends!"))
-   "\"hello ~~!x.y.foo&bar and welcome to ~~%%(a b c d) and friends!\"")
+   "\"hello ~~|!x.y.foo&bar| and welcome to ~~%%(a b c d) and friends!\"")
 
   ("percent-syntax"
    (pp '(percent-syntax || (dot-syntax x y)))

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

@@ -55,6 +55,10 @@ and args (\"world\" 36 6)"
    (collect !empty? (string-split "word"))
    ("w" "o" "r" "d"))
 
+  ("splits on regexp"
+   (string-split "hello, darkness ; my old friend\nI've come : to talk - with you again..." (regexp "\[\\n;:\\-,\]"))
+   ("hello" " darkness " " my old friend" "I've come " " to talk " " with you again..."))
+
   ("returns empty leading, internal, and trailing segments"
    (string-split "and" "and")
    ("" ""))

data/lib/nydp/builtin/regexp.rb

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

data/lib/nydp/builtin/string_split.rb

@@ -3,7 +3,9 @@ class Nydp::Builtin::StringSplit
 
   def builtin_invoke vm, args
     target    = args.car.to_s
-    separator = args.cdr.car.to_s
+    separator = args.cdr.car
+    separator = separator.to_s unless separator.is_a? Regexp
+
     result    = target.split separator, -1
 
     vm.push_arg Nydp::Pair.from_list result

data/lib/nydp/core.rb

@@ -59,6 +59,7 @@ module Nydp
       Symbol.mk("handle-error"     , ns).assign(Nydp::Builtin::HandleError.instance)
       Symbol.mk("parse-in-string"  , ns).assign(Nydp::Builtin::ParseInString.instance)
       Symbol.mk("random-string"    , ns).assign(Nydp::Builtin::RandomString.instance)
+      Symbol.mk("regexp"           , ns).assign(Nydp::Builtin::Regexp.instance)
       Symbol.mk("to-string"        , ns).assign(Nydp::Builtin::ToString.instance)
       Symbol.mk("to-integer"       , ns).assign(Nydp::Builtin::ToInteger.instance)
       Symbol.mk("string-length"    , ns).assign(Nydp::Builtin::StringLength.instance)

data/lib/nydp/date.rb

@@ -29,9 +29,9 @@ module Nydp
     def <=> other ; is_date?(other) && ruby_date <=> other.ruby_date ; end
     def eql?    d ; self == d                                        ; end
     def hash      ; ruby_date.hash                                   ; end
-    def is_date? other ; other.is_a? Nydp::Date                                               ; end
-    def -        other ; r2n(ruby_date - (is_date?(other) ? other.ruby_date : other))         ; end
-    def +          int ; int.is_a?(Fixnum) ? r2n(ruby_date + int) : r2n(change(*int.to_ruby)) ; end
+    def is_date? other ; other.is_a? Nydp::Date                                                ; end
+    def -        other ; r2n(ruby_date - (is_date?(other) ? other.ruby_date : other))          ; end
+    def +          int ; int.is_a?(Integer) ? r2n(ruby_date + int) : r2n(change(*int.to_ruby)) ; end
 
     @@pass_through = %i{ monday? tuesday? wednesday? thursday? friday? saturday? sunday? }
     @@keys = Set.new %i{

data/lib/nydp/function_invocation.rb

@@ -39,7 +39,7 @@ module Nydp
         @expr.map { |x| x.lexical_reach n}.max
       end
 
-      def inspect ; @expr.map { |x| x.inspect }.join ' '  ; end
+      def inspect ; @expr.map { |x| x.inspect }.join(' ') ; end
       def source  ; @source       ; end
       def to_s    ; source.to_s   ; end
     end

data/lib/nydp/helper.rb

@@ -83,7 +83,7 @@ module Nydp
 
     def literal? expr
       case expr
-      when String, Float, Integer, Fixnum, Nydp::Symbol, Nydp::Truth, Nydp::Nil
+      when String, Float, Integer, Integer, Nydp::Symbol, Nydp::Truth, Nydp::Nil
         true
       else
         false

data/lib/nydp/parser.rb

@@ -131,14 +131,16 @@ 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 << string_token.string
+      fragments << string_token.string if 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 << string_token.string
+        fragments << string_token.string if string_token.string != ""
       end
 
-      if fragments.size == 2
+      if fragments.size == 1
+        return ""
+      elsif fragments.size == 2
         return fragments[1]
       else
         return Pair.from_list fragments

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.4.6"
+  VERSION = "0.5.0"
 end

data/spec/pair_spec.rb

@@ -18,7 +18,9 @@ describe Nydp::Pair do
 
   describe :== do
     it "should be true for two empty lists" do
-      expect(Nydp::Pair.new(NIL, NIL)).to eq Nydp::Pair.new(NIL, NIL)
+      expect(Nydp::Pair.new(Nydp::NIL, Nydp::NIL)).to eq Nydp::Pair.new(Nydp::NIL, Nydp::NIL)
+
+      expect(Nydp::Pair.new(nil, nil)).to eq Nydp::Pair.new(nil, nil)
     end
 
     it "there is no empty list, only NIL" do

data/spec/parser_spec.rb

@@ -141,8 +141,8 @@ describe Nydp::Parser do
     parsed = parse("foo.2:3:4")
     expect(parsed.inspect).to eq "(colon-syntax (dot-syntax foo 2) 3 4)"
 
-    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]
+    expect(parsed.map &:class).to eq [Nydp::Symbol, Nydp::Pair, Integer, Integer]
+    expect(parsed.cdr.car.map &:class).to eq [Nydp::Symbol, Nydp::Symbol, Integer]
   end
 
   it "should handle prefix and postfix syntax also" do
@@ -263,7 +263,7 @@ describe Nydp::Parser do
   it "parses a string with a simple interpolation" do
     str = "foo "
     empty = ""
-    expect(parse '"foo ~foo"').to eq pair_list([string_pieces, str, foo, empty])
+    expect(parse '"foo ~foo"').to eq pair_list([string_pieces, str, foo])
   end
 
   it "parses a string with a more complex interpolation" do
@@ -284,7 +284,7 @@ describe Nydp::Parser do
 
   it "parses a string with only an interpolation" do
     empty = ""
-    expect(parse '"~foo"').to eq pair_list([string_pieces, empty, foo, empty])
+    expect(parse '"~foo"').to eq foo
   end
 
   it "should even parse comments" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.5.0
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-05 00:00:00.000000000 Z
+date: 2021-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -195,6 +195,7 @@ files:
 - lib/nydp/builtin/quit.rb
 - lib/nydp/builtin/rand.rb
 - lib/nydp/builtin/random_string.rb
+- lib/nydp/builtin/regexp.rb
 - lib/nydp/builtin/ruby_wrap.rb
 - lib/nydp/builtin/script_run.rb
 - lib/nydp/builtin/set_intersection.rb
@@ -282,8 +283,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A civilised yet somewhat dangerous kind of Lisp for a new generation