Replacement require-macros form

[technomancy]

After some discussion on the #fennel freenode channel it was
observed that the current macro and special calls could be
problematic on larger codebases because they are global.

I started thinking about what a macro system would look like which
used the existing module system and didn't affect global compiler
state, and I came up with the require-macros form.

;; main.fnl
(require-macros "mymacros")

(defn add-seven-then-multiply-by-a-hundred [x]
  (-> x (+ 7) (* 100)))

(print add-seven-then-multiply-by-a-hundred 93)

;; mymacros.fnl
{"->" (fn [val ...]
        (each [_ elt (pairs [...])]
          (table.insert elt 2 val)
          (set elt.n (+ 1 elt.n))
          (set val elt))
        val)
 "defn" (fn [name args ...]
          (list (sym "set") name
                (list (sym "fn") args ...)))}

This allows you to import macros just for the scope of a single file
(or if you really want to, for the scope of a single function). The
mymacros.fnl file would be loaded in the same kind context as
eval-compiler currently works.

I think it's comprehensive enough that it could replace the existing
macro, special, and eval-compiler forms, but I'll admit I
haven't thought thru the implications of that fully. Maybe special
and eval-compiler are still needed in some contexts?

What do you think?

[bakpakin]

I think this a good start. I have never liked the clojurescript idea of require-macros, but it does keep macros modular. I would eventually like require-macros to look more like normal fennel.

I think that the macro/extension system is overly complicated, but I think I would like to keep eval-compiler no matter what. While not often needed, it can be used to extend the compiler in pretty much arbitrary ways.

Perhaps the special special form could be dropped though.

[technomancy]

Thanks.

I would eventually like require-macros to look more like normal fennel.

Can you go into more detail here? As far as I'm concerned the modules loaded by `require-macros` are normal Fennel; the only difference is a few extra entries in the environment, which is the same as how `eval-compiler` works. Do you mean you'd like to allow them to exist in the same file instead of requiring module isolation?

I think that the macro/extension system is overly complicated, but I think I would like to keep eval-compiler no matter what.

That makes sense. Originally I was thinking there would be no need for new specials outside what ships with Fennel, because the only things that couldn't be done as a macro would be things that emitted Lua keywords, and there are only a known fixed set of those. But new additions could be added to Lua, or implementation-specific extensions that might only make sense to emit in, say, erlua or luaj. Or crazy things like "for the purposes of this repl session, replace `local` with `set`". So keeping `eval-compiler` makes sense. But yeah, `special` is unnecessary when you consider that `_SPECIALS` is in scope inside `eval-compiler`.

[bakpakin]

Can you go into more detail here? As far as I'm concerned the modules
loaded by require-macros are normal Fennel; the only difference is a
few extra entries in the environment, which is the same as how
eval-compiler works.

I was thinking more along the lines of looking like common lisp, with a defmacro kind of syntax, but with lexical scoping. I guess originally I had envisioned macros and functions living along side one another in the same file, but that was never set in stone.

Something like:

(do
  (defmacro mymac [x] (list (sym "if") x x))
  (mymac :hi))

Which would expand to

(do
  (if :hi :hi))

Without modifying the environment.