cl-loop is an autoloaded macro defined in cl-macs.el.gz.

Signature
(cl-loop CLAUSE...)

Documentation
The Common Lisp loop macro.

Valid clauses include:
  For clauses:
    for VAR from/upfrom/downfrom EXPR1 to/upto/downto/above/below EXPR2
        [by EXPR3]
    for VAR = EXPR1 then EXPR2
    for VAR in/on/in-ref LIST [by FUNC]
    for VAR across/across-ref ARRAY
    for VAR being:
      the elements of/of-ref SEQUENCE [using (index VAR2)]
      the symbols [of OBARRAY]
      the hash-keys/hash-values of HASH-TABLE [using (hash-values/hash-keys V2)]
      the key-codes/key-bindings/key-seqs of KEYMAP [using (key-bindings VAR2)]
      the overlays/intervals [of BUFFER] [from POS1] [to POS2]
      the frames/buffers
      the windows [of FRAME]
  Iteration clauses:
    repeat INTEGER
    while/until/always/never/thereis CONDITION
  Accumulation clauses:
    collect/append/nconc/concat/vconcat/count/sum/maximize/minimize FORM
      [into VAR]
  Miscellaneous clauses:
    with VAR = INIT
    if/when/unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...]
    named NAME
    initially/finally [do] EXPRS...
    do EXPRS...
    [finally] return EXPR

For more details, see Info node (cl)Loop Facility.

View in manual

References
References in cl-macs.el.gz:
(defmacro cl-once-only ...) 1 reference
(defun cl--optimize ...)    1 reference

Find all references Functions used by cl-loop

Debugging
Enable edebug Enable tracing
Disassemble Forget

Aliases
loop (obsolete since 27.1)

Source Code
;; Defined in /usr/share/emacs/29.3/lisp/emacs-lisp/cl-macs.el.gz
;;;###autoload
(defmacro cl-loop (&rest loop-args)
  "The Common Lisp `loop' macro.
Valid clauses include:
  For clauses:
    for VAR from/upfrom/downfrom EXPR1 to/upto/downto/above/below EXPR2
        [by EXPR3]
    for VAR = EXPR1 then EXPR2
    for VAR in/on/in-ref LIST [by FUNC]
    for VAR across/across-ref ARRAY
    for VAR being:
      the elements of/of-ref SEQUENCE [using (index VAR2)]
      the symbols [of OBARRAY]
      the hash-keys/hash-values of HASH-TABLE [using (hash-values/hash-keys V2)]
      the key-codes/key-bindings/key-seqs of KEYMAP [using (key-bindings VAR2)]
      the overlays/intervals [of BUFFER] [from POS1] [to POS2]
      the frames/buffers
      the windows [of FRAME]
  Iteration clauses:
    repeat INTEGER
    while/until/always/never/thereis CONDITION
  Accumulation clauses:
    collect/append/nconc/concat/vconcat/count/sum/maximize/minimize FORM
      [into VAR]
  Miscellaneous clauses:
    with VAR = INIT
    if/when/unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...]
    named NAME
    initially/finally [do] EXPRS...
    do EXPRS...
    [finally] return EXPR

For more details, see Info node `(cl)Loop Facility'.

\(fn CLAUSE...)"
  (declare (debug (&rest &or
                         ;; These are usually followed by a symbol, but it can
                         ;; actually be any destructuring-bind pattern, which
                         ;; would erroneously match `form'.
                         [[&or "for" "as" "with" "and"] sexp]
                         ;; These are followed by expressions which could
                         ;; erroneously match `symbolp'.
                         [[&or "from" "upfrom" "downfrom" "to" "upto" "downto"
                               "above" "below" "by" "in" "on" "=" "across"
                               "repeat" "while" "until" "always" "never"
                               "thereis" "collect" "append" "nconc" "sum"
                               "count" "maximize" "minimize"
                               "if" "when" "unless"
                               "return"]
                          form]
                         ["using" (symbolp symbolp)]
                         ;; Simple default, which covers 99% of the cases.
                         symbolp form)))
  (if (not (memq t (mapcar #'symbolp
                           (delq nil (delq t (cl-copy-list loop-args))))))
      `(cl-block nil (while t ,@loop-args))
    (let ((cl--loop-args loop-args) (cl--loop-name nil) (cl--loop-bindings nil)
      (cl--loop-body nil)       (cl--loop-steps nil)
      (cl--loop-result nil)     (cl--loop-result-explicit nil)
      (cl--loop-result-var nil) (cl--loop-finish-flag nil)
      (cl--loop-accum-var nil)  (cl--loop-accum-vars nil)
      (cl--loop-initially nil)  (cl--loop-finally nil)
      (cl--loop-iterator-function nil) (cl--loop-first-flag nil)
          (cl--loop-symbol-macs nil)
          (cl--loop-conditions nil))
      ;; Here is more or less how those dynbind vars are used after looping
      ;; over cl--parse-loop-clause:
      ;;
      ;; (cl-block ,cl--loop-name
      ;;   (cl-symbol-macrolet ,cl--loop-symbol-macs
      ;;     (foldl #'cl--loop-let
      ;;            `((,cl--loop-result-var)
      ;;              ((,cl--loop-first-flag t))
      ;;              ((,cl--loop-finish-flag t))
      ;;              ,@cl--loop-bindings)
      ;;           ,@(nreverse cl--loop-initially)
      ;;           (while                   ;(well: cl--loop-iterator-function)
      ;;               ,(car (cl--loop-build-ands (nreverse cl--loop-body)))
      ;;             ,@(cadr (cl--loop-build-ands (nreverse cl--loop-body)))
      ;;             ,@(nreverse cl--loop-steps)
      ;;             (setq ,cl--loop-first-flag nil))
      ;;           (if (not ,cl--loop-finish-flag) ;FIXME: Why `if' vs `progn'?
      ;;               ,cl--loop-result-var
      ;;             ,@(nreverse cl--loop-finally)
      ;;             ,(or cl--loop-result-explicit
      ;;                  cl--loop-result)))))
      ;;
      (setq cl--loop-args (append cl--loop-args '(cl-end-loop)))
      (while (not (eq (car cl--loop-args) 'cl-end-loop))
        (cl--parse-loop-clause))
      (if cl--loop-finish-flag
      (push `((,cl--loop-finish-flag t)) cl--loop-bindings))
      (if cl--loop-first-flag
      (progn (push `((,cl--loop-first-flag t)) cl--loop-bindings)
         (push `(setq ,cl--loop-first-flag nil) cl--loop-steps)))
      (let* ((epilogue (nconc (nreverse cl--loop-finally)
                  (list (or cl--loop-result-explicit
                                        cl--loop-result))))
         (ands (cl--loop-build-ands (nreverse cl--loop-body)))
         (while-body (nconc (cadr ands) (nreverse cl--loop-steps)))
         (body (append
            (nreverse cl--loop-initially)
            (list (if cl--loop-iterator-function
                  `(cl-block --cl-finish--
                                 ,(funcall cl--loop-iterator-function
                                           (if (eq (car ands) t) while-body
                                             (cons `(or ,(car ands)
                                                        (cl-return-from
                                                            --cl-finish--
                                                          nil))
                                                   while-body))))
                `(while ,(car ands) ,@while-body)))
            (if cl--loop-finish-flag
            (if (equal epilogue '(nil)) (list cl--loop-result-var)
              `((if ,cl--loop-finish-flag
                (progn ,@epilogue) ,cl--loop-result-var)))
              epilogue))))
    (if cl--loop-result-var
            (push (list cl--loop-result-var) cl--loop-bindings))
    (while cl--loop-bindings
      (if (cdar cl--loop-bindings)
          (setq body (list (cl--loop-let (pop cl--loop-bindings) body t)))
        (let ((lets nil))
          (while (and cl--loop-bindings
              (not (cdar cl--loop-bindings)))
        (push (car (pop cl--loop-bindings)) lets))
          (setq body (list (cl--loop-let lets body nil))))))
    (if cl--loop-symbol-macs
        (setq body
                  (list `(cl-symbol-macrolet ,cl--loop-symbol-macs ,@body))))
    `(cl-block ,cl--loop-name ,@body)))))

Symbol Properties
edebug-form-spec
  (&rest &or
         [[&or "for" "as" "with" "and"]
          sexp]
         [[&or "from" "upfrom" "downfrom" "to" "upto" "downto" "above" "below" "by" "in" "on" "=" "across" "repeat" "while" "until" "always" "never" "thereis" "collect" "append" "nconc" "sum" "count" "maximize" "minimize" "if" "when" "unless" "return"]
          form]
         ["using"
          (symbolp symbolp)]
         symbolp form)
function-history
  ("/usr/share/emacs/29.3/lisp/emacs-lisp/cl-macs.elc"
   (autoload "cl-macs"
     ("/usr/share/emacs/29.3/lisp/emacs-lisp/cl-loaddefs.elc" . 14903)
     nil t))