nydp 0.1.2 → 0.1.3

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

@@ -0,0 +1,24 @@
+(examples-for explain-mac
+  ("does nothing if n is zero"
+   (explain-mac 0 '(afn (a) (+ 2 a)))
+   (afn (a) (+ 2 a)))
+
+  ("expands once for n = 1"
+   (explain-mac 1 '(afn (a) (+ 2 a)))
+   (rfn self (a) (+ 2 a)))
+
+  ("expands twice for n = 2"
+   (explain-mac 2 '(afn (a) (+ 2 a)))
+   (let self nil (assign self (fn (a) (+ 2 a)))))
+
+  ("expands thrice for n = 3"
+   (explain-mac 3 '(afn (a) (+ 2 a)))
+   (with (self nil) (assign self (fn (a) (+ 2 a)))))
+
+  ("expands four times for n = 4"
+   (explain-mac 4 '(afn (a) (+ 2 a)))
+   ((fn (self) (assign self (fn (a) (+ 2 a)))) 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)))

data/lib/lisp/tests/foundation-test.nydp

@@ -1,223 +1,57 @@
-(register-test '(suite "Foundation Tests"
-  (suite "maths"
-    ("sqrt"
-      (sqrt 6.25)
-      2.5))
-
-  (suite "strings"
-    (suite "string-split"
-      ("splits a string using given expression"
-        (string-split "a and b and c and d" " and ")
-        ("a" "b" "c" "d")))
-
-    (suite "string-replace"
-      ("replaces parts of a string with the given replacement"
-        (string-replace "and" "or" "a and b and c and d")
-        "a or b or c or d"))
-
-    (suite "regexp"
-      ("replace with regexp"
-       (string-replace "and|or" "x" "a and b or c and d")
-       "a x b x c x d")
-
-      ("match with regexp"
-       (let m (string-match "a and b and c and d" "and")
-         (list m.match m.captures))
-       ("and" nil))
-
-      ("no match with regexp"
-       (let m (string-match "a and b and c and d" "not-in-string")
-         (list m.match m.captures))
-       (nil nil))
-
-      ("match with regexp and capturing groups"
-       (let m (string-match "  foo\b    bar" "(^\\s+)")
-         (list m.match m.captures))
-       ("  " ("  ")))
-      )
-
-
-    (suite "type-of"
-      ("returns 'fn for builtin function"
-        (type-of car)
-        fn)
-
-      ("returns 'fn for nydp-defined function"
-        (type-of register-test)
-        fn)
-
-      ("returns 'fn for inline function"
-        (type-of (fn (x) (p x)))
-        fn)
-
-      ("returns 'string"
-        (type-of "foobar")
-        string)
-
-      ("returns 'hash for new hash"
-        (type-of (hash))
-        hash)
-
-      ("returns 'hash for hash literal"
-        (type-of { a 1 b 2})
-        hash)
-
-      ("returns 'number for an integer"
-        (type-of 42)
-        number)
-
-      ("returns 'number for a float"
-        (type-of 4.2)
-        number)
-
-      ("interpolates a string"
-        "foobar ~(+ 1 2) you know"
-        "foobar 3 you know")
-
-      ("returns 'string for an interpolated string"
-        (type-of "foobar ~(+ 1 2)")
-        string)))
-
-  (suite "eq?"
-         ("true for two empty symbols"
-          (eq? '|| '||)
-          t)
-
-         ("nil for two different symbols"
-          (eq? 'foo 'bar)
-          nil))
-
-  (suite "truth and nil"
-         ("t is boolean true"
-          (if t "hello" "goodbye")
-          "hello")
-
-         ("nil is boolean false"
-          (if nil "hello" "goodbye")
-          "goodbye")
-
-         ("t is Truth"
-          (type-of t)
-          truth)
-
-         ("nil is nil"
-          (type-of nil)
-          nil))
-
-  (suite "assignment with '="
-    ("assigns a symbol"
-      (pre-compile '(= this 'that))
-      (assign this 'that)))
-
-  (suite "argument default value"
-    ("is nil"
-     ( (fn (x y z) (list x y (car z))) 'a 'b )
-     (a b nil)))
-
-  (suite "hash"
-    ("hash-lookup"
-     (pre-compile 'a.b.c)
-     (hash-get (hash-get a 'b) 'c))
-
-    ("hash-lookup with dollar-syntax for function call"
-     (pre-compile '$a.b.c)
-     (hash-get (hash-get (a) 'b) 'c))
-
-    ("hash-lookup with embedded dollar-syntax for function call"
-     (pre-compile 'a.$b.c)
-     (hash-get (hash-get a (b)) 'c))
-
-    ("hash-lookup with embedded unquote"
-     (pre-compile 'a.,b.c)
-     (hash-get (hash-get a b) 'c))
-
-    ("hash assignment"
-     (pre-compile '(= a.b 42))
-     (hash-set a 'b 42))
-
-    ("hash assignment with unquote"
-     (pre-compile '(= a.,b 42))
-     (hash-set a b 42))
-
-    ("recursive hash assignment"
-     (pre-compile '(= a.b.c.d 42))
-     (hash-set (hash-get (hash-get a 'b) 'c) 'd 42))
-
-    ("recursive hash assignment with embedded unquote"
-     (pre-compile '(= a.b.,c.d 42))
-     (hash-set (hash-get (hash-get a 'b) c) 'd 42))
-
-    ("recursive hash assignment with prefix dollar-syntax"
-     (pre-compile '(= $a.b.,c.d 42))
-     (hash-set (hash-get (hash-get (a) 'b) c) 'd 42))
-
-    ("recursive hash assignment with embedded dollar-syntax"
-     (pre-compile '(= a.$b.,c.d 42))
-     (hash-set (hash-get (hash-get a (b)) c) 'd 42))
-
-    (suite "merge"
-      ("merge with symbol keys"
-       (let h (hash-merge { a 1 b 2 c 3 } { a 99 c 98 d 97 })
-            (list h.a h.b h.c h.d (hash-keys h) ))
-       (99 2 98 97 (a b c d )))
-
-      ("merge with mixed symbol and string and int keys"
-       (let h (hash-merge { a 1 "b" 2 3 'c } { a 99 b 98 3 "foo" })
-            (cons (hash-keys h) (mapx (hash-keys h) k h.,k)))
-       ((a "b" 3 b) 99 2 "foo" 98))))
-
-  (suite "isa"
-    ("t for 'pair for list"
-      (isa 'pair '(a b c))
-      t)
-    ("nil for 'pair for non-list"
-      (isa 'pair 42)
-      nil)
-    ("t for 'symbol for symbol"
-      (isa 'symbol 'foo)
-      t)
-    ("nil for 'symbol for non-symbol"
-      (isa 'symbol "foo")
-      nil)
-    ("t for 'string for string"
-      (isa 'string "foo")
-      t)
-    ("nil for 'string for string"
-      (isa 'string '(a b c))
-      nil))
-
-  (suite "Lists"
-    (suite "cons"
-      ("cons creates a list"
-        (cons 'a '(b c))
-        (a b c))
-
-      ("cons conses two strings"
-        (cons "a" "b")
-        ("a" . "b"))
-
-      ("len returns length of proper list"
-        (len (cons "a" (cons "b" nil)))
-        2)
-
-      ("type-of returns pair"
-        (type-of (cons "a" "b"))
-        pair))
-
-    (suite "car"
-      ("car of nil is nil"
-        (car nil)
-        nil)
-
-      ("car of empty list is nil"
-        (car '())
-        nil)
-
-      ("car - no need to quote empty list"
-        (car ())
-        nil)
-
-      ("car returns car of argument"
-        (car '(foo 12.34 "bar"))
-        foo)
-    ))))
+(examples-for sqrt
+  ("sqrt"
+   (sqrt 6.25)
+   2.5))
+
+(examples-for eq?
+  ("true for two empty symbols"
+   (eq? '|| '||)
+   t)
+
+  ("nil for two different symbols"
+   (eq? 'foo 'bar)
+   nil))
+
+(examples-for =
+  ("assigns a symbol"
+   (pre-compile '(= this 'that))
+   (assign this 'that)))
+
+(examples-for if
+  ("single-expr 'if is just the expr"
+   (pre-compile '(if a))
+   a)
+
+  ("two-expr 'if expands to 'cond"
+   (pre-compile '(if a b))
+   (cond a b))
+
+  ("three-expr 'if expands to 'cond"
+   (pre-compile '(if a b c))
+   (cond a b c))
+
+  ("four-expr 'if expands to nested 'cond"
+   (pre-compile '(if a b c d))
+   (cond a b (cond c d)))
+
+  ("five-expr 'if expands to nested 'cond"
+   (pre-compile '(if a b c d e))
+   (cond a b (cond c d e)))
+
+  ("t is boolean true"
+   (if t "hello" "goodbye")
+   "hello")
+
+  ("nil is boolean false"
+   (if nil "hello" "goodbye")
+   "goodbye"))
+
+(examples-for unless
+  ("expands to negative 'if"
+   (pre-compile '(unless x y z))
+   (cond (no x) ((fn () y z)))))
+
+(examples-for fn
+  ("argument default value is nil"
+   ( (fn (x y z) (list x y (car z))) 'a 'b )
+   (a b nil)))

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

@@ -0,0 +1,41 @@
+(examples-for hash-merge
+  ("merge with symbol keys"
+   (let h (hash-merge { a 1 b 2 c 3 } { a 99 c 98 d 97 })
+     (list h.a h.b h.c h.d (hash-keys h) ))
+   (99 2 98 97 (a b c d )))
+
+  ("merge with mixed symbol and string and int keys"
+   (let h (hash-merge { a 1 "b" 2 3 'c } { a 99 b 98 3 "foo" })
+     (cons (hash-keys h) (mapx (hash-keys h) k h.,k)))
+   ((a "b" 3 b) 99 2 "foo" 98)))
+
+(examples-for hash-key?
+  ("detects key presence"
+   (hash-key? { foo 1 bar 2 } 'foo)
+   t)
+
+  ("detects key absence"
+   (hash-key? { foo 1 bar 2 } 'zed)
+   nil))
+
+(examples-for brace-list
+  ("build a hash table from brace-list syntax"
+   (let hsh { foo 1 bar 2 }
+     (list 'foo hsh.foo 'bar hsh.bar))
+   (foo 1 bar 2))
+
+  ("single-item brace list is just the thing itself"
+   (let zi 10 "finds the ~{zi}th item")
+   "finds the 10th item")
+
+  ("unquotes hash keys"
+   (with (zi 'foo chi 'bar yi 'grr)
+         (let hsh { ,zi 10 ,chi 11 ,yi 12 }
+           (list zi hsh.foo chi hsh.bar yi hsh.grr)))
+   (foo 10 bar 11 grr 12))
+
+  ("allows literal and invocation hash keys"
+   (with (zi "hello" chi "world")
+         (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)))

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

@@ -0,0 +1,7 @@
+(examples-for isa
+  ("t for 'pair for list"           (isa 'pair '(a b c))   t)
+  ("nil for 'pair for non-list"     (isa 'pair 42)         nil)
+  ("t for 'symbol for symbol"       (isa 'symbol 'foo)     t)
+  ("nil for 'symbol for non-symbol" (isa 'symbol "foo")    nil)
+  ("t for 'string for string"       (isa 'string "foo")    t)
+  ("nil for 'string for string"     (isa 'string '(a b c)) nil))

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

@@ -0,0 +1,11 @@
+(examples-for len
+  ("nonzero"  (len "foo-bar")  7)
+  ("zero"     (len "")         0)
+
+  ("ignores backslash-escaped interpolation symbol"
+   (len "hello \~world")
+   12)
+
+  ("len returns length of proper list"
+   (len (cons "a" (cons "b" nil)))
+   2))

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

@@ -1,75 +1,110 @@
-(register-test
- '(suite "List Tests"
-         (suite "joinlists"
-                ("joins one list to another"
-                 (joinlists '(a b c) '(x y z))
-                 (a b c x y z))
-
-                ("joins three lists"
-                 (joinlists '(a b c) '(x y z) '(1 2 3))
-                 (a b c x y z 1 2 3)))
-
-         (suite "firstn"
-                ("returns no items for n = 0"
-                 (firstn 0 '(a b c d))
-                 nil)
-
-                ("returns first n items for n > 0 and n < size of list"
-                 (firstn 3 '(a b c d e))
-                 (a b c))
-
-                ("returns all items for n > size of list"
-                 (firstn 33 '(a b c d e))
-                 (a b c d e)))
-
-         (suite "nthcdr"
-                ("returns all items for n = 0"
-                 (nthcdr 0 '(a b c d))
-                 (a b c d))
-
-                ("returns nth cdr of list for n > 0 and n < size of list"
-                 (nthcdr 3 '(a b c d e))
-                 (d e))
-
-                ("returns nothing for n > size of list"
-                 (nthcdr 33 '(a b c d e))
-                 nil))
-
-         (suite "car/cdr combinations"
-                ("caar of list"   (caar '((x y) (1 2)))   x     )
-                ("caar of nil"    (caar nil)              nil   )
-                ("cadr of list"   (cadr '((x y) (1 2)))   (1 2) )
-                ("cadr of nil"    (cadr nil)              nil   )
-                ("cdar of list"   (cdar '((x y) (1 2)))   (y)   )
-                ("cdar of nil"    (cdar nil)              nil   )
-                ("cddr of list"   (cddr '(x y 1 2))       (1 2) )
-                ("cddr of nil"    (cddr nil)              nil   )
-                ("cadar of list"  (cadar '((x y) (1 2)))  y     )
-                ("cadar of nil"   (cadar nil)             nil   )
-                ("caddr of list"  (caddr '(x y 1 2))      1     )
-                ("caddr of nil"   (caddr nil)             nil   )
-                ("cdddr of list"  (cdddr '(x y 1 2))      (2)   )
-                ("cdddr of nil"   (cdddr nil)             nil   )
-                ("cadddr of list" (cadddr '(x y 1 2 3))   2     )
-                ("cadddr of nil"  (cadddr nil)            nil   ))
-
-         (suite "proper?"
-                ("t for a proper list"
-                 (proper? '(a b c d))
-                 t)
-
-                ("t for a proper list, even if we write it funny"
-                 (proper? '(a b . (c d)))
-                 t)
-
-                ("t for a proper list, even if we write it funny with nil"
-                 (proper? '(a b . nil))
-                 t)
-
-                ("nil for an improper list"
-                 (proper? '(a b . c))
-                 nil)
-
-                ("nil for a very improper list"
-                 (proper? '(a b . (c . d)))
-                 nil))))
+(examples-for pairs
+  ("'pair breaks a list into pairs"
+   (pairs '(1 a 2 b 3 c))
+   ((1 a) (2 b) (3 c))))
+
+(examples-for rev
+  ("'rev reverses a list"
+   (rev '(a b c))
+   (c b a))
+
+  ("'rev handles nil"
+   (rev nil)
+   nil)
+
+  ("'rev doesn't recurse"
+   (rev '(a b (c d e) f g))
+   (g f (c d e) b a)))
+
+(examples-for flatten
+  ("'flatten returns a flat list of things"
+   (flatten '((poo (x) (* x x)) (1 2 3)))
+   (poo x * x x 1 2 3)))
+
+(examples-for joinlists
+  ("joins one list to another"
+   (joinlists '(a b c) '(x y z))
+   (a b c x y z))
+
+  ("joins three lists"
+   (joinlists '(a b c) '(x y z) '(1 2 3))
+   (a b c x y z 1 2 3)))
+
+(examples-for firstn
+  ("returns no items for n = 0"
+   (firstn 0 '(a b c d))
+   nil)
+
+  ("returns first n items for n > 0 and n < size of list"
+   (firstn 3 '(a b c d e))
+   (a b c))
+
+  ("returns all items for n > size of list"
+   (firstn 33 '(a b c d e))
+   (a b c d e)))
+
+(examples-for nthcdr
+  ("returns all items for n = 0"
+   (nthcdr 0 '(a b c d))
+   (a b c d))
+
+  ("returns nth cdr of list for n > 0 and n < size of list"
+   (nthcdr 3 '(a b c d e))
+   (d e))
+
+  ("returns nothing for n > size of list"
+   (nthcdr 33 '(a b c d e))
+   nil))
+
+(examples-for caar
+  ("caar of list"   (caar '((x y) (1 2)))   x     )
+  ("caar of nil"    (caar nil)              nil   ))
+
+(examples-for cadr
+  ("cadr of list"   (cadr '((x y) (1 2)))   (1 2) )
+  ("cadr of nil"    (cadr nil)              nil   ))
+
+(examples-for cdar
+  ("cdar of list"   (cdar '((x y) (1 2)))   (y)   )
+  ("cdar of nil"    (cdar nil)              nil   ))
+
+(examples-for cddr
+  ("cddr of list"   (cddr '(x y 1 2))       (1 2) )
+  ("cddr of nil"    (cddr nil)              nil   ))
+
+(examples-for cadar
+  ("cadar of list"  (cadar '((x y) (1 2)))  y     )
+  ("cadar of nil"   (cadar nil)             nil   ))
+
+(examples-for caddr
+  ("caddr of list"  (caddr '(x y 1 2))      1     )
+  ("caddr of nil"   (caddr nil)             nil   ))
+
+(examples-for cdddr
+  ("cdddr of list"  (cdddr '(x y 1 2))      (2)   )
+  ("cdddr of nil"   (cdddr nil)             nil   ))
+
+(examples-for cadddr
+  ("cadddr of list" (cadddr '(x y 1 2 3))   2     )
+  ("cadddr of nil"  (cadddr nil)            nil   ))
+
+(examples-for proper?
+  ("t for a proper list"
+   (proper? '(a b c d))
+   t)
+
+  ("t for a proper list, even if we write it funny"
+   (proper? '(a b . (c d)))
+   t)
+
+  ("t for a proper list, even if we write it funny with nil"
+   (proper? '(a b . nil))
+   t)
+
+  ("nil for an improper list"
+   (proper? '(a b . c))
+   nil)
+
+  ("nil for a very improper list"
+   (proper? '(a b . (c . d)))
+   nil))