nydp 0.5.1 → 0.6.0

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

@@ -1,103 +1,130 @@
 (examples-for date
- ("creates a single date"            (to-string (date 1965 6 8))                                 "1965-06-08" )
- ("navigates to next day"            (let d (date 2004  3 11) (to-string d.tomorrow))            "2004-03-12" )
- ("navigates to previous day"        (let d (date 2006  6 22) (to-string d.yesterday))           "2006-06-21" )
- ("navigates to previous year"       (let d (date 1971 12 18) (to-string d.last-year))           "1970-12-18" )
- ("navigates to next year"           (let d (date 1974  1 11) (to-string d.next-year))           "1975-01-11" )
- ("navigates to previous month"      (let d (date 1971 12 18) (to-string d.last-month))          "1971-11-18" )
- ("navigates to next month"          (let d (date 1974  1 11) (to-string d.next-month))          "1974-02-11" )
- ("jumps a year to previous month"   (let d (date 1974  1 11) (to-string d.last-month))          "1973-12-11" )
- ("navigates to previous week"       (let d (date 2008  2 16) (to-string d.last-week))           "2008-02-09" )
- ("navigates to next week"           (let d (date 1972 11 13) (to-string d.next-week))           "1972-11-20" )
- ("navigates to year start"          (let d (date 1972 11 13) (to-string d.beginning-of-year))   "1972-01-01" )
- ("navigates to year end"            (let d (date 1972 11 13) (to-string d.end-of-year))         "1972-12-31" )
- ("navigates to month start"         (let d (date 1971 11 18) (to-string d.beginning-of-month))  "1971-11-01" )
- ("navigates to month end"           (let d (date 1971 11 18) (to-string d.end-of-month))        "1971-11-30" )
- ("navigates to week start"          (let d (date 2015 11  6) (to-string d.beginning-of-week))   "2015-11-02" )
- ("navigates to week start from sun" (let d (date 2015 11  1) (to-string d.beginning-of-week))   "2015-10-26" )
- ("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")
-    (to-string (hash-get h (date 2015 11 8))))
-  "on this day")
-
- ("equals itself"              (eq? (date 2004 3 12) (date 2004 3 12))  t  )
- ("does not equal another"     (eq? (date 2004 3 12) (date 2006 6 21))  nil)
- ("does not equal nil"         (eq? (date 2004 3 12) nil             )  nil)
- ("nil does not equal a date"  (eq? nil (date 2004 3 12)             )  nil)
-
- ("returns its year"      (let d (date 1999 12 31) d.year)     1999)
- ("returns its month"     (let d (date 1999 12 31) d.month)    12  )
- ("returns its day"       (let d (date 1999 12 31) d.day)      31  )
- ("returns its week-day"  (let d (date 1999 12 31) d.week-day) 5   )
- ("recognises not monday" (let d (date 2015 11  1) d.monday?   ) nil )
- ("recognises monday"     (let d (date 2015 11  2) d.monday?   ) t   )
- ("recognises tuesday"    (let d (date 2015 11  3) d.tuesday?  ) t   )
- ("recognises wednesday"  (let d (date 2015 11  4) d.wednesday?) t   )
- ("recognises thursday"   (let d (date 2015 11  5) d.thursday? ) t   )
- ("recognises friday"     (let d (date 2015 11  6) d.friday?   ) t   )
- ("recognises not friday" (let d (date 2015 11  7) d.friday?   ) nil )
- ("recognises saturday"   (let d (date 2015 11  7) d.saturday? ) t   )
- ("recognises sunday"     (let d (date 2015 11  8) d.sunday?   ) t   )
- ("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")
-
- ("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")
- )
+  ("creates a single date"            (to-string (date 1965 6 8))                                 "1965-06-08" )
+  ("navigates to next day"            (let d (date 2004  3 11) (to-string d.tomorrow))            "2004-03-12" )
+  ("navigates to previous day"        (let d (date 2006  6 22) (to-string d.yesterday))           "2006-06-21" )
+  ("navigates to previous year"       (let d (date 1971 12 18) (to-string d.last-year))           "1970-12-18" )
+  ("navigates to next year"           (let d (date 1974  1 11) (to-string d.next-year))           "1975-01-11" )
+  ("navigates to previous month"      (let d (date 1971 12 18) (to-string d.last-month))          "1971-11-18" )
+  ("navigates to next month"          (let d (date 1974  1 11) (to-string d.next-month))          "1974-02-11" )
+  ("jumps a year to previous month"   (let d (date 1974  1 11) (to-string d.last-month))          "1973-12-11" )
+  ("navigates to previous week"       (let d (date 2008  2 16) (to-string d.last-week))           "2008-02-09" )
+  ("navigates to next week"           (let d (date 1972 11 13) (to-string d.next-week))           "1972-11-20" )
+  ("navigates to year start"          (let d (date 1972 11 13) (to-string d.beginning-of-year))   "1972-01-01" )
+  ("navigates to year end"            (let d (date 1972 11 13) (to-string d.end-of-year))         "1972-12-31" )
+  ("navigates to month start"         (let d (date 1971 11 18) (to-string d.beginning-of-month))  "1971-11-01" )
+  ("navigates to month end"           (let d (date 1971 11 18) (to-string d.end-of-month))        "1971-11-30" )
+  ("navigates to week start"          (let d (date 2015 11  6) (to-string d.beginning-of-week))   "2015-11-02" )
+  ("navigates to week start from sun" (let d (date 2015 11  1) (to-string d.beginning-of-week))   "2015-10-26" )
+  ("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")
+     (to-string (hash-get h (date 2015 11 8))))
+   "on this day")
+
+  ("equals itself"              (eq? (date 2004 3 12) (date 2004 3 12))  t  )
+  ("does not equal another"     (eq? (date 2004 3 12) (date 2006 6 21))  nil)
+  ("does not equal nil"         (eq? (date 2004 3 12) nil             )  nil)
+  ("nil does not equal a date"  (eq? nil (date 2004 3 12)             )  nil)
+
+  ("returns its year"      (let d (date 1999 12 31) d.year)     1999)
+  ("returns its month"     (let d (date 1999 12 31) d.month)    12  )
+  ("returns its day"       (let d (date 1999 12 31) d.day)      31  )
+  ("returns its week-day"  (let d (date 1999 12 31) d.week-day) 5   )
+  ("recognises not monday" (let d (date 2015 11  1) d.monday?   ) nil )
+  ("recognises monday"     (let d (date 2015 11  2) d.monday?   ) t   )
+  ("recognises tuesday"    (let d (date 2015 11  3) d.tuesday?  ) t   )
+  ("recognises wednesday"  (let d (date 2015 11  4) d.wednesday?) t   )
+  ("recognises thursday"   (let d (date 2015 11  5) d.thursday? ) t   )
+  ("recognises friday"     (let d (date 2015 11  6) d.friday?   ) t   )
+  ("recognises not friday" (let d (date 2015 11  7) d.friday?   ) nil )
+  ("recognises saturday"   (let d (date 2015 11  7) d.saturday? ) t   )
+  ("recognises sunday"     (let d (date 2015 11  8) d.sunday?   ) t   )
+  ("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")
+
+  ("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"))
+
+(examples-for future?
+  ("is true for a future date"
+   (let d (+ (today) 10)
+     d.future?)
+   t)
+  ("is false for a past date"
+   (let d (- (today) 10)
+     d.future?)
+   nil)
+  ("is false for today"
+   (let d (today)
+     d.future?)
+   nil))
+
+(examples-for past?
+  ("is true for a past date"
+   (let d (- (today) 10)
+     d.past?)
+   t)
+  ("is false for a future date"
+   (let d (+ (today) 10)
+     d.past?)
+   nil)
+  ("is false for today"
+   (let d (today)
+     d.past?)
+   nil))

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

@@ -76,7 +76,7 @@
   ("warns about arg names shadowing macro names"
    (do (without-hooks 'warnings/new
                       λ(on-err nil
-                               (pre-compile '(fun (aif (and or) . when)
+                               (apply macs.fun '((aif (and or) . when)
                                                   ignore))))
        warnings/list)
    ((arg-shadows-macro "arg " when " shadows macro " when " in arg list " (aif (and or) . when) " and body " (ignore) )

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

@@ -1,5 +1,5 @@
 (mac this-is-a-well-documented-macro (a b c)
-  ; documentation for me!
+  ; documentation for this mac!
   `(foo ,a ,b ,c))
 
 (mac this-is-an-undocumented-macro (a b c)
@@ -23,7 +23,7 @@
 
   ("finds documentation for a documented macro"
    (hash-get (car:dox-lookup 'this-is-a-well-documented-macro) 'texts)
-   ("documentation for me!"))
+   ("documentation for this mac!"))
 
   ("finds arg names for a documented macro"
    (hash-get (car:dox-lookup 'this-is-a-well-documented-macro) 'args)

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

@@ -27,6 +27,24 @@
   ("  t for a hash"    (hash? {a 1 b 2})       t  )
   ("nil for a symbol"  (hash? 'foo)            nil))
 
+(examples-for hash-to-array
+  ("returns empty list for empty hash"
+   (hash-to-array {})
+   ())
+
+  ("returns one-element list for single-element hash"
+   (hash-to-array { a 1})
+   ((a 1)))
+
+  ("returns a list of two-element lists"
+   (hash-to-array { a 1 b 2 c 3 })
+   ((a 1) (b 2) (c 3))))
+
+(examples-for map-hash
+  ("converts a hash to a list of objects"
+   (to-string:map-hash (fn (k v) { name k price v }) { a 1 b 2 c 3 })
+   "({:name=>:a, :price=>1} {:name=>:b, :price=>2} {:name=>:c, :price=>3})"))
+
 (examples-for hash-slice
   ("returns a new hash containing only the specified keys"
    (let h (hash-slice { a 1 b 2 c 3 d 4 } '(a b e f))
@@ -45,39 +63,40 @@
    ((a "b" 3 b) 99 2 "foo" 98)))
 
 (examples-for hash-keys
-  ("returns nil for a number"  (hash-keys 1)          nil)
-  ("returns nil for nil"       (hash-keys nil)        nil)
-  ("returns nil for a string"  (hash-keys "hello")    nil)
-  ("returns nil for a symbol"  (hash-keys 'lipstick)  nil)
-
-  ("returns date operations"
-   (sort:hash-keys (date 2015 11 18))
-   (age
-    beginning_of_month
-    beginning_of_week
-    beginning_of_year
-    day
-    end_of_month
-    end_of_week
-    end_of_year
-    friday?
-    last_month
-    last_week
-    last_year
-    monday?
-    month
-    next_month
-    next_week
-    next_year
-    saturday?
-    sunday?
-    thursday?
-    tomorrow
-    tuesday?
-    wednesday?
-    week_day
-    year
-    yesterday))
+  ("returns nil for a number"  (hash-keys 1)                 nil)
+  ("returns nil for nil"       (hash-keys nil)               nil)
+  ("returns nil for a string"  (hash-keys "hello")           nil)
+  ("returns nil for a symbol"  (hash-keys 'lipstick)         nil)
+  ("returns nil for a date"    (hash-keys (date 2015 11 18)) nil)
+
+  ;; ("returns date operations"
+  ;;  (sort:hash-keys (date 2015 11 18))
+  ;;  (age
+  ;;   beginning_of_month
+  ;;   beginning_of_week
+  ;;   beginning_of_year
+  ;;   day
+  ;;   end_of_month
+  ;;   end_of_week
+  ;;   end_of_year
+  ;;   friday?
+  ;;   last_month
+  ;;   last_week
+  ;;   last_year
+  ;;   monday?
+  ;;   month
+  ;;   next_month
+  ;;   next_week
+  ;;   next_year
+  ;;   saturday?
+  ;;   sunday?
+  ;;   thursday?
+  ;;   tomorrow
+  ;;   tuesday?
+  ;;   wednesday?
+  ;;   week_day
+  ;;   year
+  ;;   yesterday))
 
   ("returns keys of a given hash"
    (hash-keys {a 1 b 2 c { x 99 y 98 z 97 }})
@@ -127,3 +146,9 @@
          (let hsh { (joinstr " " zi chi) 10 "yesterday" 11 }
            (list "hello world" (hash-get hsh "hello world") "yesterday" (hash-get hsh "yesterday"))))
    ("hello world" 10 "yesterday" 11)))
+
+(examples-for hash-transform-values
+  ("returns a new hash with the same keys as the given hash, where each corresponding value is transformed by the given transform function"
+   (let h { a 1 b 2 c 3 d 4 }
+     (to-list (hash-transform-values λkvi(* v v) h)))
+   ((a 1) (b 4) (c 9) (d 16))))

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

@@ -224,6 +224,121 @@
      (list/fill '(a b c) λ(++ idx) 10))
    (a b c 1 2 3 4 5 6 7)))
 
+(examples-for list/index-of
+  ("returns nil if thing is not found in an empty list"
+    (list/index-of 5 '())
+    nil)
+
+  ("returns nil if thing is not found"
+    (list/index-of 5 '(1 2 3 4))
+    nil)
+
+  ("returns 0 if thing is first in the list"
+   (list/index-of 'a '(a b c d a b c d))
+   0)
+
+  ("returns 1 if thing is second in the list"
+   (list/index-of 'b '(a b c d a b c d))
+   1)
+
+  ("returns 2 if thing is third in the list"
+   (list/index-of 'c '(a b c d a b c d))
+   2))
+
+(examples-for list/around-thing
+  ("returns nil,nil if item is not in the empty list"
+   (list/around-thing 6 '())
+   (nil nil))
+
+  ("returns nil,nil if item is not in the list"
+   (list/around-thing 6 '(1 2 3 4 5))
+   (nil nil))
+
+  ("returns nil,next if item is at the start of the list"
+   (list/around-thing 1 '(1 2 3 4 5))
+   (nil 2))
+
+  ("returns prev,nil if item is at the end of the list"
+   (list/around-thing 5 '(1 2 3 4 5))
+   (4 nil))
+
+  ("returns nil,nil if item is the only element of the list"
+   (list/around-thing 42 '(42))
+   (nil nil))
+
+  ("returns prev,next if item is the second element of a longer list list"
+   (list/around-thing 2 '(1 2 3 4 5))
+   (1 3))
+
+  ("returns prev,next if item is the second-last element of a longer list list"
+   (list/around-thing 4 '(1 2 3 4 5))
+   (3 5))
+
+  ("returns prev,next if item is anywhere in the middle of a longer list list"
+   (list/around-thing 3 '(1 2 3 4 5))
+   (2 4)))
+
+(examples-for list/around
+  ("returns nil,nil if index is nil"
+   (list/around nil '(a b c d e))
+   (nil nil))
+
+  ("returns nil,nil if index is nil and list is empty"
+   (list/around nil '())
+   (nil nil))
+
+  ("returns nil,nil if index is negative"
+   (list/around -1 '(a b c d e))
+   (nil nil))
+
+  ("returns nil,nil if index is negative and list is empty"
+   (list/around -1 '())
+   (nil nil))
+
+  ("returns nil,nil if index is out of range"
+   (list/around 10 '(a b c d e))
+   (nil nil))
+
+  ("returns nil,nil if index is out of range and list is empty"
+   (list/around 10 '())
+   (nil nil))
+
+  ("returns nil,nil if index is even slightly out of range"
+   (list/around 5 '(a b c d e))
+   (nil nil))
+
+  ("returns nil,next if index is zero"
+   (list/around 0 '(a b c d e))
+   (nil b))
+
+  ("returns nil,nil if index is zero and list is empty"
+   (list/around 0 '())
+   (nil nil))
+
+  ("returns nil,nil if index is one and list is empty"
+   (list/around 1 '())
+   (nil nil))
+
+  ("returns prev,nil index is at the end of the list"
+   (list/around 4 '(a b c d e))
+   (d nil))
+
+  ("returns nil,nil if index is 0 and list has only one item"
+   (list/around 0 '(xxx))
+   (nil nil))
+
+  ("returns prev,next if index is 1"
+   (list/around 1 '(a b c d e))
+   (a c))
+
+  ("returns prev,next if index corresponds to the second-last element of a longer list"
+   (list/around 3 '(a b c d e))
+   (c e))
+
+  ("returns prev,next if index is anywhere in the middle of a longer list"
+   (list/around 2 '(a b c d e))
+   (b d)))
+
 (examples-for list/last
   ("returns the thing if it's nil"
    (list/last nil)
@@ -233,14 +348,35 @@
    (list/last 42)
    42)
 
+  ("is not tricked when the last item is itself a list"
+   (list/last '(1 2 3 (a b c)))
+   (a b c))
+
+  ;; (1 2 3 . (a b c)) is equivalent to '(1 2 3 a b c)
+  ("is not tricked by tricky syntax"
+   (list/last '(1 2 3 . (a b c)))
+   c)
+
+  ("is not tricked when the last list-item is a list but there is also a last-cdr"
+   (list/last '(1 2 3 (a b c) . foo))
+   foo)
+
   ("returns the cdr if it's not a pair"
    (list/last '(x . y))
    y)
 
+  ("returns the cdr if it's not a pair"
+   (list/last '(x nil . y))
+   y)
+
+  ("dot nil is not real"
+   (list/last '(x q . nil))
+   q)
+
   ("returns the last item in the list"
    (list/last '(x y z))
    z)
 
   ("returns nil if it's the last item in the list"
-   (list/last '(x y z nil))
+   (list/last '(x nil y z nil))
    nil))

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

@@ -285,6 +285,18 @@ toto")
    (pp '(percent-syntax || (dot-syntax x y)))
    "%x.y")
 
+  ("percent-syntax with args"
+   (pp '(%tr.klakla
+             (%td:otherkla:joinstr ", " (map &firstname ppl))
+             (%td:otherkla:joinstr ", " (map &email ppl))))
+   "(%tr.klakla
+  (%td:otherkla:joinstr
+    \", \"
+    (map &firstname ppl))
+  (%td:otherkla:joinstr
+    \", \"
+    (map &email ppl)))")
+
   ("brace list"
    (pp '(let hello {a 1 b "two" c 'three d ,four e (sub invocation) f {sub brace list here} }))
 "(let hello { a 1

data/lib/lisp/tests/rotate-2d-array-examples.nydp

@@ -0,0 +1,26 @@
+(examples-for rotate-2d-array
+  ("returns nothing for nothing"
+   (rotate-2d-array nil)
+   nil)
+
+  ("returns transformed array"
+   (rotate-2d-array
+     '((a b c d)
+       (1 2 3 4)
+       (w x y z)
+       (one two three four)
+       (un deux trois quatre)))
+   ((a 1 w one un)
+    (b 2 x two deux)
+    (c 3 y three trois)
+    (d 4 z four quatre)))
+
+  ("first given list determines number of lists"
+   (rotate-2d-array
+     '((a b)
+       (1 2 3 4)
+       (w x y z)
+       (one two three four)
+       (un deux trois quatre)))
+   ((a 1 w one un)
+    (b 2 x two deux))))

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

@@ -16,8 +16,8 @@
    (let hh (list { a 1 b 2 } { a 7 b 9 } { a 3 b 1 } { a 2 b 8 })
      (pp (sort-by &a hh)))
    "({ a 1 b 2 } { a 2 b 8 }
-              { a 3 b 1 }
-              { a 7 b 9 })")
+                { a 3 b 1 }
+                { a 7 b 9 })")
 
   ("sorts a list of strings according to their length"
    (sort-by len
@@ -30,9 +30,9 @@
    ("max" "min" "sport" "short" "very song" "very long")))
 
 (examples-for safe-sort-by
-  ("sorts a list of hashes by a specified key"
+  ("sorts a list of hashes by a specified key function, with default sort value if key function returns nil"
    (let hh (list { a 1 b 2 } { b 9 } { a 3 b 1 } { a nil b 8 })
      (pp (safe-sort-by &a 99 hh)))
    "({ a 1 b 2 } { a 3 b 1 }
-              { a nil b 8 }
-              { b 9 })"))
+                { a nil b 8 }
+                { b 9 })"))

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

@@ -13,12 +13,23 @@
 
   ("reports errors"
    (on-err errors
-           (let s "hello \~|u|, \~x + \~y is \~(+ x y), thank heavens!"
+           (let s "hello \~|u|, \~x + \~y is \~(+ 2 y), thank heavens!"
              (string/eval-with-args s '(a b c) "world" 36 6)))
-   ("error evaluating \"hello \~|u|, \~x + \~y is \~(+ x y), thank heavens!\"
-with arg names (a b c)
-and args (\"world\" 36 6)"
-    "unbound symbol: y")))
+   ("error evaluating \"hello \~|u|, \~x + \~y is \~(+ 2 y), thank heavens!\"
+with arg names (a b c)\nand args (\"world\" 36 6)"
+
+"Called builtin/apply
+with args
+  NydpGenerated_2F5C2EF513C87E2349A55BCB331F83CC856076BBB89CDFAAA1817D62AFEEF0DB.rb:15
+  (fn (a b c) (string-pieces \"hello \" u \", \" x \" + \" y \" is \" (+ 2 y) \", thank heavens!\"))
+  (\"world\" 36 6)"
+
+"Called builtin/+
+with args
+  2
+  nil"
+
+"nil can't be coerced into Integer")))
 
 (examples-for string/pad-left
   ("does not change a string whose length is greater than the given length"

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

@@ -9,11 +9,12 @@
 
   ("dislikes no-prefix"
    (on-err (joinstr "\n" errors)
-           (pre-compile '(:foo 1 2 3)))
+           (pre-compile (car (parse "(:foo 1 2 3)"))))
    "expanding
 (colon-syntax || foo)
 with
-(fn names ((orf (hash-get colon-syntax-overrides car [0#0#0]names) default-colon-syntax) [0#0#0]names))
+NydpGenerated_D5FEA04F6E33706A6789A4F7BD15E937C3CFFAF5C16B89D54087F38BD4E594D1.rb:24
+(fn names ((orf (hash-get colon-syntax-overrides (car names)) default-colon-syntax) names))
 Irregular ': syntax: got (|| foo) : not prefix-syntax : in :foo"))
 
 (examples-for prefix-list
@@ -36,3 +37,10 @@ Irregular ': syntax: got (|| foo) : not prefix-syntax : in :foo"))
   ("with two args, to be sure"
    (λpq(+ p (* p q)) 3 5)
    18))
+
+(examples-for tilde-prefix-expansion
+  ("tilde expands to to-string"
+   (with (a (to-string (date "2004-03-12"))
+          b ~(date "2004-03-12"))
+     (list a b))
+   ("2004-03-12" "2004-03-12")))