release v1.0.0

Almost complete rewrite of the library, complete with lazy sequences, immutable tables, transients, transducers, better equality semantics, and more correct code generation in macros.

1 files changed, 64 insertions, 75 deletions

diff --git a/tests/fn.fnl b/tests/fn.fnl
index 2cbe94b..83c45f5 100644
--- a/tests/fn.fnl
+++ b/tests/fn.fnl
@@ -1,84 +1,73 @@
 (require-macros :fennel-test)
 (require-macros :init-macros)
+(local (meta? fennel) (pcall require :fennel))
 
-(deftest test-fn*
-  (testing "fn* meta"
-    (fn* f
-      "single arity"
-      [x] x)
-    (assert-eq (meta f)
-               {:fnl/docstring "single arity"
-                :fnl/arglist ["[x]"]})
-    (fn* f
-      "single empty arity"
-      [])
-    (assert-eq (meta f)
-               {:fnl/docstring "single empty arity"
-                :fnl/arglist ["[]"]})
-    (fn* f
-      "multiarity with single entry"
-      ([x] x))
-    (assert-eq (meta f)
-               {:fnl/docstring "multiarity with single entry"
-                :fnl/arglist ["[x]"]})
-    (fn* f
-      "multiarity"
-      ([x] x)
-      ([x y] (+ x y)))
-    (assert-eq (meta f)
-               {:fnl/docstring "multiarity"
-                :fnl/arglist ["([x])"
-                              "([x y])"]})
-    (fn* f
-      "multiarity with one empty arity"
-      ([])
-      ([x y] (+ x y)))
-    (assert-eq (meta f)
-               {:fnl/docstring "multiarity with one empty arity"
-                :fnl/arglist ["([])"
-                              "([x y])"]})
-    (fn* f
-      "multiarity with two or more arity"
-      ([x] x)
-      ([x y] (+ x y))
-      ([x y & z] (+ x y)))
-    (assert-eq (meta f)
-               {:fnl/docstring "multiarity with two or more arity"
-                :fnl/arglist ["([x])"
-                              "([x y])"
-                              "([x y & z])"]}))
-
-  (testing "fn* doc destructuring"
-    (fn* f [[a b c]])
-    (assert-eq (meta f)
-               {:fnl/arglist ["[[a b c]]"]})
-    (fn* f ([[a b c]]))
-    (assert-eq (meta f)
-               {:fnl/arglist ["[[a b c]]"]})
-    (fn* f ([[a b c]]) ([{: a}]) ([[{:a [a b c]}]]))
-    (assert-eq (meta f)
-               {:fnl/arglist ["([[a b c]])"
-                              "([{:a a}])"
-                              "([[{:a [a b c]}]])"]}))
+(fn meta [x]
+  {:fnl/docstring (fennel.metadata:get x :fnl/docstring)
+   :fnl/arglist (fennel.metadata:get x :fnl/arglist)})
 
-  (testing "fn* methods"
-    (local ns {:a 1 :b 2})
-
-    (fn* ns:foo []
-      (+ self.a self.b))
-    (assert-eq (ns:foo) 3)
-    (assert-not (pcall #(ns:foo 1)))
-    (assert-not (pcall #(ns:foo 1 2)))
+(deftest test-fn*
+  (when meta?
+    (testing "fn* meta"
+      (defn f
+        "single arity"
+        [x] x)
+      (assert-eq {:fnl/docstring "single arity"
+                  :fnl/arglist ["[x]"]}
+                 (meta f))
+      (defn f
+        "single empty arity"
+        [])
+      (assert-eq {:fnl/docstring "single empty arity"
+                  :fnl/arglist ["[]"]}
+                 (meta f))
+      (defn f
+        "multiarity with single entry"
+        ([x] x))
+      (assert-eq {:fnl/docstring "multiarity with single entry"
+                  :fnl/arglist ["([x])"]}
+                 (meta f))
+      (defn f
+        "multiarity"
+        ([x] x)
+        ([x y] (+ x y)))
+      (assert-eq {:fnl/docstring "multiarity"
+                  :fnl/arglist ["([x])"
+                                "([x y])"]}
+                 (meta f))
+      (defn f
+        "multiarity with one empty arity"
+        ([])
+        ([x y] (+ x y)))
+      (assert-eq {:fnl/docstring "multiarity with one empty arity"
+                  :fnl/arglist ["([])"
+                                "([x y])"]}
+                 (meta f))
+      (defn f
+        "multiarity with two or more arity"
+        ([x] x)
+        ([x y] (+ x y))
+        ([x y & z] (+ x y)))
+      (assert-eq {:fnl/docstring "multiarity with two or more arity"
+                  :fnl/arglist ["([x])"
+                                "([x y])"
+                                "([x y & z])"]}
+                 (meta f))))
 
-    (fn* ns:bar
-      ([x] (+ self.a x))
-      ([x y] (+ self.b x y)))
-    (assert-eq (ns:bar -1) 0)
-    (assert-eq (ns:bar 10 20) 32)
-    (assert-not (pcall #(ns:bar)))
-    (assert-not (pcall #(ns:bar 1 2 3))))
+  (testing "defn doc destructuring"
+    (defn f [[a b c]])
+    (assert-eq {:fnl/arglist ["[[a b c]]"]}
+               (meta f))
+    (defn f ([[a b c]]))
+    (assert-eq {:fnl/arglist ["([[a b c]])"]}
+               (meta f))
+    (defn f ([[a b c]]) ([{: a} b]) ([[{:a [a b c]}] d e]))
+    (assert-eq {:fnl/arglist ["([[a b c]])"
+                              "([{:a a} b])"
+                              "([[{:a [a b c]}] d e])"]}
+               (meta f)))
 
-  (testing "fn* anonymous calls"
+  (testing "defn anonymous calls"
     (assert-eq ((fn* [])) (values))
     (assert-eq ((fn* [] nil)) nil)
     (assert-eq ((fn* [x] x) 5) 5)