nydp 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab2e8ff02992658d66f96d3744cf872ece5e0c6c
-  data.tar.gz: ca9cb9b175abd201e722d7f6a60a334d164bb442
+  metadata.gz: 8ca4e399a839f5396035c2e8fe863c35e6c5acc4
+  data.tar.gz: 0e1ae8034c02c3d2401b97082d949bb29345ea5b
 SHA512:
-  metadata.gz: 31f1534694189aaec724cf8f49c1de8a98c07c50d2a94fef0737d331f8f11b054d860c64fed579365f4715cb8c6b8f3dce8de896e243ebf577aa8dc826e72d03
-  data.tar.gz: e93101eeae01cbed4c07a051de5ff7bba66b9962e92636c349c934cb7f788e6c322b3c00a64c348bdbe027c64ae67e80e67b5eac44148d851d8e37f34669e966
+  metadata.gz: 9bf68cd0b9627cf49ea2ddeb0f8ef53344b04576ecd5204dd04b943683b9b2610ba422c83d1ece2a9dc7b89968e2bfa251accad3e2bb9a450539160d660979c2
+  data.tar.gz: 2b40296df57b45e4d9e8be8f73aeecf38c2af80ac67d6da64407d57e69850c99820f582f14be8aa7f459ddc84e21cac6fbfa85759bed549b18474a6699f1524a

data/README.md

@@ -46,7 +46,7 @@ Suppose you want to invoke the function named `question` with some arguments. Do
 ```ruby
 ns     = Nydp.build_nydp     # keep this for later re-use, it's expensive to set up
 
-answer = Nydp.apply_function ns, :question, :life, ["The Universe" and(everything)]
+answer = Nydp.apply_function ns, :question, :life, ["The Universe", and_also(everything)]
 
 ==> 42
 ```
@@ -55,7 +55,6 @@ answer = Nydp.apply_function ns, :question, :life, ["The Universe" and(everythin
 
 You can maintain multiple `ns` instances without mutual interference. In other words, assigning global variables while one `ns` is in scope will not affect the values of variables in any other `ns` (unless you've specifically arranged it to be so by duplicating namespaces or some such sorcery).
 
-
 ## Different from Arc :
 
 #### 1. Macro-expansion runs in lisp
@@ -175,8 +174,6 @@ nydp > { a 1 b (author-name) }
 
 ```
 
-
-
 #### 4. Sensible, nestable string interpolation
 
 The parser detects lisp code inside strings. When this happens, instead of emitting a string literal, the parser emits a form whose car is the symbol `string-pieces`.
@@ -220,18 +217,6 @@ inside interpolations and report them correctly.
 Sorry. While technically possible ... why bother?
 
 
-#### 6. No argument destructuring
-
-However, this doesn't need to be built-in, it can be done with macros alone. On the other hand, "rest" arguments are implicitly available using the same syntax as Arc uses:
-
-```lisp
-(def fun (a b . others) ...)
-```
-
-In this example, `others` is either nil, or a list containing the third and subsequent arguments to the call to `fun`. For many examples of this kind of invocation, see [invocation-tests](lib/lisp/tests/invocation-tests.nydp) in the `tests` directory.
-
-
-
 ## Besides that, what can Nydp do?
 
 #### 1. Functions and variables exist in the same namespace.
@@ -267,7 +252,33 @@ nydp> (foo)
 ==> nil
 ```
 
-#### 6. Basic error handling
+#### 6. Argument destructuring
+
+This is not built-in to the language, but is available via the 'fun macro. Use 'fun as a drop-in replacement for 'fn and you get destructuring.
+
+```lisp
+(def funny (a (b c) . others)
+     xxx)
+```
+
+Equivalent to, and effectively pre-compiled to:
+
+```lisp
+(def funny (a d . others)
+     (with (b (nth 0 d)
+            c (nth 1 d))
+       xxx))
+```
+
+Note that `d` in this example will in real-life be a gensym and will not clobber your existing namespace.
+
+In this example, `others` is either nil, or a list containing the third and subsequent arguments to the call to `funny`. For many examples of this kind of invocation, see [invocation-tests](lib/lisp/tests/invocation-tests.nydp) in the `tests` directory. See also [destructuring-examples](lib/lisp/tests/destructuring-examples.nydp)
+
+Nested destructuring lists work as expected.
+
+`def`, 'with', and `let` all expand to forms using `fun`.
+
+#### 7. Basic error handling
 
 ```lisp
 nydp> (on-err (p "error")
@@ -278,7 +289,7 @@ make sure this happens
 error
 ```
 
-#### 7 Intercept comments
+#### 8. Intercept comments
 
 ```lisp
 nydp > (parse "; blah blah")
@@ -289,7 +300,7 @@ nydp > (parse "; blah blah")
 Except in 'mac and 'def forms, by default, `comment` is a macro that expands to nil. If you have a better idea, go for it. Any comments present at the
 beginning of the `body` argument to `mac` or `def` are considered documentation. (See "self-documenting" below).
 
-#### 8 Prefix lists
+#### 9. Prefix lists
 
 The parser emits a special form if it detects a prefix-list, that is, a list with non-delimiter characters immediately preceding
 the opening delimiter. For example:
@@ -336,7 +347,7 @@ Use 'define-prefix-list-macro to define a new handler for a prefix-list. Here's
 In this case, the regex matches an initial 'λ ; there is no constraint however on the kind of regex a prefix-list-macro might use.
 
 
-#### 9 Self-documenting
+#### 10. Self-documenting
 
 Once the 'dox system is bootstrapped, any further use of 'mac or 'def will create documentation.
 
@@ -370,7 +381,7 @@ Not as friendly, but more amenable to programmatic manipulation. Each subsequent
 it as a macro, or define it again in some other context) will generate a new documentation structure, which will simply be preprended to
 the existing list.
 
-#### 10 Pretty-Printing
+#### 11. Pretty-Printing
 
 'dox above uses the pretty printer to display code source. The pretty-printer is hard-coded to handle some special cases,
 so it will unparse special syntax, prefix-lists, quote, quasiquote, unquote, and unquote-splicing.
@@ -396,7 +407,7 @@ nydp > (p:pp:dox-src 'pp/find-breaks)
 The pretty-printer is still rather primitive in that it only indents according to some hard-coded rules, and according to argument-count
 for documented macros. It has no means of wrapping forms that get too long, or that extend beyond a certain predefined margin or column number.
 
-#### 11 DSLs
+#### 12. DSLs
 
 The `pre-compile` system (described earlier in "Macro-expansion runs in lisp") is available for implementing local, mini-languages. To do this, use `pre-compile-with`
 in a macro. `pre-compile-with` expects a hash with expansion rules, and an expression to expand using these rules. For example, to build a "describe" dsl :

data/lib/lisp/core-000.nydp

@@ -7,6 +7,7 @@
 
 (assign   list (fn args args))
 (assign   noop (fn args nil))
+(assign     x1 (fn (arg) arg))
 (assign   caar (fn (arg) (car (car arg))))
 (assign   cadr (fn (arg) (car (cdr arg))))
 (assign   cdar (fn (arg) (cdr (car arg))))
@@ -20,3 +21,4 @@
 (assign    isa (fn (type obj) (eq? (type-of obj) type)))
 (assign  pair? (fn (arg) (isa 'pair arg)))
 (assign  hash? (fn (arg) (isa 'hash arg)))
+(assign   sym? (fn (arg) (isa 'symbol arg)))

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

@@ -56,12 +56,16 @@
         (fn (arg)
             (pre-compile-with macs arg)))
 
+; we override this later to provide argument deconstruction
+(hash-set macs 'fun
+          (fn args (cons 'fn args)))
+
 ; we override this later to provide automatic documentation
 (hash-set macs 'def
           (fn (name args . body)
               (list 'assign
                     name
-                    (+ (list 'fn args)
+                    (+ (list 'fun args)
                        body))))
 
 (def qq-handle-unquote-splicing (arg rest level)

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

@@ -20,11 +20,9 @@
   ; 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 things
-        (rev-accum (cdr things)
-                   (cons (car things)
-                         acc))
-        acc))
-
-(def rev (things) (rev-accum things nil))
+(def rev (things last-cdr)
+  ; 'things - the list to be reversed
+  ; 'last-cdr - (normally nil) - an item (atom, list, nil, anything) to be consed to the end of the reversed list.
+  (if (pair? things)
+      (rev (cdr things) (cons (car things) last-cdr))
+      last-cdr))

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

@@ -144,7 +144,7 @@
 
 (def define-mac-expr (name args body-forms)
   ; used internally by 'mac
-  `(do (hash-set macs ',name (fn ,args ,@(hash-get body-forms nil)))
+  `(do (hash-set macs ',name (fun ,args ,@(hash-get body-forms nil)))
        (dox-add-doc ',name
                     'mac
                     ',(map car (hash-get body-forms 'comment))
@@ -160,7 +160,7 @@
              'mac
              '("define a new global macro")
              '(name args . body)
-             '`(hash-set macs ',name (fn ,ooargs ,@body))
+             '`(hash-set macs ',name (fn ,args ,@body))
              '(nydp-core))
 
 (dox-add-doc 'do
@@ -174,7 +174,7 @@
 
 (def define-def-expr (name args body-forms)
   ; used internally by 'def
-  `(do (def-assign ,name (fn ,args ,@(hash-get body-forms nil)))
+  `(do (def-assign ,name (fun ,args ,@(hash-get body-forms nil)))
        (dox-add-doc ',name
                     'def
                     ',(map car (hash-get body-forms 'comment))

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

@@ -33,7 +33,7 @@
              'def
              '("returns 'things in reverse order")
              '(things)
-             '(rev-accum things nil)
+             '(if (pair? things) (rev (cdr things) (cons (car things) last-cdr)) last-cdr)
              '(list-manipulation))
 
 (dox-add-doc 'hash-cons

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

@@ -85,8 +85,8 @@ scoping, assignment, anonymous functions and more...")
             (pairs (cddr things)))))
 
 (mac with (parms . body)
-     `((fn ,(map car (pairs parms))
-           ,@body)
+     `((fun ,(map car (pairs parms))
+            ,@body)
        ,@(map cadr (pairs parms))))
 
 (mac let (var val . body)
@@ -113,7 +113,7 @@ scoping, assignment, anonymous functions and more...")
   ; invocation)
   (let ppairs (pairs params)
     `(let ,name nil
-       (assign ,name (fn ,(map car ppairs) ,@body))
+       (assign ,name (fun ,(map car ppairs) ,@body))
        (,name ,@(map cadr ppairs)))))
 
 (let uniq-counter 0
@@ -134,10 +134,14 @@ scoping, assignment, anonymous functions and more...")
 (mac or args
   ; lazy-evaluates each argument, returns the first
   ; non-nil result, or nil if all evaluate to nil.
-  (cond args
-        (w/uniq ora
-                `(let ,ora ,(car args)
-                   (cond ,ora ,ora (or ,@(cdr args)))))))
+  (if (cdr args)
+      (let arg (car args)
+        (if (isa 'symbol arg)
+            `(cond ,arg ,arg (or ,@(cdr args)))
+            (w/uniq ora
+                    `(let ,ora ,arg
+                       (cond ,ora ,ora (or ,@(cdr args)))))))
+      (car args)))
 
 (mac pop (xs)
      (w/uniq gp
@@ -255,3 +259,39 @@ scoping, assignment, anonymous functions and more...")
   ; stores ,val, executes ,@body, and returns ,val. Assumes 'body is going to do something
   ; destructive with 'val, but you want 'val before it gets changed. See also 'returnlet
   (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
+         ,@(if (cddr body)
+               `(,(car body) (aif ,@(cdr body)))
+               body))))
+
+(def destructure/with (var args n)
+  ; provides the argument expression to 'with when
+  ; destructuring arguments are present in a 'fun definition
+  (if (pair? args)
+      `(,(car args) (nth ,n ,var) ,@(destructure/with var (cdr args) (+ n 1)))
+      args
+      `(,args (lastcdr ,var))))
+
+(def destructure/build (given-args new-args body)
+  ; used internally by 'fun
+  (if (pair? given-args)
+      (if (sym? (car given-args))
+          (destructure/build (cdr given-args)
+                             (cons (car given-args) new-args)
+                             body)
+          (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)))
+
+(mac fun (args . body)
+  ; build a 'fn form, changing 'args and 'body to
+  ; properly handle any destructuring args if present
+  (destructure/build args nil body))

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

@@ -7,8 +7,6 @@
               (iso (car x) (car y))
               (iso (cdr x) (cdr y)))))
 
-(def x1      (thing) thing)
-(def sym?    (arg)   (isa 'symbol arg))
 (def num?    (arg)   (isa 'number arg))
 (def string? (arg)   (isa 'string arg))
 (mac just    (arg)   arg)
@@ -49,7 +47,7 @@
   ; 'things is a list, 'x is the name of a variable, and 'expr
   ; is evaluated and collected for each 'x in 'things
   (chapter list-manipulation)
-  `(map (fn (,x) ,expr) ,things))
+  `(map (fun (,x) ,expr) ,things))
 
 (def atom? (thing)
   ; 't if 'thing is not a list or a hash

data/lib/lisp/core-060-benchmarking.nydp

@@ -1,3 +1,5 @@
+(chapter-start 'core-benchmarking "utils for benchmarking / measuring performance improvements")
+
 ;; (def bm-cond ()
 ;;   (if (< 3 5) "less" "more"))
 
@@ -83,23 +85,6 @@
 ;; (def bm-len-fn ()
 ;;   (len list))
 
-;; (def bm-repeat (f n)
-;;   (for b 1 n (f)))
-
-;; (def bm (desc f repeats iterations)
-;;      (p "\n================================================")
-;;      (p "Benchmark: ~desc - ~repeats runs of ~iterations iterations each")
-;;      (let times 0
-;;           (for reps 1 repeats
-;;                (let started (time)
-;;                     (bm-repeat f iterations)
-;;                     (let elapsed (- (time) started)
-;;                          (assign times (+ elapsed times))
-;;                          (p "  took: ~elapsed ms, ~(/ elapsed iterations) ms per iteration"))))
-;;           (p "total ~(just times), average ~(/ times repeats) per run")
-;;           (p "================================================\n")
-;;           "~desc : total ~(just times), average ~(/ times repeats) per run"))
-
 ;; (assign a 1)
 ;; (assign b 1)
 
@@ -174,8 +159,32 @@
 ;;     (= h.ca v1) (= h.cb v2) (= h.cc v3) (= h.ca v4) (= h.cb v5) (= h.cc v6)
 ;;     (= h.da v1) (= h.db v2) (= h.dc v3) (= h.da v4) (= h.db v5) (= h.dc v6)))
 
+(def bm-or-lex-lex-lex (a b c) (or a b c))
+(def bm-faster-or ()
+  (bm-or-lex-lex-lex 1 2 3)
+  (bm-or-lex-lex-lex nil 2 3))
+
+(def bm-repeat (f n)
+  ; used in benchmarking
+  (for b 1 n (f)))
+
+(def bm (desc f repeats iterations)
+     (p "\n================================================")
+     (p "Benchmark: ~desc - ~repeats runs of ~iterations iterations each")
+     (let times 0
+          (for reps 1 repeats
+               (let started (time)
+                    (bm-repeat f iterations)
+                    (let elapsed (- (time) started)
+                         (assign times (+ elapsed times))
+                         (p "  took: ~elapsed ms, ~(/ elapsed iterations) ms per iteration"))))
+          (p "total ~(just times), average ~(/ times repeats) per run")
+          (p "================================================\n")
+          "~desc : total ~(just times), average ~(/ times repeats) per run"))
+
 (def rbs (name)
   (let summary nil
+    (push (bm "cond with OR       "   bm-faster-or             10  40000) summary)
     ;; (push (bm "cond with OR       "   bm-cond-9             10  40000) summary)
     ;; (push (bm "cond with OR       "   bm-cond-9             10  100000) summary)
     ;; (push (bm "cond with OR       "   bm-cond-lex-lit-lit             10  100000) summary)

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

@@ -41,7 +41,7 @@
   ; complete form for pretty-printing, and indent being the current
   ; indent level.
   `(do (hash-set pp/special-forms ',name
-                 (fn ,args ,@body))
+                 (fun ,args ,@body))
        (dox-add-doc ',name
                     'pp/def
                     (list "pretty-printer for forms starting with ~(quote ,name)")

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

@@ -77,3 +77,36 @@
   ; of parameters for 'f. Effectively, calls (apply f item)
   ; for each item in 'args
   (map λa(apply f a) args))
+
+(mac def/cycler (name things)
+  ; create a function called 'name ; each invocation of the function will
+  ; return the next value in 'things, cycling around to the start if no things are left
+  `(with (i -1 xs ',things list-len ,(len things))
+         (def ,name (j)
+           (comment ,(just "each call to ~name returns the next value from ~(inspect things)"))
+           (nth (= i (mod (+ 1 (or j i)) list-len))
+                xs))))
+
+(def fill-bucket (items bucket size-f bucket-size maximum-size)
+  ; returns a list (list a b c) where
+  ; 'a is a subset of 'items
+  ; 'b is the sum of sizes of items in 'a : (apply + (map size-f a))
+  ; 'c is the subset of 'items not in 'a
+  ; invariants:
+  ; b < maximum-size
+  ; 'a + 'c is equal to 'items
+  ; arguments:
+  ; 'items is the list of things of which you have too many
+  ; 'bucket is either nil, or a list if you have an existing partially-filled bucket
+  ; 'size-f is a function that can tell the size of each item in 'items
+  ; 'bucket-size is the size of the existing bucket, or 0 if empty
+  ; 'maximum-size is the maximum allowed size for the bucket
+  (let next-item (car items)
+    (let next-size (+ (size-f next-item) bucket-size)
+      (if (< next-size maximum-size)
+          (fill-bucket (cdr items)
+                       (cons next-item bucket)
+                       size-f
+                       next-size
+                       maximum-size)
+          (list (rev bucket) bucket-size items)))))

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

@@ -0,0 +1,20 @@
+(examples-for aif
+  ("binds 'it in dependent expression"
+   (aif (* 2 3)
+        (+ it 1))
+   7)
+
+  ("binds 'it in subsequent dependent expressions"
+   (aif nil
+        (ignore it)
+        "hello"
+        "~it world")
+   "hello world")
+
+  ("recurses as necessary"
+   (explain-mac 1 '(aif (a) (b) (c) (d) (e)))
+   (let it (a) (if it (b) (aif (c) (d) (e)))))
+
+  ("avoids unnecessary expansion"
+   (explain-mac 1 '(aif (a) (b) (c)))
+   (let it (a) (if it (b) (c)))))

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

@@ -114,19 +114,20 @@
    (cond a (cond b c))))
 
 (examples-for or
-  ("expands 'or"
+  ("expands a tricky 'or"
    (do (reset-uniq-counter)
-       (pre-compile '(or a b c)))
+       (pre-compile '(or (a) (b) (c))))
    ((fn (ora-1)
         (cond ora-1
               ora-1
               ((fn (ora-2)
                    (cond ora-2
                          ora-2
-                         ((fn (ora-3)
-                              (cond ora-3
-                                    ora-3
-                                    nil)) c))) b))) a)))
+                         (c))) (b)))) (a)))
+
+  ("expands a simple symbol-only 'or"
+   (pre-compile '(or a b c))
+   (cond a a (cond b b c))))
 
 (examples-for w/uniq
   ("w/uniq provides unique variables for macro expansion"

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

@@ -0,0 +1,7 @@
+(def/cycler cycler-testing-example (c1 c2 c3))
+
+(examples-for cycler
+  ("returns each item in the list, over and over"
+   (list (cycler-testing-example) (cycler-testing-example) (cycler-testing-example) (cycler-testing-example)
+         (cycler-testing-example) (cycler-testing-example) (cycler-testing-example) (cycler-testing-example))
+   (c1 c2 c3 c1 c2 c3 c1 c2)))

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

@@ -0,0 +1,64 @@
+(examples-for destructure/with
+  ("with just one arg"
+   (destructure/with 'xxx '(a) 0)
+   (a (nth 0 xxx)))
+
+  ("with several args"
+   (destructure/with 'xxx '(a b (c d) e) 0)
+   (a     (nth 0 xxx)
+    b     (nth 1 xxx)
+    (c d) (nth 2 xxx)
+    e     (nth 3 xxx)))
+
+  ("with several complex args and a rest-arg"
+   (destructure/with 'xxx '(a (b c) (d (e f)) g . h) 0)
+   (a          (nth 0 xxx)
+    (b c)      (nth 1 xxx)
+    (d (e f))  (nth 2 xxx)
+    g          (nth 3 xxx)
+    h          (lastcdr xxx))))
+
+(examples-for destructure/build
+  ("with no args"
+   (destructure/build nil nil '(x))
+   (fn nil x))
+
+  ("with one arg"
+   (destructure/build '(a) nil '(x))
+   (fn (a) x))
+
+  ("with one rest-arg"
+   (destructure/build 'args nil '(x))
+   (fn args x))
+
+  ("with one destructuring arg"
+   (do (reset-uniq-counter)
+        (destructure/build '((a b)) nil '(x)))
+   (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)))
+   (fn (a destructure-1 destructure-2 g . h)
+       (with (d     (nth 0 destructure-2)
+              (e f) (nth 1 destructure-2))
+             (with (b (nth 0 destructure-1)
+                    c (nth 1 destructure-1))
+                   x)))))
+
+(examples-for fun
+  ("complete expansion, handles recursive destructures"
+   (do (reset-uniq-counter)
+       (pre-compile '(fun ((a (b c)) d . e) x)))
+   (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))))
+
+  ("implicit in 'let and 'with"
+   (with ((a b)       (list "h" "e")
+          (c (d e f)) (list "l" (list "l" "o" " ")))
+          (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"))

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

@@ -1,24 +1,24 @@
 (examples-for explain-mac
   ("does nothing if n is zero"
-   (explain-mac 0 '(afn (a) (+ 2 a)))
-   (afn (a) (+ 2 a)))
+   (explain-mac 0 '(afn (a) (let b (+ 2 a) (* b b))))
+   (afn (a) (let b (+ 2 a) (* b b))))
 
-  ("expands once for n = 1"
-   (explain-mac 1 '(afn (a) (+ 2 a)))
-   (rfn self (a) (+ 2 a)))
+  ("expands once for n = 1; does not expand inside forms"
+   (explain-mac 1 '(afn (a) (let b (+ 2 a) (* b b))))
+   (rfn self (a) (let b (+ 2 a) (* b b))))
 
   ("expands twice for n = 2"
-   (explain-mac 2 '(afn (a) (+ 2 a)))
-   (let self nil (assign self (fn (a) (+ 2 a)))))
+   (explain-mac 2 '(afn (a) (let b (+ 2 a) (* b b))))
+   (let self nil (assign self (fn (a) (let b (+ 2 a) (* b b))))))
 
   ("expands thrice for n = 3"
-   (explain-mac 3 '(afn (a) (+ 2 a)))
-   (with (self nil) (assign self (fn (a) (+ 2 a)))))
+   (explain-mac 3 '(afn (a) (let b (+ 2 a) (* b b))))
+   (with (self nil) (assign self (fn (a) (let b (+ 2 a) (* b b))))))
 
   ("expands four times for n = 4"
-   (explain-mac 4 '(afn (a) (+ 2 a)))
-   ((fn (self) (assign self (fn (a) (+ 2 a)))) nil))
+   (explain-mac 4 '(afn (a) (let b (+ 2 a) (* b b))))
+   ((fun (self) (assign self (fn (a) (let b (+ 2 a) (* b b))))) nil))
 
   ("returns same expression for n > number of possible expansions"
-   (explain-mac 10 '(afn (a) (+ 2 a)))
-   ((fn (self) (assign self (fn (a) (+ 2 a)))) nil)))
+   (explain-mac 10 '(afn (a) (let b (+ 2 a) (* b b))))
+   ((fun (self) (assign self (fn (a) (let b (+ 2 a) (* b b))))) nil)))

data/lib/lisp/tests/fill-bucket-examples.nydp

@@ -0,0 +1,20 @@
+(examples-for fill-bucket
+  ("fills a bucket with 12 characters"
+   (fill-bucket '("1" "2345" "67" "890" "1" "2345" "678")
+                nil
+                len
+                0
+                12)
+   (("1" "2345" "67" "890" "1")
+    11
+    ("2345" "678")))
+
+  ("fills a bucket up to 100"
+   (fill-bucket '(1 2 3 4 5 6 7 8 9 10)
+                nil
+                λx(* x x)
+                0
+                100)
+   ((1 2 3 4 5 6)
+    91
+    (7 8 9 10))))

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

@@ -20,6 +20,14 @@
    (rev '(a b c))
    (c b a))
 
+  ("'rev reverses a list, appending another list"
+   (rev '(a b c) '(x y z))
+   (c b a x y z))
+
+  ("'rev reverses a list, appending an improper ending"
+   (rev '(a b c) 'surprise)
+   (c b a . surprise))
+
   ("'rev handles nil"
    (rev nil)
    nil)

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.2.6"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-16 00:00:00.000000000 Z
+date: 2017-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -106,6 +106,7 @@ files:
 - lib/lisp/core-100-utils.nydp
 - lib/lisp/tests/accum-examples.nydp
 - lib/lisp/tests/add-hook-examples.nydp
+- lib/lisp/tests/aif-examples.nydp
 - lib/lisp/tests/all-examples.nydp
 - lib/lisp/tests/any-examples.nydp
 - lib/lisp/tests/auto-hash-examples.nydp
@@ -116,8 +117,10 @@ files:
 - lib/lisp/tests/collect-tests.nydp
 - lib/lisp/tests/cons-examples.nydp
 - lib/lisp/tests/curry-tests.nydp
+- lib/lisp/tests/cycler-examples.nydp
 - lib/lisp/tests/date-examples.nydp
 - lib/lisp/tests/def-examples.nydp
+- lib/lisp/tests/destructuring-examples.nydp
 - lib/lisp/tests/detect-examples.nydp
 - lib/lisp/tests/dot-syntax-examples.nydp
 - lib/lisp/tests/dox-tests.nydp
@@ -126,6 +129,7 @@ files:
 - lib/lisp/tests/empty-examples.nydp
 - lib/lisp/tests/error-tests.nydp
 - lib/lisp/tests/explain-mac-examples.nydp
+- lib/lisp/tests/fill-bucket-examples.nydp
 - lib/lisp/tests/filter-forms-examples.nydp
 - lib/lisp/tests/foundation-test.nydp
 - lib/lisp/tests/group-by-examples.nydp