I've made the following changes to PS LOOP and pushed them on a branch called "loop" pending the fixing of the pretty-printer as we discussed a couple weeks ago.
These changes capture some idioms that were common in our code. They deviate from CL's LOOP (I could not bring myself to implement "BEING THE HASH-KEYS OF") in ways that are appropriate for JS semantics. Since PS LOOP was not fully compatible with CL's LOOP anyway, this is not much of a loss.
(1) Added a FOR..OF clause that iterates through the keys of a JS object. This translates to JS's "for k in obj" loops and corresponds roughly to "loop for k being the hash-keys of" in CL.
(ps (loop :for k :of obj :do (foo k)))
"for (var k in obj) { foo(k); };"
To bind both key and value, you specify a pair. (This is an icky bit of syntax but it feels like the least icky option of the ones I'm aware of.)
(ps (loop :for (k v) :of obj :do (foo k v)))
"for (var k in obj) { var v = obj[k]; foo(k, v); };"
Destructuring works on the value position just like they do everywhere else, so you can unpack an array. (Note that in this example the key variable isn't needed so we can put NIL in there.)
(ps (loop :for (nil (v1 v2)) :of obj :do (foo v1 v2)))
"for (var _js23095 in obj) { var _js23096 = obj[_js23095]; var v1 = _js23096[0]; var v2 = _js23096[1]; foo(v1, v2); };"
... or named properties (by using keywords):
(ps (loop :for (nil (:hello :world)) :of obj :do (foo hello world)))
"for (var _js23097 in obj) { var var23099 = obj[_js23097]; var hello23101 = var23099.hello; var world23102 = var23099.world; foo(hello23101, world23102); };"
Side note: To get the scoping right for parallel loop clauses is tricky because LOOP orders things "step test step test" where JS's FOR does "step step test test", meaning that the second step will be evaluated even if the first test fails. It got trickier with the introduction of FOR..OF, so I adopted a simpler implementation that has some advantages (much tighter generated loop code) but also some disadvantages: (a) it was a pain to support :INITIALLY clauses so I dropped them (I'd be surprised if anyone ever used it), and (b) complex loops sometimes require an extra temporary variable to track whether the loop is on its first iteration or not.
(2) There is now a MAP..TO clause that works like COLLECT only instead of building an array, builds an object mapping keys to values:
(ps (loop :for str :in strs :map str :to (length str)))
"(function () { var _js23109 = strs.length; var map23110 = { }; for (var _js23108 = 0; _js23108 < _js23109; _js23108 += 1) { var str = strs[_js23108]; map23110[str] = str.length; }; return map23110; })();"
(3) In FOR..ON, a BY term can now be an integer. For example, you can say "by 2" instead of "by #'cddr" which makes little sense for JS arrays:
(ps (loop :for (key val) :on pairs :by 2 :do (foo key val)))
"for (var _js23094 = pairs; _js23094.length > 0; _js23094 = _js23094.slice(2)) { var key = _js23094[0]; var val = _js23094[1]; foo(key, val); };"
If BY doesn't get a number, it assumes it got a function:
(ps (loop :for (key val) :on pairs :by blah :do (foo key val)))
"for (var _js23112 = pairs; _js23112.length > 0; _js23112 = blah(_js23112)) { var key = _js23112[0]; var val = _js23112[1]; foo(key, val); };"
Daniel