nydp 0.4.1 → 0.5.0

data/lib/lisp/core-130-validations.nydp

@@ -0,0 +1,51 @@
+(chapter-start 'validations "utilities to record and run validation routines")
+
+(let validations {}
+  (def validate/reset ()
+    (= validations {}))
+  (def validate/fns (thing context)
+    (hash-get validations (list (type-of thing) context)))
+  (def validate/fn+ (type context f)
+    (hash-cons validations (list type context) f)))
+
+;;
+;; returns a hash of error-name to list of error messages
+;;
+;; An empty return value signifies an error-free 'thing
+;;
+(def validate (thing context)
+  (returnlet msgs {}
+    (let msgf λem(hash-cons msgs e m)
+      (eachl λv(v thing context msgf)
+             (validate/fns thing context)))))
+
+;; declare a validation routine for type 'type in context 'context
+;;
+;; 'type must be a symbol
+;; 'context must be a symbol
+;; 'body is one or more nydp expressions.
+;;
+;; 'body will be embedded in a function with access to the following variables :
+;;
+;; * the value of the 'type argument
+;; * ctx
+;; * mf
+;;
+;; 'mf ("message function") is a function that takes two arguments and is used to store
+;; the validation error message
+;; example: (mf "Last name" "Last name must not be empty")
+;;
+;; example usage:
+;;
+;; (validate/def invoice issue
+;;   (if (no invoice.account)
+;;       (mf "Account" "Account must be a client account"))
+;;   (if (!> invoice.total 0)
+;;       (mf "Amount"  "Amount must be greater than zero"))
+;;   (if (any? !&group invoice.invoice-items)
+;;       (mf "Group"   "Each line must be assigned to a group")))
+;;
+;; if your routine makes no call to 'mf then 'validate will return an empty hash, which should be
+;; interpreted as signifying that the object in question is error free in the given context.
+(mac validate/def (type context . body)
+  `(validate/fn+ ',type ',context (fn (,type ctx mf) ,@body)))

data/lib/lisp/{core-060-benchmarking.nydp → core-900-benchmarking.nydp}

@@ -159,23 +159,104 @@
 ;;     (= 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 build-mapsum-data (count data)
-  (if (> count 0)
-      (build-mapsum-data (- count 1)
-                         (cons { mappit (rand 10) }
-                               data))
-      data))
-
-(let mapsum-data (build-mapsum-data 1000)
-  (def bm-mapsum    () (mapsum &mappit mapsum-data))
-  (def bm-mapreduce () (mapreduce &mappit + mapsum-data 0)))
-
-
+  ;; (def bm-acc ()
+  ;;   (accum z
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)))
+
+  ;; (def bm-facc ()
+  ;;   (faccum z
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
+  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)))
+
+(in-private
+ (def bm-no-closures ()
+   (list λ(+ 1 2)
+         λ(+ 1 2)
+         λ(+ 1 2)
+         λ(+ 1 2)
+         λ(+ 1 2)
+         λ(+ 1 2)
+         λ(+ 1 2)
+         λ(+ 1 2)
+         λ(+ 1 2)
+         λ(+ 1 2)))
+
+ (def bm-cons () (cons 'a 'b))
+ (def bm-type-of () (type-of 'a)))
+
+
+
+;; ================================================
+;; Benchmark: string concatenation     - 10 runs of 20000 iterations each
+;;   took: 0.702480166 ms, 3.51240083e-05 ms per iteration
+;;   took: 0.71368384 ms, 3.5684192e-05 ms per iteration
+;;   took: 0.722608668 ms, 3.61304334e-05 ms per iteration
+;;   took: 0.716350427 ms, 3.5817521349999995e-05 ms per iteration
+;;   took: 0.72145049 ms, 3.60725245e-05 ms per iteration
+;;   took: 0.745082221 ms, 3.725411105e-05 ms per iteration
+;;   took: 0.722694129 ms, 3.613470645e-05 ms per iteration
+;;   took: 0.71999777 ms, 3.59998885e-05 ms per iteration
+;;   took: 0.727236822 ms, 3.63618411e-05 ms per iteration
+;;   took: 0.73657519 ms, 3.68287595e-05 ms per iteration
+;; total 7.228159722999999, average 0.7228159722999999 per run
+;; ================================================
+;;    string concatenation     : total 7.228159722999999, average 0.7228159722999999 per run
+;; (def bm-string-concat ()
+;;   (+
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")
+;;      (+ "this" "that" "another")))
+
+
+;; ================================================
+;; Benchmark: random string     - 10 runs of 20000 iterations each
+;;   took: 0.693267608 ms, 3.4663380399999996e-05 ms per iteration
+;;   took: 0.763436112 ms, 3.8171805599999996e-05 ms per iteration
+;;   took: 0.682000681 ms, 3.410003405e-05 ms per iteration
+;;   took: 0.687733846 ms, 3.43866923e-05 ms per iteration
+;;   took: 0.686838878 ms, 3.43419439e-05 ms per iteration
+;;   took: 0.681588034 ms, 3.40794017e-05 ms per iteration
+;;   took: 0.689589352 ms, 3.44794676e-05 ms per iteration
+;;   took: 0.690437907 ms, 3.4521895349999996e-05 ms per iteration
+;;   took: 0.683199842 ms, 3.4159992099999995e-05 ms per iteration
+;;   took: 0.696863126 ms, 3.48431563e-05 ms per iteration
+;; total 6.954955385999999, average 0.6954955385999999 per run
+;; ================================================
+;;    random string     : total 6.954955385999999, average 0.6954955385999999 per run
+
+;; (def bm-random-string ()
+;;   (list (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)
+;;         (random-string)))
 
 (def bm-repeat (f n)
   ; used in benchmarking
@@ -195,10 +276,17 @@
           (p "================================================\n")
           "~desc : total ~(just times), average ~(/ times repeats) per run"))
 
+
+
 (def rbs (name)
   (let summary nil
-    (push (bm "mapsum    "   bm-mapsum             10  100) summary)
-    (push (bm "mapreduce "   bm-mapreduce          10  100) summary)
+    ;; (push (bm "random string    "   bm-random-string             10  20000) summary)
+    ;; (push (bm "string concatenation    "   bm-string-concat             10  20000) summary)
+    ;; (push (bm "type-of    "   bm-type-of             10  20000) summary)
+    ;; (push (bm "accum    "   bm-acc             10  500) summary)
+    ;; (push (bm "accum    "   bm-facc            10  500) summary)
+    ;; (push (bm "mapsum    "   bm-mapsum             10  100) summary)
+    ;; (push (bm "mapreduce "   bm-mapreduce          10  100) summary)
     ;; (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)

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

@@ -4,4 +4,31 @@
           (a 1)
           (a 2)
           (a 3))
-   (1 2 3)))
+   (1 2 3))
+
+  ("accum function returns the accumulated object in each case"
+   (let watcher nil
+     (let accumulated (accum b
+                             (= watcher (cons (b 1) watcher))
+                             (= watcher (cons (b 2) watcher))
+                             (= watcher (cons (b 3) watcher)))
+       (list 'watcher watcher 'accumulated accumulated)))
+   (watcher     (3 2 1)
+    accumulated (1 2 3))))
+
+(examples-for accum-hash
+  ("accumulate the values passed to a given function under the given key, return the resulting hash"
+   (let h
+     (accum-hash hi
+                 (hi 'a 1)
+                 (hi 'a 2)
+                 (hi 'b 42)
+                 (hi 'b 43)
+                 (hi 'a 3)
+                 (hi 'b 44)
+                 (hi 'c 'x)
+                 (hi 'a 4)
+                 (hi 'c 'y)
+                 (hi 'c 'z))
+     (list h.a h.b h.c))
+   ((4 3 2 1) (44 43 42) (z y x))))

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/at-syntax-examples.nydp

@@ -0,0 +1,17 @@
+(examples-for at-syntax
+  ("at-symbol as argument"
+   (let @ {}
+     (= @foo 1)
+     (= @bar 2)
+     (list @foo @bar))
+   (1 2))
+
+  ("at-syntax assignment"
+   (pre-compile '(= @a 42))
+   (hash-set @ 'a 42))
+
+  ("mixed at-syntax and dot-syntax assignment"
+   (pre-compile '(= @a.b 42))
+   (hash-set (hash-get @ 'a) 'b 42)))
+
+;; (let @ {} 123)

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

@@ -19,6 +19,15 @@
    (best > '(c g d o a p b m e g a z m))
    z)
 
+  ("finds object with max size"
+   (to-string:best (map-compare-f > &size)
+              (list { i 0 size 3 }
+                    { i 1 size 1 }
+                    { i 2 size 7 }
+                    { i 3 size 4 }
+                    { i 4 size 5 }))
+   "{i=>2, size=>7}")
+
   ("finds maximum of list of numbers"
    (best > '(3 5 4 7 8 2))
    8))

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

@@ -84,3 +84,22 @@
 
 (examples-for mod
   ("modulus for two ints" (mod 64 6) 4))
+
+(examples-for abs
+  ("a positive integer"  (abs   64)   64)
+  ("a negative integer"  (abs  -42)   42)
+  ("zero"                (abs    0)    0)
+  ("negative zero"       (abs   -0)    0)
+  ("float zero"          (abs  0.0)    0)
+  ("float negative zero" (abs -0.0)    0)
+  ("float negative"      (abs -1.6)  1.6)
+  ("float positive"      (abs  4.2)  4.2))
+
+(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/case-examples.nydp

@@ -0,0 +1,14 @@
+(examples-for 'case
+  ("expands to an if-expression"
+   (do (reset-uniq-counter)
+       (explain-mac 1
+                    `(case eq? person.name
+                           "conan" (greet person)
+                           "egg"   (delete person)
+                           "bach"  (play person)
+                           else    (interrogate person))))
+   (let caseval-1 (dot-syntax person name)
+     (if (eq? caseval-1 "conan") (greet person)
+         (eq? caseval-1 "egg")   (delete person)
+         (eq? caseval-1 "bach")  (play person)
+         (interrogate person)))))

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

@@ -0,0 +1,6 @@
+(examples-for cdr-set
+  ("sets cdr of a cons cell"
+   (let things '(a b c d)
+     (cdr-set things '(x y z))
+     things)
+   (a x y z)))

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

@@ -18,6 +18,11 @@
  ("navigates to week end from sun"   (let d (date 2015 11  1) (to-string d.end-of-week))         "2015-11-01" )
  ("navigates to week end"            (let d (date 2015 11  6) (to-string d.end-of-week))         "2015-11-08" )
 
+ ("works with apply"       (to-string (apply date '(2006 6 21))) "2006-06-21")
+ ("works with apply again" (to-string (apply date 2006 6 21 nil)) "2006-06-21")
+
+ ("parses string" (let d (date "2004-03-12") (list d.year d.month d.day)) (2004 3 12))
+
  ("can act as hash key"
   (with (h {} d (date 2015 11 8))
     (hash-set h d "on this day")
@@ -45,4 +50,54 @@
  ("adds days"             (let d (date 2015 11  8) (to-string (+ d  1))) "2015-11-09")
  ("adds more days"        (let d (date 2015 11  8) (to-string (+ d 10))) "2015-11-18")
  ("subtracts a day"       (let d (date 2015 11 18) (to-string (- d  1))) "2015-11-17")
- ("subtracts more days"   (let d (date 2015 11 18) (to-string (- d  5))) "2015-11-13"))
+ ("subtracts more days"   (let d (date 2015 11 18) (to-string (- d  5))) "2015-11-13")
+
+ ("advances by -2 weeks"   (let d (date 1965  6  8) (to-string (+ d '(-2 week)))) "1965-05-25")
+ ("advances by -1 week"    (let d (date 1965  6  8) (to-string (+ d '(-1 week)))) "1965-06-01")
+ ("advances by  1 week"    (let d (date 1965  6  8) (to-string (+ d '( 1 week)))) "1965-06-15")
+ ("advances by  2 weeks"   (let d (date 1965  6  8) (to-string (+ d '( 2 week)))) "1965-06-22")
+
+ ("advances by -2 weeks"   (let d (date 1965  6  8) (to-string (+   d '(-2 week)))) "1965-05-25")
+ ("advances by -1 week"    (let d (date 1965  6  8) (to-string (+   d '(-1 week)))) "1965-06-01")
+ ("advances by  1 week"    (let d (date 1965  6  8) (to-string (+   d '( 1 week)))) "1965-06-15")
+ ("advances by  2 weeks"   (let d (date 1965  6  8) (to-string (+   d '( 2 week)))) "1965-06-22")
+
+ ("advances by -2 days"    (let d (date 1965  6  8) (to-string (+   d '(-2 day)))) "1965-06-06")
+ ("advances by -1 day"     (let d (date 1965  6  8) (to-string (+   d '(-1 day)))) "1965-06-07")
+ ("advances by  1 day"     (let d (date 1965  6  8) (to-string (+   d '( 1 day)))) "1965-06-09")
+ ("advances by  2 days"    (let d (date 1965  6  8) (to-string (+   d '( 2 day)))) "1965-06-10")
+
+ ("advances by -2 months"  (let d (date 1965  6  8) (to-string (+   d '(-2 month)))) "1965-04-08")
+ ("advances by -1 month"   (let d (date 1965  6  8) (to-string (+   d '(-1 month)))) "1965-05-08")
+ ("advances by  1 month"   (let d (date 1965  6  8) (to-string (+   d '( 1 month)))) "1965-07-08")
+ ("advances by  2 months"  (let d (date 1965  6  8) (to-string (+   d '( 2 month)))) "1965-08-08")
+
+ ("advances by -2 years"   (let d (date 1965  6  8) (to-string (+   d '(-2 year)))) "1963-06-08")
+ ("advances by -1 year"    (let d (date 1965  6  8) (to-string (+   d '(-1 year)))) "1964-06-08")
+ ("advances by  1 year"    (let d (date 1965  6  8) (to-string (+   d '( 1 year)))) "1966-06-08")
+ ("advances by  2 years"   (let d (date 1965  6  8) (to-string (+   d '( 2 year)))) "1967-06-08")
+
+ ("adapts for leap years"         (let d (date 2019 12 31) (to-string (+   d '( 2 month)))) "2020-02-29")
+ ("jumps one year"                (let d (date 2019 12 31) (to-string (+   d '( 1 year) ))) "2020-12-31")
+ ("jumps to 28 feb a year later"  (let d (date 2019 12 31) (to-string (+   d '(14 month)))) "2021-02-28")
+ ("jumps to end of june"          (let d (date 2019 12 31) (to-string (+   d '( 6 month)))) "2020-06-30")
+ ("jumps to end of july"          (let d (date 2019 12 31) (to-string (+   d '( 7 month)))) "2020-07-31")
+ ("jumps from end feb to end feb" (let d (date 2020 02 29) (to-string (+   d '(12 month)))) "2021-02-28")
+
+ ("finds anniversary before a given date in previous year"
+  (to-string (anniversary/previous (date 2019 6 21) (date 1949 10 3)))
+  "2018-10-03")
+
+ ("finds anniversary before a given date in same year"
+  (to-string (anniversary/previous (date 2019 11 20) (date 1949 10 3)))
+  "2019-10-03")
+
+ ("finds anniversary after a given date in same year"
+  (to-string (anniversary/next (date 2019 6 21) (date 1949 10 3)))
+  "2019-10-03")
+
+
+ ("finds anniversary after a given date in following year"
+  (to-string (anniversary/next (date 2019 11 20) (date 1949 10 3)))
+  "2020-10-03")
+ )

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")
@@ -66,12 +77,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")
@@ -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)))