サーチ…


概要

1つまたは複数のリストの要素に関数を適用するために、 高レベルのマッピング関数のセットをCommon Lispで利用できます。関数がリストに適用される方法と、最終結果がどのように得られるかは異なります。次の表は、相違を要約し、それぞれに対応するLOOPフォームを示しています。 fは適用される関数であり、リストの数に等しい数の引数を持たなければならない。 「車に適用される」とは、リストの要素に順番に適用されることを意味し、「cdrに適用される」とは、リスト、そのcdr、cddrなどに順番に適用されることを意味する。結果をリストしたり、連結したり(リストでなければならない!)、あるいは単に副作用のために使用された場合(この場合、最初のリストが返されます)、結果がグローバル結果であるかどうかを返します。

関数に適用されます返品等価ループ
(mapcar fl 1 ... 1 n結果のリスト (xのN L中のL 1におけるX 1のためのループ... N(FX 1 ... X n)を収集)
(maplist fl 1 ... 1 n CDR 結果のリスト (L上のx nに対するL 1上のX 1のためのループ... N(FX 1 ... X n)を収集)
(mapcan fl 1 ... 1 n結果の連結 (L nは nconcを(FX 1中のX nのL 1におけるX 1のためのループ... X n)で
(mapcon fl 1 ... l n CDR 結果の連結 (L nは nconcを(FX 1 ... X n)でのX nのL 1上のX 1のためのループ...)
(mapc fl 1 ... 1 n l 1 (Lのx nのL 1におけるX 1のためのループ... N行う(FX 1 ... X n)が、最終的に(戻りL 1))
(mapl fl 1 ... 1 n CDR l 1 (L上のx nに対するL 1上のX 1のためのループ... N行う(FX 1 ... X n)が、最終的に(戻りL 1))

すべてのケースで、リストの長さが異なる可能性があり、最短リストが終了するとアプリケーションが終了することに注意してください。

マップ機能の別のカップルが用意されています。 mapに類似し、シーケンス(文字列、ベクトル、リスト)に適用することができ、 mapcar 、それはシーケンスの任意の型を返すことができ、最初の引数、およびとして指定されたmap-intoに類似し、 mapしかし、関数の適用結果を保持するために、最初のシーケンス引数を破壊的に変更します。

MAPCARの例

MAPCARは、家族で最もよく使用される機能です。

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)

mapcarの慣用的な使用法は、リストのリストとして表現された行列を転置することです:

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 |
;  +---+---+---+               +---+---+---+

説明については、 この回答を参照してください。

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))

MAPCANと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)

MAPCANの使い方の1つは、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)

MAPCと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)


Modified text is an extract of the original Stack Overflow Documentation
ライセンスを受けた CC BY-SA 3.0
所属していない Stack Overflow