Second, in Lexicons.pdf, you write the following about hygiene:

"The solution, in a nutshell, is: Within a backquote, precede any function call that you want to be non-shadowable with a comma."

I find this rather ironic considering all the ado on the forum about hygienic macros. (If this works then why did people both writing all those posts about hygiene? Not that I'm saying it doesn't...)

http://arclanguage.org/item?id=3422 http://arclanguage.org/item?id=2962 http://arclanguage.org/item?id=886

So does it really work? (And if it works is it the Right Thing to do?) I suppose there is no possible way to shadow foo in

  (let foo (fn args (apply prs "foo:" args))
    (mac bar args `(,foo ,@args)))

  (mac baz args `(prs "baz:" ,@args)) ; would do this in a let if macros were first class
  (mac bad args `(,baz ,@args))

And if this is the Right Way to fix hygiene, should macro writers be expected to do this for every single macro they ever write?

Doesn't work in Arc2, but works in Anarki. Also doesn't work with macros, as you say. Macros aren't as big a deal however, because they cannot be shadowed by let or def, only by other macros with the same name.

While I find this an interesting approach, one problem I see is that this only works as long as Arc is an interpreter. Embedding foo into the s-expr mixes up runtime values (the function foo) and expand-time values (the s-expr).

In a compiler, you would have one runtime in which foo exists, and another runtime (the expand-time, at a higher "meta level") in which the s-expr exists, and the two runtimes can never meet -- they exist on different levels of the reflective tower.

(I am not entirely sure of this, and in any case it does not apply to Lexicons.)

It turns out that the current implementation has a serious bug, so at the moment the answer is no, it doesn't. But the situation appears to be salvageable.

> If this works then why did people both writing all those posts about hygiene?

A function, as distinct from a macro, has the property that when you call it, it will work the same way every time, even if you have provided some crazy bindings that shadow the functions it calls. For instance,

  (def prn args ; from arc.arc
    (do1 (apply pr args)
         (writec #\newline))

  (let pr (die)
    (prn 53)) ; doesn't die.

Non-hygienic macros do not have this property. That is the basic issue.

  (let pr [die]
    (prn 53)) ; doesn't die.