customize when to prefer built-ins over clauses and vice versa

[Luis-Henriquez-Perez]

It is worth noting that the "while" clause does not work in iter (assuming the lax-naming flag is enabled) because iter uses the built-in while. Might be useful to have a custom variable for specifying for which commands iter should prefer built-ins and which it should prefer clauses.

Right now there's loopy-iter-ignored-commands which stops loopy iter from prioritizing some clauses over built-ins. But you should be able to go the other way around too. So I can say if you see a while assume it is a clause and not the built-in.

[okamsn]

My thinking was that in loopy-iter, one wouldn't want to use the commands named after the built-in Emacs Lisp forms, as they are normally just wrappers around those forms.

That is, I don't know the benefit to using the whilecommand instead of the normal while special form in loopy-iter, since the command would just expand in place to a usage of the form.

What is your use case that you would prefer the command to form? Do you have other examples of this for other commands?

[Luis-Henriquez-Perez]

Sorry for the very late response.

What is your use case that you would prefer the command to form?

At the time my use case were the examples I presented in #109 (one of which I show below). To try to describe the situation: I want to have multiple separate loops in the same body that share the same "environment". Below both loops collect to the same let-bind. In this example I feel that I'm kind of "misusing" iter--or at least I'm not using it as intended because it is intended to be a loop have some sort of iteration clause or at least iterate more than once. Rather, I'm using it for it's convenient accumulation commands and inefficiently returning a value. Therefore, I think there should be a specific macro for this situation.

(defmacro with-map! (map &rest body)
  "Let-bind dotted symbols to their values in BODY.
This is similar to `let-alist' but map can be any key value structure."
  (declare (indent 1))
  (iter (dolist (dot-sym (oo-dot-symbols body))
	  (expr name (macroexp-quote (oo-dot-symbol-name dot-sym)))
	  (collect let-binds (list name dot-sym)))
	(dolist (asterix-sym (oo-asterix-symbols body))
	  (expr name (oo-keyword-intern (oo-asterix-symbol-name asterix-sym)))
	  (collect let-binds (list name asterix-sym)))
	(return `(map-let ,let-binds ,map ,@body))))

Do you have other examples of this for other commands?

I don't have examples for other commands. Maybe loopy-block is good enough solution for this.

[okamsn]

After a series of changes to loopy-iter, one should now be able to use any loopy command after one of the special words listed in loopy-iter-keywords. For example,

;; => (1 2 2 4)
(loopy-iter (listing i '(1 2 3))
            (for while (< i 3))
            (collecting i)
            (accum collect (* 2 i)))

Since the idea for loopy clauses without a built-in while loop is discussed in other issues, I'm closing this one as complete.