diff options
Diffstat (limited to 'init-macros.fnl')
| -rw-r--r-- | init-macros.fnl | 183 |
1 files changed, 124 insertions, 59 deletions
diff --git a/init-macros.fnl b/init-macros.fnl index 034b9aa..0e45c77 100644 --- a/init-macros.fnl +++ b/init-macros.fnl @@ -29,10 +29,6 @@ SOFTWARE.") (fn string? [x] (= :string (type x))) -;;; ns - -(var current-ns nil) - (fn has? [tbl sym] ;; searches for the given symbol in a table. (var has false) @@ -40,6 +36,97 @@ SOFTWARE.") (set has (= sym elt))) has) +;;; ns + +(local cljlib-namespaces + {} + ;; A map of files and their respective namespaces. Each entry is a + ;; filename followed by a table with two keys: `:current` and + ;; `:known`. The second one holds all namespaces that were defined + ;; for the file via the `ns` macro, and thus are available to switch + ;; with the `in-ns` macro. The `:current` key represents currently + ;; active namespace that is used for binding via the `def` macro and + ;; its derivatives. + ) + +(fn current-file [ast] + (. (ast-source ast) :filename)) + +(fn create-ns [name] + (let [file (current-file name)] + (when (not (. cljlib-namespaces file)) + (tset cljlib-namespaces file {:known {}})) + (tset cljlib-namespaces file :current name) + (tset cljlib-namespaces file :known (tostring name) true)) + `(setmetatable + {} + {:__name "namespace" + :__fennelview #(do ,(: "#<namespace: %s>" :format (tostring name)))})) + +(fn known-ns? [name] + (let [file (current-file name)] + (?. cljlib-namespaces file :known (tostring name)))) + +(fn current-ns [ast] + (?. cljlib-namespaces (current-file ast) :current)) + +(fn in-ns [name] + "Sets the compile-time variable `cljlib-namespaces` to the given `name`. +Affects such macros as `def`, `defn`, which will bind names to the +specified namespace. + +# Examples +Creating several namespaces in the file, and defining functions in each: + +```fennel +(ns a) +(defn f [] \"f from a\") +(ns b) +(defn f [] \"f from b\") +(in-ns a) +(defn g [] \"g from a\") +(in-ns b) +(defn g [] \"g from b\") + +(assert-eq (a.f) \"f from a\") +(assert-eq (b.f) \"f from b\") +(assert-eq (a.g) \"g from a\") +(assert-eq (b.g) \"g from b\") +``` + +Note, switching namespaces in the REPL doesn't affect non-namespaced +local bindings. In other words, when defining a local with `def`, a +bot a local binding and a namespaced binding are created, and +switching current namespace won't change the local binding: + +``` +>> (ns foo) +nil +>> (def x 42) +nil +>> (ns bar) +nil +>> (def x 1337) +nil +>> (in-ns foo) +#<namespace: foo> +>> x ; user might have expected to see 42 here +1337 +>> foo.x +42 +>> bar.x +1337 +``` + +Sadly, Fennel itself has no support for namespace switching in REPL, +so this feature can be only partially emulated by the cljlib library. +" + (assert-compile (known-ns? name) + (: "no such namespace: %s" :format (tostring name)) + name) + (tset cljlib-namespaces (current-file name) :current name) + name) + (fn ns [name commentary requirements] "Namespace declaration macro. Accepts the `name` of the generated namespace, and creates a local @@ -73,10 +160,11 @@ Which is equivalent to: Note that when no `:as` alias is given, the library will be named after the innermost part of the require path, i.e. `some.lib` is -transformed to `lib`." - (set current-ns name) +transformed to `lib`. + +See `in-ns` on how to switch namespaces." (let [bind-table [name] - require-table [{}] + require-table [(create-ns name)] requirements (if (string? commentary) requirements commentary)] @@ -110,30 +198,6 @@ transformed to `lib`." (values ,require-table (comment ,commentary))) `(local ,bind-table ,require-table)))) -(fn in-ns [name] - "Sets the compile time variable `current-ns` to the given `name`. -Affects such macros as `def`, `defn`, which will bind names to the -specified namespace. - -# Examples - -```fennel -(ns a) -(defn f [] \"f from a\") -(ns b) -(defn f [] \"f from b\") -(in-ns a) -(defn g [] \"g from a\") -(in-ns b) -(defn g [] \"g from b\") - -(assert-eq (a.f) \"f from a\") -(assert-eq (b.f) \"f from b\") -(assert-eq (a.g) \"g from a\") -(assert-eq (b.g) \"g from b\") -```" - (set current-ns name)) - ;;; def (fn def [...] @@ -142,19 +206,20 @@ namespace set with the `ns` macro, unless `:private` was passed before the binding name. Accepts the `name` to be bound and the `initializer` expression. `meta` can be either an associative table where keys are strings, or a string representing a key from the table. If a sole -string is given, it's value is set to `true` in the meta table." +string is given, its value is set to `true` in the meta table." :fnl/arglist [([name initializer]) ([meta name initializer])]} (match [...] (where (or [:private name val] [{:private true} name val])) `(local ,name ,val) [name val] - (if (in-scope? current-ns) - `(local ,name - (let [v# ,val] - (tset ,current-ns ,(tostring name) v#) - v#)) - `(local ,name ,val)))) + (let [namespace (current-ns name)] + (if (in-scope? namespace) + `(local ,name + (let [v# ,val] + (tset ,namespace ,(tostring name) v#) + v#)) + `(local ,name ,val))))) ;;; defn @@ -303,7 +368,7 @@ list: The same syntax applies to multi-arity version. -(pre and post checks are not yet implemented)" +(pre- and post-checks are not yet implemented)" :fnl/arglist [([name doc-string? [params*] pre-post? body]) ([name doc-string? ([params*] pre-post? body)+])]} (let [{: name? : doc? : args : pre-post? : body : multi-arity?} @@ -419,10 +484,10 @@ The same syntax applies to multi-arity version. (fn defn [name ...] {:fnl/docstring - "Same as (def name (fn* name docstring? [params*] pre-post? exprs*)) -or (def name (fn* name docstring? ([params*] pre-post? exprs*)+)) with -any doc-string or attrs added to the function metadata. Accepts -`name` wich will be used to refer to a function in the current + "Same as `(def name (fn* name docstring? [params*] pre-post? exprs*))` +or `(def name (fn* name docstring? ([params*] pre-post? exprs*)+))` +with any doc-string or attrs added to the function metadata. Accepts +`name` which will be used to refer to a function in the current namespace, and optional `doc-string?`, a vector of function's `params*`, `pre-post?` conditions, and the `body` of the function. The body is wrapped in an implicit do. See `fn*` for more info." @@ -433,13 +498,13 @@ The body is wrapped in an implicit do. See `fn*` for more info." (fn defn- [name ...] {:fnl/docstring - "Same as (def :private name (fn* name docstring? [params*] pre-post? -exprs*)) or (def :private name (fn* name docstring? ([params*] -pre-post? exprs*)+)) with any doc-string or attrs added to the -function metadata. Accepts `name` wich will be used to refer to a -function, and optional `doc-string?`, a vector of function's `params*`, -`pre-post?` conditions, and the `body` of the function. The body is -wrapped in an implicit do. See `fn*` for more info." + "Same as `(def :private name (fn* name docstring? [params*] pre-post? +exprs*))` or `(def :private name (fn* name docstring? ([params*] +pre-post? exprs*)+))` with any doc-string or attrs added to the +function metadata. Accepts `name` which will be used to refer to a +function, and optional `doc-string?`, a vector of function's +`params*`, `pre-post?` conditions, and the `body` of the function. +The body is wrapped in an implicit do. See `fn*` for more info." :fnl/arglist [([name doc-string? [params*] pre-post? body]) ([name doc-string? ([params*] pre-post? body)+])]} (assert-compile (sym? name) "expected a function name, use `fn*` for anonymous functions" name) @@ -470,7 +535,7 @@ to the value of `test`." (fn if-let [[name test] if-branch else-branch ...] {:fnl/docstring "When `test` is logical `true`, evaluates the `if-branch` with `name` -bound to the value of `test`. Otherwise evaluates the `else-branch`" +bound to the value of `test`. Otherwise, evaluates the `else-branch`" :fnl/arglist [[name test] if-branch else-branch]} (assert-compile (= 0 (select "#" ...)) "too many arguments to if-let" ...) `(let [val# ,test] @@ -490,7 +555,7 @@ the value of `test`." (fn if-some [[name test] if-branch else-branch ...] {:fnl/docstring "When `test` is not `nil`, evaluates the `if-branch` with `name` -bound to the value of `test`. Otherwise evaluates the `else-branch`" +bound to the value of `test`. Otherwise, evaluates the `else-branch`" :fnl/arglist [[name test] if-branch else-branch]} (assert-compile (= 0 (select "#" ...)) "too many arguments to if-some" ...) `(let [val# ,test] @@ -561,7 +626,7 @@ By default, multifunction has no multimethods, see (fn defmethod [multifn dispatch-val ...] {:fnl/arglist [multi-fn dispatch-value fnspec] - :fnl/docstring "Attach new method to multi-function dispatch value. accepts the + :fnl/docstring "Attach new method to multi-function dispatch value. Accepts the `multi-fn' as its first argument, the `dispatch-value' as second, and `fnspec' - a function tail starting from argument list, followed by function body as in `fn*'. @@ -597,14 +662,14 @@ Multi-arity function tails are also supported: (defmulti foo (fn* ([x] [x]) ([x y] [x y]))) -(defmethod foo [10] [_] (print \"I've knew I'll get 10\")) -(defmethod foo [10 20] [_ _] (print \"I've knew I'll get both 10 and 20\")) +(defmethod foo [10] [_] (print \"I knew I'll get 10\")) +(defmethod foo [10 20] [_ _] (print \"I knew I'll get both 10 and 20\")) (defmethod foo :default ([x] (print (.. \"Umm, got\" x))) ([x y] (print (.. \"Umm, got both \" x \" and \" y)))) ``` -Calling `(foo 10)` will print `\"I've knew I'll get 10\"`, and calling -`(foo 10 20)` will print `\"I've knew I'll get both 10 and 20\"`. +Calling `(foo 10)` will print `\"I knew I'll get 10\"`, and calling +`(foo 10 20)` will print `\"I knew I'll get both 10 and 20\"`. However, calling `foo' with any other numbers will default either to `\"Umm, got x\"` message, when called with single value, and `\"Umm, got both x and y\"` when calling with two values. @@ -870,7 +935,7 @@ specified, an implicit catch-all clause is created. `body*', and inner expressions of `catch-clause*', and `finally-clause?' are wrapped in implicit `do'. -Finally clause is optional, and written as (finally body*). If +The `finally` clause is optional, and written as (finally body*). If present, it must be the last clause in the `try' form, and the only `finally' clause. Note that `finally' clause is for side effects only, and runs either after succesful run of `try' body, or after any @@ -957,7 +1022,7 @@ the other tests or exprs. `(cond)` returns nil." "lazy-seq.init-macros"))) (fn lazy-seq [...] - {:fnl/docstring "Takes a `body` of expressions that returns an sequence, table or nil, + {:fnl/docstring "Takes a `body` of expressions that returns a sequence, table or nil, and yields a lazy sequence that will invoke the body only the first time `seq` is called, and will cache the result and return it on all subsequent `seq` calls. See also - `realized?`" |