Python enumerate() analog in Common Lisp

Question

Ich möchte eine Liste überlisten, aber den Elementindex in der Liste verfolgen.

In Python ich etwas entlang der Linien von tun können:

(mapcar-something (lambda (elt idx) (format nil "Elt ~D: ~S" idx elt)) 
        '(a b c d)) 

Erwartetes Ergebnis:

("Elt 0: A" "Elt 1: B" "Elt 2: C" "Elt 3: D") 

map(lambda (idx, elt): "Elt {0}: {1}".format(idx, elt), enumerate(mylist)) 

ich es etwas entlang der Linien von zu übersetzen versuchte,

Aber ich kann die mapcar-something Funktion nicht finden, die ich verwenden sollte. Muss ich das selbst implementieren (via Schleife, vielleicht)?

Answer 1

Common Lisp LOOP Makro automatisch halten können Spur des Indexes.

(loop for elt in '(a b c d) and idx from 0 
     collect (operation-on idx elt)) 

LOOP automatisch erhöht um 1 eine Variable mit from initialisiert; und wenn sie von and eingeführt werden, dann passieren beide Zuordnungen (das Element des Arrays und des Index) auf einmal, nicht verschachtelt.

So eine enumerate Funktion entlang der Linien würde:

(defun enumerate (list &optional (first-index 0)) 
    (loop for elt in list and idx from first-index 
    collect (cons idx elt))) 

In der Ausdruckskraft von Common Lisp, wäre es vielleicht sinnvoll sein, einen Makro entlang der Linien zu definieren:

(defmacro with-enumerated-list ((list elt idx &key (first-index 0)) &body body) 
    `(loop for ,elt in ,list and ,idx from ,first-index 
    collect (progn ,@body))) 

in diesem Fall könnte die enumerate-Funktion reduziert werden:

(defun enumerate (list &optional (first-index 0)) 
    (with-enumerated-list (list elt idx :first-index first-index) 
    (cons idx elt))) 

Answer 2

CL-USER 25 > (defun iota (n) 
       (loop for i below n collect i)) 
IOTA 

CL-USER 26 > (iota 4) 
(0 1 2 3) 

CL-USER 27 > (mapcar (lambda (elt idx) 
         (format nil "Elt ~D: ~S" idx elt)) 
        '(a b c d) 
        (iota 4)) 
("Elt 0: A" "Elt 1: B" "Elt 2: C" "Elt 3: D") 

oder

CL-USER 28 > (loop for elt in '(a b c d) and idx from 0 
        collect (format nil "Elt ~D: ~S" idx elt)) 
("Elt 0: A" "Elt 1: B" "Elt 2: C" "Elt 3: D") 

Answer 3

Wenn Sie wollen etwas, das wie Ihr ursprüngliches Beispiel aussieht:

(defun enumerate (function list) 
    (let ((idx 0)) 
    (loop for elt in list 
     collect (funcall function elt idx) 
     do (incf idx)))) 

Ihr Beispiel:

(enumerate (lambda (elt idx) (format nil "Elt ~D: ~S" idx elt)) 
      '(a b c d)) 
=> ("Elt 0: A" "Elt 1: B" "Elt 2: C" "Elt 3: D")