Thanks to both of you for your answers; they're very helpful.
I had to take some time to digest them (and my day job got in the way) but I have a few follow-up remarks/questions:
1. is clear now; however I get the feeling that I need to play with macros more to get a real feeling for when and why they are as useful as many people say.
2. refering to fallintothis' answer, do you mean inefficient in execution (why, and as opposed to what?) or simply a bit of a drag to type out?
referring to akkartik's response, It's not that I thought the definition of pair breaks anything, just that it produces non-useful behavior (my original wording of inconsistent probably doesn't describe well what I mean);
Is there a use case where you would pass a function to pair, but in the event of an odd number of elements, want the last element simply returned as a one-element list instead of the result of calling the function on it?
5. I get that it should still be optimized, but it just seems strange to me to implement it recursively when that's not the most straightforward (to me at least) way to define a loop macro.
Is the rule in Arc (or lisp in general) that preference is given to functional implementations wherever possible, or am I reading too much into this?
6. Both your explanations seemed strange to me at first (since in other languages, global variables are technically different from normal (is there a term for this?) variables). But it makes sense to me when you consider lisp's lexical scope (which the arc tutorial unfortunately doesn't cover other than mentioning closures); is a global variable simply one that is defined at the highest level of the code, i.e. only enclosed within one (the outermost) pair of parentheses?
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"
