シーケンス

concatenate

（詳細不明） 

使用例： 
  (concatenate 'string     "^X-Status[ \t]*:[ \t]*" (car from) "[ \t]*$")

copy-seq

SEQUENCEのコピーを作成して返します。元のSEQUENCEとはequalpだがeqではありません。 

  (copy-seq x) == (subseq x 0)

count

ITEMとのテストを満足するSEQUENCE中の要素数を返します。結果は非負の整数です。 

  :from-end : 他の関数との互換性のために用意されたもので、結果に影響しません。 
  :test     : テストを行う2項演算子 
  :start    : テストする開始位置
  :end      : テストの終了位置

count-if

TESTを満足するSEQUENCE中の要素数を返します。結果は非負の整数です。 

  :from-end : 他の関数との互換性のために用意されたもので、結果に影響しません。 
  :test     : テストを行う2項演算子 
  :start    : テストする開始位置
  :end      : テストの終了位置

count-if-not

TESTを満足しないSEQUENCE中の要素数を返します。結果は非負の整数です。 

  :from-end : 他の関数との互換性のために用意されたもので、結果に影響しません。 
  :test     : テストを行う2項演算子 
  :start    : テストする開始位置
  :end      : テストの終了位置

delete

SEQUENCEの中でITEMと一致するものを削除したSEQUENCEを返します。 
元のSEQUENCEは変更されます。元のSEQUENCEを保持したければ、removeを使うこと。 

  :count    : 削除する文字数を制限します。 
  :from-end : :countが指定された場合にのみ意味を持ちます。 
         nil    SEQUENCEの先頭から削除します。 
         t      SEQUENCEの後尾から削除します。 

使用例： 
  ;;; removeとdeleteを使ってみる。 
  (setq foo "abcabcdef")        => "abcabcdef"
  (remove #\b foo)              => "acacdef"
  foo                           => "abcabcdef"
  (delete #\b foo)              => "acacdef"
  foo                           => "acacdef"

delete-if

SEQUENCEの中でPREDICATEを満たすものを削除します。 

delete-if-not

SEQUENCEの中でPREDICATEを満たさないものを削除します。 

elt

SEQUENCEのINDEX番目の要素を返します。 
INDEXは0を基底とします。なければnilを返します。 

every

SEQUENCEの先頭の要素から順番にPREDICATEを適用していき、PREDICATEが 
nil を返すと、nilをすぐに返します。 
全ての要素がPREDICATEを満たす場合、 t を返します。 

MORE-SEQUNCESが与えられた時、SEQUENCEの中で最も短いものの終わりまで実行されます。 

fill

SEQUENCEのそれぞれをITEMに置換えます。元のSEQUENCEは置き換えられます。 

使用例： 
  ;;; シーケンスを作って、変更してみる。 
  (setq foo (make-sequence 'string 8 :initial-element #\a))
  => "aaaaaaaa"
  (fill foo #\b :start 3 :end 4)
  => "aaabaaaa"
  foo
  => "aaabaaaa"

find

SEQUENCE の中で ITEM との :test を満たすものがあればそれを返します。なければ
nilを返します。 

使用例： 
  ;;; リストから'aを探してみる。 
  (find 'a '(e c a b))
  => a

find-if

SEQUENCEの中でPREDICATEを満たすものがあればそれを返します。なければnilを返します。 

find-if-not

SEQUENCEの中でPREDICATEを満たさないものがあればそれを返します。なければ
nilを返します。 

length

sequence(文字列や、リスト、配列)の長さを求めます。 
配列にfill-pointerがある場合は、そこまでの長さになります。 

使用例： 
  (length "abcd")               => 4
  (length (list 1 2 3))         => 3
  (length (make-array 7))       => 7
  (length (make-array 7 :fill-pointer 4))
                                => 4

make-sequence

要素のタイプが type でサイズが size なシーケンスを作成して返します。 
:initial-element が与えられた場合はそれぞれの項目はそれで初期化されます。 

使用例： 
  ;;; #\aが8文字の文字列を作ってみる 
  (make-sequence 'string 8 :initial-element #\a)
  => "aaaaaaaa"
  (make-sequence 'list 4 :initial-element "abc")
  => (#1="abc" #1# #1# #1#)

merge

SEQUENCE1とSEQUENCE2を併合します。SEQUENCE1とSEQUENCE2は破壊されません。 
PREDICATEによりSEQUENCE1とSEQUENCE2の値を比較し、非nilならば SEQUENCE1の値を 
nil ならば SEQUENCE2の値を順にマージしていきます。 

  RESULT-TYPE : 結果となるシーケンスの型を指定します。 
  PREDICATE   : シーケンス同士を比較する関数を指定します。 
  :key        : 比較対照を取得する関数を指定します。 

例 
  (merge 'list '(1 2 3 5 8) '(2 4 6) #'<) => (1 2 2 3 4 5 6 8)
  (merge 'string "AbCF" "aBcd" #'char-lessp) => "AabBCcdF"

notany

SEQUENCEの先頭の要素から順番にPREDICATEを適用していき、PREDICATEが 
非nilな値を返すと、 nil をすぐに返します。 
PREDICATEを満たす要素が見つからない時は t を返します。 

MORE-SEQUNCESが与えられた時、SEQUENCEの中で最も短いものの終わりまで実行されます。 

notevery

SEQUENCEの先頭の要素から順番にPREDICATEを適用していき、PREDICATEが 
nil を返すと、t をすぐに返します。 
全ての要素がPREDICATEを満たす場合、 nil を返します。 

MORE-SEQUNCESが与えられた時、SEQUENCEの中で最も短いものの終わりまで実行されます。 

nreverse

SEQUENCEを逆順にした新しいSEQUENCEを作成して返します。元のsequenceは破壊 
されます。 

使用例： 
  (setq lst '(a b c))
  => (a b c)
  (nreverse lst)
  => (c b a)
  lst
  => (a)

nsubstitute

SEQUENCE に対して OLDITEM との :test を満足する要素を NEWITEM に置き換えた列を返します。 
元の SEQUENCE は変更されます。 

  :test     : テストを行う2項演算子 
  :start    : 開始位置。デフォルトは0で非負の整数
  :end      : 終了位置。デフォルトはnilで、nilの場合は列の長さを指定した 
              場合と等しい動作。 
  :count    : 置き換える最大の回数。 
  :from-end : nil ならば先頭から、non-nil で末尾から置換を行う。 :count
              が与えられた時のみ意味を持つ。 

nsubstitute-if

SEQUENCEに対してTESTを満足する要素をNEWITEMに置き換えた列を返します。 
元のSEQUENCEは変更されます。 

  TEST      : テストを行う単項演算子 
  :start    : 開始位置。デフォルトは0で非負の整数
  :end      : 終了位置。デフォルトはnilで、nilの場合は列の長さを指定した 
              場合と等しい動作。 
  :count    : 置き換える最大の回数。 
  :from-end : nil ならば先頭から、 non-nil で末尾から置換を行う。 :count
              が与えられた時のみ意味を持つ。 

nsubstitute-if-not

SEQUENCEに対してTESTを満足しない要素をNEWITEMに置き換えた列を返します。 
元のSEQUENCEは変更されます。 

  TEST      : テストを行う単項演算子 
  :start    : 開始位置。デフォルトは0で非負の整数
  :end      : 終了位置。デフォルトはnilで、nilの場合は列の長さを指定した 
              場合と等しい動作。 
  :count    : 置き換える最大の回数。 
  :from-end : nil ならば先頭から、 non-nil で末尾から置換を行う。 :count
              が与えられた時のみ意味を持つ。 

position

SEQUENCE の中で ITEM との :test を満たすものがあればそのインデックスを返します。 
なければ nil を返します。 

使用例： 
  ;;; リストの中から'aのインデックスを調べる 
  (position 'a '(e c a b))
  => 2

position-if

SEQUENCEの中でPREDICATEを満たすものがあればそのインデックスを返します。 
なければnilを返します。 

position-if-not

SEQUENCEの中でPREDICATEを満たさないものがあればそのインデックスを返します。 
なければnilを返します。 

reduce

2項演算子であるFUNCTIONで、SEQUENCEに対して畳み込みを行います。 
  
  FUNCTION  : 2項演算子。 
  :from-end : nil なら先頭から、non-nil なら最後の要素から畳み込みを行います。 
  :start    : 畳み込みを行う SEQUENCE の開始インデックスです。デフォルトは 0 です。 
              :from-end が non-nil なら終了インデックスになります。 
  :END      : 畳み込みを行う SEQUENCE の終了インデックスです。デフォルトは nil です。 
              :from-end が non-nil なら開始インデックスになります。 
  :INITIAL-VALUE : non-nil ならばこの値を初期値として使用します。 

 (reduce #'- '(1 2 3)) = (- (- 1 2) 3)
 (reduce #'- '(1 2 3) :initial-value 10) = (- (- (- 10 1) 2) 3)
 (reduce #'- '(1 2 3) :from-end t :initial-value 10) = (- 1 (- 2 (- 3 10)))

remove

SEQUENCEの中でITEMと一致するものを削除したSEQUENCEを返します。 
元のSEQUENCEはそのまま。元のSEQUENCEを変更したければ、deleteを使うこと。 

  :count    : 削除する文字数を制限します。 
  :from-end : :countが指定された場合にのみ意味を持ちます。 
         nil    SEQUENCEの先頭から削除します。 
         t      SEQUENCEの後尾から削除します。 

使用例： 
  ;;; removeとdeleteを使ってみる。 
  (setq foo "abcabcdef")        => "abcabcdef"
  (remove #\b foo)              => "acacdef"
  foo                           => "abcabcdef"
  (delete #\b foo)              => "acacdef"
  foo                           => "acacdef"

remove-if

SEQUENCEの中でPREDICATEを満たすものを削除したSEQUENCEを返します。 
元のSEQUENCEはそのまま。 

remove-if-not

SEQUENCEの中でPREDICATEを満たさないものを削除したSEQUENCEを返します。 
元のSEQUENCEはそのままです。 

replace

SEQUENCE1 を SEQUENCE2 で置換します。元の SEQUENCE は置き換えられます。 
SEQUENCE1 の :start1-:end1 の位置に、 SEQUENCE2 の :start2-:end2 を挿入
します。 

使用例： 
  (setq foo (make-sequence 'string 8 :initial-element #\a))
  => "aaaaaaaa"
  (setq bar (make-sequence 'string 3 :initial-element #\b))
  => "bbb"
  (replace foo bar)
  => "bbbaaaaa"
  (replace foo bar :start1 4 :end1 5)
  => "bbbabaaa"

reverse

SEQUENCEを逆順にした新しいSEQUENCEを作成して返します。元のsequenceはそのままです。 

some

SEQUENCEの先頭の要素から順番にPREDICATEを適用していき、PREDICATEが 
非nilな値を返すと、その値をSOMEの戻り値としてすぐに終了します。 
PREDICATEを満たす要素が見つからない時は nil を返します。 

MORE-SEQUNCESが与えられた時、SEQUENCEの中で最も短いものの終わりまで実行されます。 

sort

SEQUENCE を PREDICATE に従った順番に並び替えたものを返します。元の SEQUENCE
は変更されます。 sort は安定であることは保証されません。安定なソートが必要 
なときは stable-sort を使いましょう。 

  SEQUENCE  : ソートするシーケンスを指定します。 
  PREDICATE : 比較関数を指定します。 
  :key      : 比較対象を取得する関数を指定します。 

使用例： 
  (setq *test-seq* '(("foo") ("bar") ("hoge")))
  => (("foo") ("bar") ("hoge"))
  (setq *test-seq* (sort *test-seq* #'string-lessp :key #'car))
  => (("bar") ("foo") ("hoge"))
  *test-seq*
  => (("bar") ("foo") ("hoge"))
 
  (setq *test-seq* '(("foo") ("bar") ("hoge")))
  => (("foo") ("bar") ("hoge"))
  (sort *test-seq* #'string-lessp :key #'car)
  => (("bar") ("foo") ("hoge"))
  *test-seq*
  => (("foo") ("hoge"))

参考： 
  [xyzzy:06221] (こっそり)バージョンアップのお知らせ
  ・sort のアルゴリズムを quick から merge に変更
  (比較回数が少ない分、merge の方が速いっぽい)。 
  結果、stable-sort と同じになった(が、依存しないように)。 
  従来は *たまたま* (eq list (sort list)) だったが、 
  そうではなくなったので注意すること。 

stable-sort

SEQUENCE を PREDICATE に従った順番に並び替えたものを返します。元の SEQUENCE
は変更されます。 stable-sort は安定なソートを行います。つまり PREDICATE によっ
て同順と見なされる要素間の順序は、ソート前と同じであることが保証されます。 

  SEQUENCE  : ソートするシーケンスを指定します。 
  PREDICATE : 比較関数を指定します。 
  :key      : 比較対象を取得する関数を指定します。 

使用例： 
  (setq *test-seq* '(("foo") ("bar") ("hoge")))
  => (("foo") ("bar") ("hoge"))
  (setq *test-seq* (stable-sort *test-seq* #'string-lessp :key #'car))
  => (("bar") ("foo") ("hoge"))
  *test-seq*
  => (("bar") ("foo") ("hoge"))
 
  (setq *test-seq* '(("foo") ("bar") ("hoge")))
  => (("foo") ("bar") ("hoge"))
  (stable-sort *test-seq* #'string-lessp :key #'car)
  => (("bar") ("foo") ("hoge"))
  *test-seq*
  => (("foo") ("hoge"))

subseq

SEQUENCEのSTART番目からENDもしくは最後までの新しいsequenceを返します。 

substitute

SEQUENCE に対して OLDITEM との :test を満足する要素を NEWITEM に置き換え 
た列を返します。元の SEQUENCE は変更されませんが、戻り値と一部を共有する 
かもしれません。 

  :test     : テストを行う2項演算子 
  :start    : 開始位置。デフォルトは0で非負の整数
  :end      : 終了位置。デフォルトはnilで、nilの場合は列の長さを指定した 
              場合と等しい動作。 
  :count    : 置き換える最大の回数。 
  :from-end : nil ならば先頭から、non-nil で末尾から置換を行う。 :count
              が与えられた時のみ意味を持つ。 

substitute-if

SEQUENCEに対してTESTを満足する要素をNEWITEMに置き換えた列を返します。 
元のSEQUENCEは変更されませんが、戻り値と一部を共有するかもしれません。 

  TEST      : テストを行う単項演算子 
  :start    : 開始位置。デフォルトは0で非負の整数
  :end      : 終了位置。デフォルトはnilで、nilの場合は列の長さを指定した 
              場合と等しい動作。 
  :count    : 置き換える最大の回数。 
  :from-end : nil ならば先頭から、non-nil で末尾から置換を行う。 :count
              が与えられた時のみ意味を持つ。 

substitute-if-not

SEQUENCEに対してTESTを満足しない要素をNEWITEMに置き換えた列を返します。 
元のSEQUENCEは変更されませんが、戻り値と一部を共有するかもしれません。 

  TEST      : テストを行う単項演算子 
  :start    : 開始位置。デフォルトは0で非負の整数
  :end      : 終了位置。デフォルトはnilで、nilの場合は列の長さを指定した 
              場合と等しい動作。 
  :count    : 置き換える最大の回数。 
  :from-end : nil ならば先頭から、non-nil で末尾から置換を行う。 :count
              が与えられた時のみ意味を持つ。