1. My dirty little secret: after enough experience with macros, they seem pretty "normal" to me. They're a natural way to do what they do, so when I pause to write a macro, it doesn't even seem like some deep magic of an ultra-language. There's no need to be a zealot to appreciate macros, though their utility is apparent with time. For example, the definition of the while macro
((rfn gs1722 (gs1723)
(when gs1723
(-- x)
(gs1722 (> x 10))))
(> x 10))
before it gets evaluated. We didn't even need to bake a while loop into the language -- we can define it using the macro.
It's not impossible to write while without macros. For instance, in the Factor language, while works by using anonymous functions instead of unevaluated code. It's similar to the Arc function
In the map version we first pair up the elements into a new list, then iterate through that to add the pairs, putting those into yet another list. We're doing twice the work. If pair worked right, we'd only go through '(1 3 5 7 9) once, adding the pairs of numbers as we went.
5. Not reading too much into it: functional solutions are generally preferred. My best guess says it's a matter of taste. To me, state is weird to reason about, but recursion is straightforward. Also consider that, to implement a loop statefully, you'd need something like goto. But we still have first-class functions, so if we can model loops as tail calls at no cost to efficiency, then we don't need to add goto to Arc. It keeps the language simpler.
This isn't the case in all Lisps. For example, Common Lisp has tagbody wherein you can use go, which is a goto statement. See http://sunsite.univie.ac.at/textbooks/cltl/clm/node91.html. Implementations often use it for, e.g., the loop macro (which is quite different from Arc's, but still loops).
6. Yes, global variables are the ones "at the top".
arc> (= global* 10)
10
Local variables (the opposite of global variables) only live inside a block of code (i.e., locally), and can be different values during different function calls.
arc> (def f (local)
(+ global* local))
#<procedure: f>
arc> (f 10) ; during execution, 'local' is bound to 10 inside 'f'
20
arc> (f 123) ; during execution, 'local' is bound to 123 inside 'f'
133
Global variables live everywhere (i.e., globally), and tend to change less frequently -- you set them explicitly to some value.
arc> global*
10
arc> local ; isn't around outside of 'f'
Error: "reference to undefined identifier: _local"
arc> (= global* 5)
5
arc> (f 10)
15
arc> (f 123)
128
You can alter local variables, too, but they still only live locally.
arc> (let local 5
(= local 10)
(+ global* local))
15
arc> global*
5
arc> local
Error: "reference to undefined identifier: _local"
