AutoLISP リスト操作関数の使い方

[リスト操作関数リファレンス（公式ヘルプ）](https://help.autodesk.com/view/OARX/2020/JPN/?guid=GUID-00A75AFB-5708-4D0C-B18C-F74DDC4D65FA)
[AutoLISP リスト操作いろいろ](https://qiita.com/tydesign/items/0c36873ac104412cbecd)

## 文字列のリストを文字コード順にソート　acad_strlsort
```scheme
(acad_strlsort '("b" "d" "a" "e" "c"))
;; -> ("a" "b" "c" "d" "e")
(acad_strlsort '("3" "4" "1" "5" "2"))
;; -> ("1" "2" "3" "4" "5")
(acad_strlsort '("う" "お" "あ" "え" "い"))
;; -> ("あ" "い" "う" "え" "お")
```

## 複数のリストを結合する　append
```scheme
(append '("abc" "def") '("ghi" "jkl"))
;; -> ("abc" "def" "ghi" "jkl")
(append '(1 2 3) '("abc") '(4.5 5.5 6.5))
;; -> (1 2 3 "abc" 4.5 5.5 6.5)
```

## 連想リストの要素を検索する　assoc
```scheme
(setq lst '((1 "aaa")(2 "bbb")(3 "ccc")(4 "ddd")(5 "eee")))
(assoc 1 lst)
;; -> (1 "aaa")
(assoc 3 lst)
;; -> (3 "ccc")

(setq lst2 '((Aaa 111)(Bbb 222)(Ccc 333)(Ddd 444)(Eee 555)))
(assoc 'Aaa lst2)
;; -> (AAA 111)
(assoc 3 lst)
;; -> (EEE 555)
```

## リストの先頭の要素を取得する　car
```scheme
(car '(1 2 3 4 5))
;; -> 1
```

## リストの先頭以外を取得する　cdr
```scheme
(cdr '(1 2 3 4 5))
;; -> (2 3 4 5)
```

## リストを作成する　cons
```scheme
(cons "a" '("b" "c" "d" "e"))
;; -> ("a" "b" "c" "d" "e")
(cons '("a" "b") '("c" "d" "e"))
;; -> (("a" "b") "c" "d" "e")
(cons 1 '(2 3 4 5))
;; -> (1 2 3 4 5)
(cons '(1 2) '(3 4 5))
;; -> ((1 2) 3 4 5)

;;; ドット リストを作成
(cons 1 "aaa")
;; -> (1 . "aaa")
(cons 'a 123.45)
;; -> (A . 123.45)
```

## リストのすべての要素に対して処理をする　foreach
```scheme
(setq a 0)
(foreach x '(1 2 3 4 5)
    (setq a (+ a x))
)
;; -> a = 15

(setq b "foreach-")
(foreach s '("a" "b" "c" "d" "e")
    (setq b (strcat b s))
)
;; -> "foreach-abcde"
```

## リストの最後の要素を取得する　last
```scheme
(last '(1 2 3 4 5))
;; -> 5
(last '("a" "b" "c" "d" "e"))
;; -> "e"
```

## リストの要素数を数える length
```scheme
(length '(1 2 3 4 5))
;; -> 5
(length '("a" "b" "c"))
;; -> 3
```

## リストを作成する　list
```scheme
(list "a" "b" "c")
;; -> ("a" "b" "c")
(list 'a 'b 'c)
;; -> (A B C)
```

## 指定された項目がリストかどうかを調べる　listp
```scheme
(listp '(1 2 3 4 5))
;; -> T
(listp '("a" "b" "c"))
;; -> T
(listp 1)
;; -> nil
(listp "aaa")
;; -> nil
```

## 指定されたリストの各要素を引数として関数を実行する　mapcar
```scheme
(mapcar '+ '(1 2 3 4 5) '(10 20 30 40 50))
;; -> (11 22 33 44 55
(mapcar 'strcat '("a" "b" "c" "d" "e") '("-A" "-B" "-C" "-D" "-E"))
;; -> ("a-A" "b-B" "c-C" "d-D" "e-E")
(mapcar 'list '(1 2 3 4 5) '("a" "b" "c" "d" "e"))
;; -> ((1 "a") (2 "b") (3 "c") (4 "d") (5 "e"))
(mapcar 'cons '(1 2 3 4 5) '("a" "b" "c" "d" "e"))
;; -> ((1 . "a") (2 . "b") (3 . "c") (4 . "d") (5 . "e"))
```

## 指定された式がリスト内に存在するかどうかを検索する　member
```scheme
(member "c" '("a" "b" "c" "d" "e"))
;; -> ("c" "d" "e")
(member "f" '("a" "b" "c" "d" "e"))
;; -> nil
(member 2 '(1 2 3 4 5))
;; -> (2 3 4 5)
(member (+ 2 2) '(1 2 3 4 5))
;; -> (4 5)
```

## リストの n 番目の要素を取得する　nth
```scheme
(nth 2 '(1 2 3 4 5))
;; -> 3
(nth 0 '(1 2 3 4 5))
;; -> 1
```

## リストの要素を反転する　reverse
```scheme
(reverse '(1 2 3 4 5))
;; -> (5 4 3 2 1)
(reverse '("a" "b" "c" "d" "e"))
;; -> ("e" "d" "c" "b" "a")
```

## リストの要素を入れ替える　subst
```scheme
;;; 1 を 9 に
(subst 9 1  '(1 2 3 4 5 1))
;; -> (9 2 3 4 5 9)

;;; "a" を "z" に
(subst "z" "a"  '("a" "b" "c" "d" "e" "a"))
;; -> ("z" "b" "c" "d" "e" "z")
```

## リストが nil かどうかを調べる　vl-consp
```scheme
(vl-consp '(1 2 3 4 5))
;; -> T
(vl-consp ())
;; -> nil
```

## すべての要素の組み合わせに対して真かどうか調べる　vl-every
```scheme
(vl-every '< '(1 2 3 4 5) '(2 3 4 5 6))
;; -> T
(vl-every '< '(1 2 3 4 5) '(2 2 4 5 6))
;; -> nil
```

## リストを作成　vl-list*
```scheme
(vl-list* 1 2 3 4 5)
;; -> (1 2 3 4 . 5)
(vl-list* "aaa")
;; -> "aaa"
(vl-list* 1 "aaa")
;; -> (1 . "aaa")
(vl-list* '(1 2) '(3 4 5))
;; -> ((1 2) 3 4 5)
(vl-list* 1 2 '(3 4 5))
;; -> (1 2 3 4 5)
(vl-list* '(1 2) '(3 4) '(5 6))
;; -> ((1 2) (3 4) 5 6)
```

## 文字コードのリストから文字列を作成　vl-list->string
```scheme
(vl-list->string (list (ascii "a") (ascii "b") (ascii "c")))
;; -> "abc"
```

## 本来のリストの長さを算出　vl-list-length
```scheme
(vl-list-length '(1 2 3 4 5))
;; -> 5
(vl-list-length '("a" "b" "c"))
;; -> 3
(vl-list-length (cons 1 "a"))
;; -> nil
(vl-list-length nil)
;; -> 0
```

## リストの要素の 1つでも結果が真かどうかを調べる　vl-member-if
```scheme
(vl-member-if 'numberp '(1 2 3 4 5))
;; -> (1 2 3 4 5)
(vl-member-if 'numberp '(1 2 3 4 5 "a"))
;; -> (1 2 3 4 5 "a")
(vl-member-if 'numberp '("a" "b" "c" "d" "e"))
;; -> nil
```

## リストの要素の 1 つでも結果が nil かどうかを調べる　vl-member-if-not
```scheme
(vl-member-if-not 'numberp '(1 2 3 4 5))
;; -> nil
(vl-member-if-not 'numberp '(1 2 3 4 5 "a"))
;; -> ("a")
(vl-member-if-not 'numberp '("a" "b" "c" "d" "e"))
;; -> ("a" "b" "c" "d" "e")
```

## 指定された要素のリスト内のインデックスを返す　vl-position
```scheme
(vl-position 3 '(1 2 3 4 5))
;; -> 2
(vl-position "a" '("a" "b" "c" "d" "e"))
;; -> 0
(vl-position "え" '("あ" "い" "う" "え" "お"))
;; -> 3
```

## リストから要素を除去する　vl-remove
```scheme
(vl-remove 3 '(1 2 3 4 5))
;; -> (1 2 4 5)
(vl-remove "a" '("a" "b" "c" "d" "e"))
;; -> ("b" "c" "d" "e")
(vl-remove "え" '("あ" "い" "う" "え" "お"))
;; -> ("あ" "い" "う" "お")
```

## リストの要素の中で、T になったの要素を除去したリストを取得する　vl-remove-if
```scheme
(vl-remove-if 'numberp '(1 2 3 4 5))
;; -> nil
(vl-remove-if 'numberp '(1 2 3 4 5 "a"))
;; -> ("a")
(vl-remove-if 'numberp '("a" "b" "c" "d" "e"))
;; -> ("a" "b" "c" "d" "e")
```

## リストの要素の中で、nil になったの要素を除去したリストを取得する　vl-remove-if-not
```scheme
(vl-remove-if-not 'numberp '(1 2 3 4 5))
;; -> (1 2 3 4 5)
(vl-remove-if-not 'numberp '(1 2 3 4 5 "a"))
;; -> (1 2 3 4 5)
(vl-remove-if-not 'numberp '("a" "b" "c" "d" "e"))
;; -> nil
```

## 1 つの要素の組み合わせに対して T かどうか調べる　vl-some
1つでも T があれば T。

```scheme
(vl-some '< '(1 2 3 4 5) '(2 3 4 5 6))
;; -> T
(vl-some '< '(1 2 3 4 5) '(2 2 4 5 6))
;; -> T
(vl-some '< '(1 2 3 4 5) '(0 1 2 3 4))
```

## 比較関数にしたがってリスト内の要素をソートする vl-sort
```scheme
(vl-sort '(1 2 3 4 5) '>)
;; -> (5 4 3 2 1)
(vl-sort '("a" "b" "c" "d" "e") '>)
;; -> ("e" "d" "c" "b" "a")
```

## 比較関数にしたがってソートされた、インデックス番号のリストを取得する　vl-sort-i
```scheme
(vl-sort-i '(1 2 3 4 5) '>)
;; -> (4 3 2 1 0)
(vl-sort-i '("a" "b" "c" "d" "e") '>)
;; -> (4 3 2 1 0)
```

## 文字列を文字コードのリストに変換　vl-string->list
```scheme
(vl-string->list "abcde")
;; -> (97 98 99 100 101)
(vl-string->list "12345")
;; -> (49 50 51 52 53)
(vl-string->list "あいうえお")
;; -> (130 160 130 162 130 164 130 166 130 168)
```