リスト

acons

(KEY . DATUM) を A-LIST に加えた連想リストを返します。

  (acons x y a) == (cons (cons x y) a)

使用例：
  (setq foo '((b . 2))) => ((b . 2))
  (acons 'a 1 foo)      => ((a . 1) (b . 2))
  foo                   => ((b . 2))

adjoin

ITEM が LIST の member でなければ先頭に追加した LIST を返す。 member なら LIST を
そのまま返します。

  (adjoin item list) == (if (member item list) list (cons item list))

  :key : :keyに fn が指定された場合，xyzzyでは
          (adjoin item list) == (if (member item list :key fn) list (cons item list))
         となりますが，CLTL2では次のように動作し，非互換です．
          (adjoin item list) == (if (member (funcall fn item) list :key fn) list (cons item list))

使用例：
  (adjoin 'a '(b c d))
  => (a b c d)
  (adjoin 'b '(a b c d))
  => (a b c d)
  (adjoin '(a) '((b) (c) (d)) :key #'car)
  => ((a) (b) (c) (d))

append

複数のリストを引数にとってそれらを結合したリストを返します。
引数は保存されます。

使用例：
  ;;; リストをくっつけてみる。
  (setq x '(a b c))
  (setq y '(d e f))
  (append x y)
  =>(a b c d e f)
  x
  =>(a b c)
  y
  =>(d e f)

assoc

連想リスト A-LIST の中で car 部が ITEM との :test を満たす最初のペアを返します。

使用例：
  (assoc 'r '((a . b) (c . d) (r . x) (s . y) (r . z))) 
  =>  (r . x) 
  (assoc 'goo '((foo . bar) (zoo . goo)))
  => nil 
  (assoc '2 '((1 a b c) (2 b c d) (-7 x y z)))
  => (2 b c d)

assoc-if

連想リスト A-LIST の中で car 部が PREDICATE を満たす最初のペアを返します。

使用例：
  (assoc-if #'numberp '((a . b) (1 . c) (2 . d)))
  => (1 . c)

assoc-if-not

連想リスト A-LIST の中で car 部が PREDICATE を満たさない最初のペアを返します。

使用例：
  (assoc-if-not #'numberp '((a . b) (1 . c) (2 . d)))
  => (a . b)

butlast

リストの最後のN要素分を除いたリストを返します。
引数 LIST は保存されます。

使用例：
  ;;; 最後の要素を取り除く。
  (butlast '(1 2 3))
  => (1 2) 
  ;;; 最後の2要素を取り除く。
  (butlast '(1 2 3) 2)
  => (1) 

caaaar

caaaar を返します。

  (caaaar X) = (car (car (car (car X))))

caaadr

caaadr を返します。

  (caaadr X) = (car (car (car (cdr X))))

caaar

caaar を返します。

  (caaar X) = (car (car (car X)))

caadar

caadar を返します。

  (caadar X) = (car (car (cdr (car X))))

caaddr

caaddr を返します。

  (caaddr X) = (car (car (cdr (cdr X))))

caadr

caadr を返します。

  (caadr X) = (car (car (cdr X)))

caar

caar を返します。

  (caar X) = (car (car X))

cadaar

cadaar を返します。

  (cadaar X) = (car (cdr (car (car X))))

cadadr

cadadr を返します。

  (cadadr X) = (car (cdr (car (cdr X))))

cadar

cadar を返します。

  (cadar X) = (car (cdr (car X)))

caddar

caddar を返します。

  (caddar X) = (car (cdr (cdr (car X))))

cadddr

cadddr を返します。

  (cadddr X) = (car (cdr (cdr (cdr X))))

caddr

caddr を返します。

  (caddr X) = (car (cdr (cdr X)))

cadr

cadr を返します。

  (cadr X) = (car (cdr X))

car

リストの最初の要素を返します。

コンスセル LIST の最初のポインタを返します。 LIST が nil の場合 car は 
nil を返すよう、定義されています。引数がリストでない場合、エラーになります
引数がリスト以外でもエラーになって欲しくない場合には、safe-car を使用します。

使用例：
  (car '(a b c))
  => a
  (car '())
  => nil
  (car "string")
  => 不正なデータ型です: "string": cons

cdaaar

cdaaar を返します。

  (cdaaar X) = (cdr (car (car (car X))))

cdaadr

cdaadr を返します。

  (cdaadr X) = (cdr (car (car (cdr X))))

cdaar

cdaar を返します。

  (cdaar X) = (cdr (car (car X)))

cdadar

cdadar を返します。

  (cdadar X) = (cdr (car (cdr (car X))))

cdaddr

cdaddr を返します。

  (cdaddr X) = (cdr (car (cdr (cdr X))))

cdadr

cdadr を返します。

  (cdadr X) = (cdr (car (cdr X)))

cdar

cdar を返します。

  (cdar X) = (cdr (car X))

cddaar

cddaar を返します。

  (cddaar X) = (cdr (cdr (car (car X))))

cddadr

cddadr を返します。

  (cddadr X) = (cdr (cdr (car (cdr X))))

cddar

cddar を返します。

  (cddar X) = (cdr (cdr (car X)))

cdddar

cdddar を返します。

  (cdddar X) = (cdr (cdr (cdr (car X))))

cddddr

cddddr を返します。

  (cddddr X) = (cdr (cdr (cdr (cdr X))))

cdddr

cdddr を返します。

  (cdddr X) = (cdr (cdr (cdr X)))

cddr

cddr を返します。

  (cddr X) = (cdr (cdr X))

cdr

リストの二番目以降をリストで返します。

コンスセル LIST の 2 番目のポインタを返します。 LIST が nil の場合 cdr 
は nil を返すよう、定義されています。引数がリストでない場合、エラーにな
ります。引数がリスト以外でもエラーになって欲しくない場合には、safe-cdrを
使用します。

使用例：
  (cdr '(a b c))
  => (b c)
  (cdr '())
  => nil
  (cdr "string")
  => 不正なデータ型です: "string": cons

cons

新しいリストを返します。

主に、新しくリストを作る際に用いる関数です。これは X を car、 
Y を cdr として、コンスセルを新しく作り、この新しいコンスセルへの
ポインタを返します。 (通常はリストですが) Y が特定のあるタイプでな
くてはならないという制限はありません。

使用例：
  (cons 1 '(2))
  => (1 2)
  (cons 1 '())
  => (1)
  (cons 1 2)
  => (1 . 2)

copy-alist

連想リストのコピーを返します。例えばこんな連想リストをコピーした場合に、
オリジナルと同じものを指している部分に下線を引いています。copy-listでは
最上位の要素そのものがオリジナルと共有しているのに対し、copy-alistは第二
階層の要素を共有しています。

オリジナル：
  '(((1 2) . #\a) ((3 4) . #\b))

copy-list ：
  '(((1 2) . #\a) ((3 4) . #\b))
    ~~~~~~~~~~~~~ ~~~~~~~~~~~~~
copy-alist：
  '(((1 2) . #\a) ((3 4) . #\b))
     ~~~~~   ~~~   ~~~~~   ~~~

GNU Emacs Lisp Reference Manualによると、コピー元の連想リストとは独立し
て連想リストの修正を行えるようにするためとか。下の例でも示しているとおり、
copy-listでは元のリストまで変わってしまいます。

使用例：
  ;;; copy-listとcopy-alistの違いを見てみる。
  (setq a '((1 . #\a) (2 . #\b)))       => ((1 . #\a) (2 . #\b))
  (setq b (copy-list a))                => ((1 . #\a) (2 . #\b))
  (setq c (copy-alist a))               => ((1 . #\a) (2 . #\b))
  (rplacd (assoc 2 a) #\c)              => (2 . #\c)
  a                                     => ((1 . #\a) (2 . #\c))
  b                                     => ((1 . #\a) (2 . #\c))
  c                                     => ((1 . #\a) (2 . #\b))

copy-list

リストのコピーを返します。
コピーとオリジナルはequalですが、eqではありません。コピーとオリジナルは
同じ構造を持っており、一番上位のリストの要素は同じものを共有しています。
一方を変えると他方も変わります。オリジナルと同じものを指している部分に下
線を引いています。

オリジナル：
  '(((1 2) . #\a) ((3 4) . #\b))

copy-list ：
  '(((1 2) . #\a) ((3 4) . #\b))
    ~~~~~~~~~~~~~ ~~~~~~~~~~~~~
使用例：
  ;;; [A] eqではないことを示してみます。
  (setq a '((1 2 3) (4 5 6)))   => ((1 2 3) (4 5 6))
  (setq b (copy-list a))        => ((1 2 3) (4 5 6))
  (eq a b)                      => nil
  (equal a b)                   => t
  ;;; [B] car同士はeqです。
  (eq (car a) (car b))          => t
  ;;; [C] caarを変えると変わるけど、carを変えても変わらない。
  (progn (setf (caar a) 7) a)   => ((7 2 3) (4 5 6))
  b                             => ((7 2 3) (4 5 6))
  (progn (setf (car a) 8) a)    => (8 (4 5 6))
  b                             => ((7 2 3) (4 5 6))

eighth

list の 8 番目の要素を返します。

  (eighth X) = (nth 7 X)

使用例：
  (eighth '(1 2 3 4 5 6 7 8 9 0))
  => 8

endp

OBJECT が空かどうかを返します。
リストの終わりを判定するのに使用されます。 null と異なり、
例えば文字列を指定するとエラーを発生します。

  空リストもしくはnil   t
  空でないリスト        nil
  それ以外              エラー

使用例：
  ;;; nullとの違いを見てみる。
  (endp "foo")  => 不正なデータ型です: t: list
  (endp nil)    => t
  (null "foo")  =>nil
  (null nil)    => t

fifth

list の 5 番目の要素を返します。

  (fifth X) = (nth 4 X)

使用例：
  (fifth '(1 2 3 4 5 6 7 8 9 0))
  => 5

first

carの別名です。
全く同じ動きをします。

使用例：
  ;;; carと同じ動きをする。
  (car '(1 2 3))
  => 1
  (first '(1 2 3))
  => 1
  (symbol-function 'car)
  => #<function: car>
  (symbol-function 'first)
  => #<function: car>
 
参考：
  ;;; list.lの定義
  (si:*fset 'first #'car)

fourth

cadddr の別名です。全く同じ動きをします。

intersection

LIST1 と LIST2 の両方に含まれる要素のリストを作って返します。
nintersection と違い引数 LIST1 は保存されます。

使用例:
  (intersection '(1 3 5 7 9) '(2 3 5 7 11))
  => (7 5 3)

last

リストの末尾からN個分のリストを返します。

使用例：
  ;;; 末尾を取得してみる。
  (last '(a b c d))     => (d)
  (last '(a b c d) 2)   => (c d)
  (last '(a b c d) 5)   => (a b c d)

ldiff

OBJECT が LIST の一部であるなら、LIST から OBJECT の部分を除いたリストを返します。

LIST の一部分であるかどうかの判定は eq で行います。
OBJECT が LIST の tailp であれば LIST の一部であるとみなされるとも言えます。

使用例:
  (setq x '(a b c d e))
  => (a b c d e)
  (setq y (cddr x))
  => (c d e)
  (ldiff x y)
  => (a b)
  ;; 見た目は同じでも x の一部分でないならダメ
  (ldiff x '(c d e))
  => (a b c d e)

list

この関数は、 ARGS を要素とするリストを作ります。結果として返されるリ
ストは(常に) nil でターミネート(訳注：終端)されています。 ARGS が与え
られない場合、 empty リストを返します。 

  (list 1 2 3 4 5)
  => (1 2 3 4 5)
  (list)
  => nil

list*

list とよく似て ARGS を要素とするリストを作りますが、 最後の要素だけは
コンスセルの cdr部に直接つなげます。

使用例:
  (setq a (list 1 2 3))
  => (1 2 3)            ; (1 . (2 . (3 . nil)))

  (setq b (list* 1 2 3))
  => (1 2 . 3)          ; (1 . (2 . 3))

  (setq c (list* 4 5 6 a))
  => (4 5 6 1 2 3)

list-length

リストの長さを返します。
リストが循環している場合、length は結果を返さないかもしれませんが、
list-length は nil を返します。

使用例：
  ;;; リストの長さを比べてみる。
  (list-length '())             => 0 
  (list-length '(a b c d))      => 4 
  (list-length '(a (b c) d))    => 3 
  (let ((a '(x)))
    (setf (cdr a) a)
    (list-length a))            => nil

make-list

指定された長さのリストを作成して返します。

  SIZE             : リストの長さ
  :initial-element : リストの要素

使用例：
  (make-list 3)
  => (nil nil nil)
  (make-list 0)
  => nil
  (make-list 2 :initial-element 'x)
  => (x x)

member

LIST の中で ITEM との :test を満たすものがあれば一致したところからのリストを返します。
なければ nil を返します。

使用例：
  (member 'e '(a b c d))
  => nil
  (member 'b '(a b c d))
  => (b c d)

member-if

LIST の中で条件 PREDICATE を満たすものがあれば、そこからのリストを返します。
なければ nil を返します。

使用例：
  (member-if #'numberp '(a b c))
  => nil
  (member-if #'numberp '(a b 3 c))
  => (3 c)

member-if-not

LIST の中で条件 PREDICATE を満たさないものがあれば、そこからのリストを返します。
なければ nil を返します。

使用例：
  (member-if-not #'numberp '(1 2 3))
  => nil
  (member-if-not #'numberp '(1 2 a 3))
  => (a 3)

nbutlast

リストの最後のN要素分を除いたリストを返します。
引数 LIST は破壊されます。

使用例：
  ;;; 最後の要素を取り除きます。
  (setq foo '(1 2 3))
  => (1 2 3)
  (nbutlast foo)
  => (1 2)
  foo
  => (1 2)

nconc

複数のリストを引数にとってそれらを結合したリストを返します。
引数は破壊されます。

使用例：
  ;;; リストをくっつけてみる。
  (setq x '(a b c))
  (setq y '(d e f))
  (nconc x y)
  => (a b c d e f) 
  x
  => (a b c d e f)
  y
  => (d e f)

nintersection

LIST1 と LIST2 の両方に含まれる要素のリストを作って返します。
intersection と違い引数 LIST1 は破壊されます。

使用例:
  (setq x '(1 3 5 7 9))
  => (1 3 5 7 9)
  (setq y '(2 3 5 7 11))
  => (2 3 5 7 11)
  (nintersection x y)
  => (3 5 7)
  x
  => (1 3 5 7)
  y
  => (2 3 5 7 11)

ninth

list の 9 番目の要素を返します。

  (ninth X) = (nth 8 X)

使用例：
  (ninth '(1 2 3 4 5 6 7 8 9 0))
  => 9

nreconc

X を反転させて Y を結合したリストを返します。
引数 X は破壊されます。

  (nreconc x y) == (nconc (nreverse x) y)

nreconcの方が効率が良いようです。

nset-difference

LIST1 から LIST2 にも含まれる要素を除き、そのリストを返します。
set-difference と違い引数 LIST1 は破壊されます。

使用例:
  (setq x '(1 3 5 7 9))
  => (1 3 5 7 9)
  (setq y '(2 3 7))
  => (2 3 7)
  (nset-difference x y)
  => (1 5 9)
  x
  => (1 5 9)

nset-exclusive-or

LIST1 と LIST2 のいずれか一方にのみ含まれる要素のリストを作って返します。
set-exclusive-or と違い引数 LIST2 は破壊されます。

使用例:
  (setq x '(1 3 5 7 9))
  => (1 3 5 7 9)
  (setq y '(2 3 5 7 11))
  => (2 3 5 7 11)
  (nset-exclusive-or x y)
  => (9 1 2 11)
  x
  => (1 3 5 7 9)
  y
  => (2 11)

nsublis

TREE の中で ALIST の :key との :test を満たすものを VALUE に置き換えたリストを返します。
引数 TREE は破壊されます。

使用例：
  ;;; fooの変換テーブルの内容に基づいてbarを変換します。
  (setq foo '((1 . #\a) (2 . #\b) (3 . #\c)))
  => ((1 . #\a) (2 . #\b) (3 . #\c))
  (setq bar '(1 (2 3) ((4 5 6) (7 8 9))))
  => (1 (2 3) ((4 5 6) (7 8 9)))
  (nsublis foo bar)
  => (#\a (#\b #\c) ((4 5 6) (7 8 9)))
  bar
  => (#\a (#\b #\c) ((4 5 6) (7 8 9)))

nsubst

TREE の中で OLD を NEW に置き換えたTREEを返します。
引数 TREE は破壊されます。

使用例：
  ;;; 階層のあるツリーをnsubstしてみる。aは破壊される。
  (setq a '((1 2) ((1 3) (1 4))))       => ((1 2) ((1 3) (1 4)))
  (nsubst 5 1 a)                        => ((5 2) ((5 3) (5 4)))
  a                                     => ((5 2) ((5 3) (5 4)))

nsubst-if

TREEの中でTESTを満たすものがあればNEWに置き換えたものを返します。
TREEが破壊される点を除いてsubst-ifと同じです。

  NEW  : 置き換える要素
  TEST : 置き換えるかどうかを判定するテスト
         non-nilを返したら置き換えます。
  TREE : 対象のツリー

TESTの引数についてはsubst-ifを参照して下さい。

使用例：
  ;;; 適当なツリーを用意して、その要素が奇数ならば0に置き換える。
  (setq a '((1 2) ((1 3) (1 (1 3)))))
  => ((1 2) ((1 3) (1 (1 3))))
  (nsubst-if 0 #'(lambda (x) (and (integerp x) (oddp x))) a)
  => ((0 2) ((0 0) (0 (0 0))))
  a
  => ((0 2) ((0 0) (0 (0 0))))

nsubst-if-not

TREEの中でTESTを満たさないものがあればNEWに置き換えたものを返します。
TREEが破壊される点を除いてsubst-if-notと同じです。

  NEW  : 置き換える要素
  TEST : 置き換えるかどうかを判定するテスト
         nilを返したら置き換えます。
  TREE : 対象のツリー

TESTの引数についてはsubst-ifを参照して下さい。

使用例：
  ;;; 適当なツリーを用意して、数字以外のものがあれば0に変換する。
  (setq a '((123 "abc") '(456 "123") (789 #\a)))
  => ((123 "abc") '(456 "123") (789 #\a))
  (nsubst-if-not 0 #'(lambda (x) (or (listp x) (integerp x))) a)
  => ((123 0) (0 (456 0)) (789 0))
  a
  => ((123 0) (0 (456 0)) (789 0))

nth

リストの N 番目の要素を返します。

  N    : リストのインデックスを指定します。0を基底とします。
  LIST : 要素を返すリストです。

N がリストの長さを越えていれば nil を返します。 N が負数であればエラーを
返します。

  (nth n x) == (car (nthcdr n x))

使用例：
  (nth 2 '(1 2 3 4))
  => 3
  (nth 10 '(1 2 3 4))
  => nil
  (nth -3 '(1 2 3 4))
  => 範囲外の値です: -3

nthcdr

リストの N 番目の cdr を返します。

  N    : リストのインデックスを指定します。0を基底とします。
  LIST : 要素を返すリストです。

N がリストの長さを越えていれば nil を返します。 N が負数であればエラーを
返します。

使用例：
  (nthcdr 1 '(1 2 3 4))
  => (2 3 4)
  (nthcdr 10 '(1 2 3 4))
  => nil
  (nthcdr -3 '(1 2 3 4))
  => 範囲外の値です: -3

nunion

LIST1 と LIST2 を併せたリストを作って返します。
union と違い LIST1 は破壊されます。

使用例:
  (setq x '(1 3 5 7 9))
  => (1 3 5 7 9)
  (setq y '(2 3 5 7 11))
  => (2 3 5 7 11)
  (nunion x y)
  => (1 9 2 3 5 7 11)
  x
  => (1 9 2 3 5 7 11)
  y
  => (2 3 5 7 11)

pairlis

二つのリスト KEYS と DATA から要素を一つずつ組み合わせた連想リストを作って返します。
A-LIST が与えられればそれに加えて返します。

  '(1 2 3 4 5) ─┬→ '((5 . e) (4 . d) (3 . c) (2 . b) (1 . a))
  '(a b c d e) ─┘

使用例：
  (pairlis '(one two) '(1 2) '((three . 3)))
  => ((two . 2) (one . 1) (three . 3))

pop

リストの先頭要素を取り除きます。取り除いた要素を返します。

  PLACE : setfに適用できるものでなければなりません。

使用例：
  (setq x '(a (b c d) e f))     => (a (b c d) e f)
  (pop (cdr (second x)))        => c
  x                             => (a (b d) e f)

互換性：
  Common Lispとxyzzyにあり。
  muleはなさそう。

push

リストの先頭に要素を追加します。

  ITEM  : リストに追加する要素です。
  PLACE : pushする場所はsetfに適用できるものでなければなりません。

使用例：
  ;;; リストの途中にpushしてみる。
  (setq x '(a (b c d) e f))     => (a (b c d) e f)
  (push 99 (cdr (second x)))    => (99 c d)
  x                             => (a (b 99 c d) e f)

互換性：
  Common Lispとxyzzyにあり。
  muleは無さそう。

pushnew

push とほぼ同じですが、リストの最上位に現れている要素でなければリストの
先頭に追加されます。追加するかどうかは、 :test もしくは :test-not で指定
される比較テストを使ってリストの全要素についてチェックして決められます。

  ITEM      : 登録する内容です。
  PLACE     : 登録する場所です。
  :test     : 比較関数です。標準では#'eql？
  :test-not : 比較関数です。
  :key      : キー判定用の関数です。標準では#'identity？

使用例：
  (setq *a* nil)                ;; この時 *a* の値は nil
  (pushnew 'a *a*)  => (a)      ;; この時 *a* の値は (a)
  (pushnew 'b *a*)  => (b a)    ;; この時 *a* の値は (b a)
  (pushnew 'a *a*)  => (b a)    ;; この時 *a* の値は (b a)

互換性：
  Common Lispとxyzzyにあり。
  muleは無さそう。

rassoc

連想リスト A-LIST の中で cdr 部が ITEM との :test を満たす最初のペアを返します。

使用例：
  (rassoc 'a '((a . b) (b . c) (c . a) (z . a)))
  => (c . a)

rassoc-if

連想リスト A-LIST の中で cdr 部が PREDICATE を満たす最初のペアを返します。

使用例：
  (rassoc-if #'numberp '((a . b) (1 . c) (2 . 4)))
  => (2 . 4)

rassoc-if-not

連想リスト A-LIST の中で cdr 部が PREDICATE を満たさない最初のペアを返します。

使用例：
  (rassoc-if-not #'numberp '((a . b) (1 . c) (2 . d)))
  => (a . b)

rest

cdrの別名です。 
全く同じ動きをします。 

使用例： 
  ;;; cdrと同じ動きをする。 
  (cdr '(1 2 3))
  => (2 3)
  (rest '(1 2 3))
  => (2 3)
  (symbol-function 'cdr)
  => #<function: cdr>
  (symbol-function 'rest)
  => #<function: cdr>
 
参考： 
  ;;; evalmacs.lの定義
  (si:*fset 'rest #'cdr)

revappend

X を反転させて Y を結合したリストを返します。
引数 X は保存されます。

  (revappend x y) == (append (reverse x) y)
  
revappendの方が効率が良いようです。

rplaca

リスト X の car を Y に置き換えて、置き換えた X を返します。
(progn (setf (car X) Y) X)と同じでしょうか。

使用例：
  ;;; 置き換えてみる。
  (setq g '(a b c)) 
  => (a b c)
  (rplaca (cdr g) 'd)
  => (d c) 
  g
  => (a d c)

rplacd

リスト X の cdr を Y に置き換えて、置き換えた X を返します。
(progn (setf (cdr X) Y) X)と同じでしょうか。

使用例：
  ;;; 置き換えてみる。
  (setq x '(a b c)) 
  (rplacd x 'd)
  => (a . d) 
  x
  => (a . d)

safe-caaaar

safe-caaaar を返します。

  (safe-caaaar X) = (safe-car (safe-car (safe-car (safe-car X))))

safe-caaadr

safe-caaadr を返します。

  (safe-caaadr X) = (safe-car (safe-car (safe-car (safe-cdr X))))

safe-caaar

safe-caaar を返します。

  (safe-caaar X) = (safe-car (safe-car (safe-car X)))

safe-caadar

safe-caadar を返します。

  (safe-caadar X) = (safe-car (safe-car (safe-cdr (safe-car X))))

safe-caaddr

safe-caaddr を返します。

  (safe-caaddr X) = (safe-car (safe-car (safe-cdr (safe-cdr X))))

safe-caadr

safe-caadr を返します。

  (safe-caadr X) = (safe-car (safe-car (safe-cdr X)))

safe-caar

safe-caar を返します。

  (safe-caar X) = (safe-car (safe-car X))

safe-cadaar

safe-cadaar を返します。

  (safe-cadaar X) = (safe-car (safe-cdr (safe-car (safe-car X))))

safe-cadadr

safe-cadadr を返します。

  (safe-cadadr X) = (safe-car (safe-cdr (safe-car (safe-cdr X))))

safe-cadar

safe-cadar を返します。

  (safe-cadar X) = (safe-car (safe-cdr (safe-car X)))

safe-caddar

safe-caddar を返します。

  (safe-caddar X) = (safe-car (safe-cdr (safe-cdr (safe-car X))))

safe-cadddr

safe-cadddr を返します。

  (safe-cadddr X) = (safe-car (safe-cdr (safe-cdr (safe-cdr X))))

safe-caddr

safe-caddr を返します。

  (safe-caddr X) = (safe-car (safe-cdr (safe-cdr X)))

safe-cadr

safe-cadr を返します。

  (safe-cadr X) = (safe-car (safe-cdr X))

safe-car

(car X) は X が nil か cons でなければエラーになります
しかし safe-car はエラーを発生せずに nil を返します。

使用例：
  ;;; carとsafe-carの違い
  (car "abc")
  => 不正なデータ型です: "abc": cons
  (safe-car "abc")
  => nil

safe-cdaaar

safe-cdaaar を返します。

  (safe-cdaaar X) = (safe-cdr (safe-car (safe-car (safe-car X))))

safe-cdaadr

safe-cdaadr を返します。

  (safe-cdaadr X) = (safe-cdr (safe-car (safe-car (safe-cdr X))))

safe-cdaar

safe-cdaar を返します。

  (safe-cdaar X) = (safe-cdr (safe-car (safe-car X)))

safe-cdadar

safe-cdadar を返します。

  (safe-cdadar X) = (safe-cdr (safe-car (safe-cdr (safe-car X))))

safe-cdaddr

safe-cdaddr を返します。

  (safe-cdaddr X) = (safe-cdr (safe-car (safe-cdr (safe-cdr X))))

safe-cdadr

safe-cdadr を返します。

  (safe-cdadr X) = (safe-cdr (safe-car (safe-cdr X)))

safe-cdar

safe-cdar を返します。

  (safe-cdar X) = (safe-cdr (safe-car X))

safe-cddaar

safe-cddaar を返します。

  (safe-cddaar X) = (safe-cdr (safe-cdr (safe-car (safe-car X))))

safe-cddadr

safe-cddadr を返します。

  (safe-cddadr X) = (safe-cdr (safe-cdr (safe-car (safe-cdr X))))

safe-cddar

safe-cddar を返します。

  (safe-cddar X) = (safe-cdr (safe-cdr (safe-car X)))

safe-cdddar

safe-cdddar を返します。

  (safe-cdddar X) = (safe-cdr (safe-cdr (safe-cdr (safe-car X))))

safe-cddddr

safe-cddddr を返します。

  (safe-cddddr X) = (safe-cdr (safe-cdr (safe-cdr (safe-cdr X))))

safe-cdddr

safe-cdddr を返します。

  (safe-cdddr X) = (safe-cdr (safe-cdr (safe-cdr X)))

safe-cddr

safe-cddr を返します。

  (safe-cddr X) = (safe-cdr (safe-cdr X))

safe-cdr

(cdr X) は X が nil か cons でなければエラーになります
しかし safe-cdr はエラーを発生せずに nil を返します。

second

cadrの別名です。
全く同じ動きをします。

使用例：
  ;;; cadrと同じ動きをする。
  (cadr '(1 2 3))
  => 2
  (second '(1 2 3))
  => 2
  (symbol-function 'cadr)
  => #<lexical-closure: cadr>
  (symbol-function 'second)
  => #<lexical-closure: cadr>
 
参考：
  ;;; list.lの定義
  (si:*fset 'second #'cadr)

set-difference

二つのリストの差を返します。
nset-difference と違い引数 LIST1 は保存されます。

使用例：
  (set-difference  '(3 6 9) '(2 4 6 8 10))
  => (9 3)

set-exclusive-or

LIST1 と LIST2 のいずれか一方にのみ含まれる要素のリストを作って返します。
nset-exclusive-or と違い引数 LIST2 は保存されます。

使用例:
  (set-exclusive-or '(1 3 5 7 9) '(2 3 5 7 11))
  => (9 1 11 2)

seventh

list の 7 番目の要素を返します。

  (seventh X) = (nth 6 X)

使用例：
  (seventh '(1 2 3 4 5 6 7 8 9 0))
  => 7

sixth

list の 6 番目の要素を返します。

  (sixth X) = (nth 5 X)

使用例：
  (sixth '(1 2 3 4 5 6 7 8 9 0))
  => 6

sublis

TREE の中で ALIST の :key との :test を満たすものを VALUE に置き換えたリストを返します。
引数 TREE は保存されます。

使用例：
  ;;; a->1、b->2に変更
  (sublis '((a . 1) (b . 2)) '(a b c))
  => (1 2 c)

subsetp

LIST1 が LIST2 のサブセットなら t、そうでないなら nil を返します。

使用例:
  (subsetp '(1 5 7) '(1 3 5 7 9))
  => t
  (subsetp '(1 5 8) '(1 3 5 7 9))
  => nil

subst

TREE の中で OLD を NEW に置き換えた TREE のコピーを返します。
引数 TREE は保存されます。

使用例：
  ;;; 階層のあるツリーをsubstしてみる。aはそのまま
  (setq a '((1 2) ((1 3) (1 4))))       => ((1 2) ((1 3) (1 4)))
  (subst 5 1 a)                         => ((5 2) ((5 3) (5 4)))
  a                                     => ((1 2) ((1 3) (1 4)))

subst-if

TREE の中で TEST を満たすものがあれば NEW に置き換えたものを返します。
引数 TREE は保存されます。

  NEW  : 置き換える要素
  TEST : 置き換えるかどうかを判定するテスト
         non-nilを返したら置き換えます。
  TREE : 対象のツリー

TESTにはTREEの部分リストと要素を順番に引数として与えるので、必ずしも末端
の要素だけが置き換えの対象とはなりません。例えば、こんな感じで呼び出され
ます。

  ;;; funcで判定する場合
  (subst-if 0 #'func '(1 2 3))

  ;;; funcに引数として与えられる値(1 2 3だけじゃない)
  (1 2 3) 1 (2 3) 2 (3) 3 nil

下の使用例の様に事前の型チェックをして回避します。

使用例：
  ;;; 適当なツリーを用意して、その要素が奇数ならば0に置き換える。
  (setq a '((1 2) ((1 3) (1 (1 3)))))
  => ((1 2) ((1 3) (1 (1 3))))
  (subst-if 0 #'(lambda (x) (and (integerp x) (oddp x))) a)
  => ((0 2) ((0 0) (0 (0 0))))
  a
  => ((1 2) ((1 3) (1 (1 3))))

subst-if-not

TREEの中でTESTを満たさないものがあればNEWに置き換えたものを返します。
TREEは保存されます。

  NEW  : 置き換える要素
  TEST : 置き換えるかどうかを判定するテスト
         nilを返したら置き換えます。
  TREE : 対象のツリー

TESTの引数についてはsubst-ifを参照して下さい。

使用例：
  ;;; 適当なツリーを用意して、数字以外のものがあれば0に変換する。
  (setq a '((123 "abc") '(456 "123") (789 #\a)))
  => ((123 "abc") '(456 "123") (789 #\a))
  (subst-if-not 0 #'(lambda (x) (or (listp x) (integerp x))) a)
  => ((123 0) (0 (456 0)) (789 0))
  a
  => ((123 "abc") '(456 "123") (789 #\a))  

tailp

SUBLISTがLISTを構成しているconsであるかを返す。

具体的にはLISTを順にcdrしていった結果とSUBLISTが
eqならtそうでないならnilを返す。

tenth

list の 10 番目の要素を返します。

  (tenth X) = (nth 9 X)

使用例：
  (tenth '(1 2 3 4 5 6 7 8 9 0))
  => 0

third

caddr の別名です。全く同じ動きをします。

union

LIST1 と LIST2 を併せたリストを作って返します。
nunion と違い引数 LIST1 は保存されます。

使用例:
  (union '(1 3 5 7 9) '(2 3 5 7 11))
  => (1 9 2 3 5 7 11)