common-lisp
Mappatura delle funzioni sugli elenchi
Ricerca…
Panoramica
Un set di funzioni di mappatura di alto livello è disponibile in Common Lisp, per applicare una funzione agli elementi di uno o più elenchi. Differiscono nel modo in cui la funzione viene applicata agli elenchi e in che modo viene ottenuto il risultato finale. La seguente tabella riassume le differenze e mostra per ognuna di esse il modulo LOOP equivalente. f è la funzione da applicare, che deve avere un numero di argomenti uguale al numero di liste; "Applicato alla macchina" significa che viene applicato a turno agli elementi delle liste, "applicato al cdr" significa che viene applicato a turno alle liste, al loro cdr, al loro cddr, ecc .; la colonna "restituisce" mostra se il risultato globale è quello ottenuto elencando i risultati, concatenandoli (quindi devono essere elenchi!), o semplicemente usati per effetti collaterali (e in questo caso viene restituito il primo elenco).
| Funzione | Applicata ai | ritorna | LOOP equivalente |
|---|---|---|---|
| (mapcar fl 1 ... l n ) | auto | elenco dei risultati | (loop per x 1 in l 1 ... per x n in l n collect (fx 1 ... x n )) |
| (maplist fl 1 ... l n ) | cdr | elenco dei risultati | (loop per x 1 su l 1 ... per x n su l n collect (fx 1 ... x n )) |
| (mapcan fl 1 ... l n ) | auto | concatenazione dei risultati | (loop per x 1 in l 1 ... per x n in l n nconc (fx 1 ... x n )) |
| (mapcon fl 1 ... l n ) | cdr | concatenazione dei risultati | (loop per x 1 su l 1 ... per x n su l n nconc (fx 1 ... x n )) |
| (mapc fl 1 ... l n ) | auto | l 1 | (loop per x 1 in l 1 ... per x n in l n do (fx 1 ... x n ) infine (ritorno l 1 )) |
| (mapl fl 1 ... l n ) | cdr | l 1 | (loop per x 1 su l 1 ... per x n su l n do (fx 1 ... x n ) infine (ritorno l 1 )) |
Si noti che, in tutti i casi, gli elenchi possono essere di lunghezze diverse e l'applicazione termina quando viene terminata la lista più breve.
Sono disponibili un altro paio di funzioni di mappa: map , che può essere applicata a sequenze (stringhe, vettori, elenchi), analoga a mapcar , e che può restituire qualsiasi tipo di sequenza, specificata come primo argomento e map-into , analoga alla map , ma modifica distruttivamente il suo primo argomento di sequenza per mantenere i risultati dell'applicazione della funzione.
Esempi di MAPCAR
MAPCAR è la funzione più utilizzata della famiglia:
CL-USER> (mapcar #'1+ '(1 2 3))
(2 3 4)
CL-USER> (mapcar #'cons '(1 2 3) '(a b c))
((1 . A) (2 . B) (3 . C))
CL-USER> (mapcar (lambda (x y z) (+ (* x y) z))
'(1 2 3)
'(10 20 30)
'(100 200 300))
(110 240 390)
CL-USER> (let ((list '(a b c d e f g h i))) ; randomize this list
(mapcar #'cdr
(sort (mapcar (lambda (x)
(cons (random 100) x))
list)
#'<=
:key #'car)))
(I D A G B H E C F)
Un uso idiomatico di mapcar è di trasporre una matrice rappresentata come una lista di liste:
CL-USER> (defun transpose (list-of-lists)
(apply #'mapcar #'list list-of-lists))
ROTATE
CL-USER> (transpose '((a b c) (d e f) (g h i)))
((A D G) (B E H) (C F I))
; +---+---+---+ +---+---+---+
; | A | B | C | | A | D | G |
; +---+---+---+ +---+---+---+
; | D | E | F | becomes | B | E | H |
; +---+---+---+ +---+---+---+
; | G | H | I | | C | F | I |
; +---+---+---+ +---+---+---+
Per una spiegazione, vedi questa risposta .
Esempi di MAPLIST
CL-USER> (maplist (lambda (list) (cons 0 list)) '(1 2 3 4))
((0 1 2 3 4) (0 2 3 4) (0 3 4) (0 4))
CL-USER> (maplist #'append
'(a b c d -)
'(1 2 3))
((A B C D - 1 2 3) (B C D - 2 3) (C D - 3))
Esempi di MAPCAN e MAPCON
MAPCAN:
CL-USER> (mapcan #'reverse '((1 2 3) (a b c) (100 200 300)))
(3 2 1 C B A 300 200 100)
CL-USER> (defun from-to (min max)
(loop for i from min to max collect i))
FROM-TO
CL-USER> (from-to 1 5)
(1 2 3 4 5)
CL-USER> (mapcan #'from-to '(1 2 3) '(5 5 5))
(1 2 3 4 5 2 3 4 5 3 4 5)
Uno degli usi di MAPCAN è creare un elenco di risultati senza valori NIL:
CL-USER> (let ((l1 '(10 20 40)))
(mapcan (lambda (x)
(if (member x l1)
(list x)
nil))
'(2 4 6 8 10 12 14 16 18 20
18 16 14 12 10 8 6 4 2)))
(10 20 10)
MAPCON:
CL-USER> (mapcon #'copy-list '(1 2 3))
(1 2 3 2 3 3)
CL-USER> (mapcon (lambda (l1 l2) (list (length l1) (length l2))) '(a b c d) '(d e f))
(4 3 3 2 2 1)
Esempi di MAPC e MAPL
MAPC:
CL-USER> (mapc (lambda (x) (print (* x x))) '(1 2 3 4))
1
4
9
16
(1 2 3 4)
CL-USER> (let ((sum 0))
(mapc (lambda (x y) (incf sum (* x y)))
'(1 2 3)
'(100 200 300))
sum)
1400 ; => (1 x 100) + (2 x 200) + (3 x 300)
MAPL:
CL-USER> (mapl (lambda (list) (print (reduce #'+ list))) '(1 2 3 4 5))
15
14
12
9
5
(1 2 3 4 5)
