制御構造

and

フォームがnilでない間だけ順番に評価します。 
フォームが一つでもnilならば、そこで評価を中断してnilを返して終了します。 
全てのフォームがnilでなければ、最後に実行したフォームの値を返します。 

  ;;; exp1 がnot-nilなら exp2を実行し、 
  ;;; exp2 がnot-nilなら exp3を実行し、 
  ;;; exp3 がnot-nilなら.......
  (and exp1 exp2 exp3 ...)

例えば、以下の様にチェックを順番に記述するような場合に向いていると思います。 
チェックに失敗すれば、以降の処理は実行しません。 

  (and (file-exist-p ...) ; 特定のファイルの存在チェック
       (find-file ...)    ; そのファイルを読み込みチェック
       (scan-buffer ...)  ; 正規表現で検索
       (match-string 2)   ; 検索結果のチェック
       ...)

block

フォームを順番に評価して最後のフォームの結果を返します。 
ほとんどprognですがreturn-fromやreturnで戻り値が指定できるところが違います。 
returnやreturn-fromにぶつかったときには残りの式は評価しません。 

case

C言語のswitch文みたいなのです。 

(case <キー>
  (<リスト1> <式>〜<式>)
  (<リスト2> <式>〜<式>)
       ...
  (<リストn> <式>〜<式>))

まず<キー>を評価し，それが<リスト>のどれかの要素と一致すれば， 
その<リスト>に続く式を順に評価して，最後の式の値をcaseの値として返 
す。どの<リスト>のどの要素にも一致しなければcaseの値はnilである。 
ただし例外として，最後のリスト(<リストn>)がtであれば，「どれにも一
致しなければ」を意味する。 

<リスト1>〜<リストn>までは，それぞれデータのリストで，これら
は評価されない。すなわち値がリストになる式ではなく，リストそのものがここ 
に入る。要素が一つだけの場合は，リストの代わりに要素がここにきてもいい。 

使用例： 
  ;;; 4を入力して場合分けさせる
  (setq x 4)
  => 4
  (case x
    (1 'one)
    (2 'two)
    (3 'three)
    ((4 5) 'four_or_five)
    (t 'large))
  => four_or_five

catch

throwを投げるためのラベルを設定します。 
C++のtryに相当します。 

  C++  : try    throw
  Lisp : catch  throw

参考： 
  エラー処理関連

cond

cond CLAUSE...
     `cond'は任意個の選択肢から選択します。`cond'の個々のCLAUSEはリスト 
     でなければなりません。このリストのCARはCONDITIONです。残りの要素は
     (もしあれば)BODY-FORMSです。したがって句(clause)は次のようになりま
     す。 

          (CONDITION BODY-FORMS...)

     `cond'は個々の句のCONDITIONを評価していくことによって、その句の並び
     をテキストどおりの順序で試します。CONDITIONの値が`nil'でなければ、 
     その句は「成功」します。その場合、`cond' はそのBODY-FORMSを評価し、 
     BODY-FORMSの最後の値が`cond'の値となります。残りの句は無視されます。 

     CONDITIONの値が`nil'ならば、その句は「失敗」し、`cond'は次の句に制
     御を移し、その CONDITIONを試していきます。 

     すべてのCONDITIONが`nil'に評価された場合、すなわち、すべての句が失
     敗した場合、`cond'は`nil'を返します。 

     句は次のようになっているかもしれません。 

          (CONDITION)

     その場合、CONDITIONのテスト結果が`nil'でなければ、CONDITIONの値が 
     `cond'形式の値になります。 

     以下の例では四つの句を持っていて、それぞれ`x'の値が数値、文字列、バッ 
     ファ、シンボルのどれかであるかをテストします。 

          (cond ((numberp x) x)
                ((stringp x) x)
                ((bufferp x)
                 (setq temporary-hack x) ; 一つの句に
                 (buffer-name x))        ; 複数の body-forms
                ((symbolp x) (symbol-value x)))

     最後の句より前の句がどれも成功しなかった場合には、その最後の句を実 
     行したいということがよくあります。これを行うために私たちは次のよう
     に最後の句のCONDITIONとして`t'を使用します。`(t BODY-FORMS)'。形式 
     `t'は`t'に評価され、決して`nil'にはならず、したがって、この句は決し 
     て失敗せず、最悪でもそこには到達する`cond'が提供されます。 

     例えば、 

          (cond ((eq a 'hack) 'foo)
                (t "default"))
          => "default"

     この式は`a'の値が`hack'ならば`foo'を返し、そうでなければ文字列
     `"default"'を返す`cond'です。 

あらゆる条件分岐の構造は`cond'でも`if'でも表現することができます。したがっ
て、どちらを使うかの選択はスタイルの問題です。例えば:

     (if A B C)
     ==
     (cond (A B) (t C))

count-buffers

全バッファの数を返します。 

  ALL : " *Completion*"や" *Minibuf0*"等の先頭が空白のバッファも数えるか？ 
        t       先頭が空白のバッファも数える。 
        nil     先頭が空白のバッファは数えない。 

使用例： 
  ;;; バッファの数を数えてみる。 
  (count-buffers)
  => 20
  (count-buffers t)
  => 23

do

(do ((var1 init1 step1)
     (var2 init2 step2)
            ...
     (varm initm stepm))
    (end-test result1 result2 ... resultm) 
   declaration1
       ...
   declarationN)

(do ((<変数1> <初期値1> <ステップ1>)
     (<変数2> <初期値2> <ステップ2>)
              ...
     (<変数m> <初期値m> <ステップm>))
    (<<終了条件> <後式1> ... <後式p>) 
   <式1>
   ...
   <式n>)


<変数1>〜<変数m>までを局所変数とし，<終了条件>が真
になるまでdo式本体の<式1>〜<式n>を繰り返し実行する。<
変数1>〜<変数m>までは変数を表す記号で，do式の中で局所的に使
われる変数を指定する。do式が評価されるときは，まず<初期値1>〜 
<初期値m>までが評価され，その値が各局所変数にバインドされる。そ
の後で，<終了条件>が評価され，もし値がnilであれば本体を実行する。 
次に<ステップ1>〜<ステップm>までを評価してその値を各局所
変数に代入してから<終了条件>を評価する。これを<終了条件>
の値がnil以外になるまで繰り返す。<終了条件>の値がnil以外になっ
たら，<終了条件>に続く<後式1>〜<後式p>を評価し，そ
の最後の式の値をdo式の値とする。 

do式の一般形は， 

(block nil
  (let ((<変数1> <初期値1> <ステップ1>)
        (<変数2> <初期値2> <ステップ2>)
                 ...
        (<変数m> <初期値m> <ステップm>))
    (tagbody
      loop
      (when <終了条件>
        (return (progn <後式1> ... <後式p>)))
      <式1>
      ...
      <式n>
     (psetq <変数1> <ステップ1>
              ...
            <変数m> <ステップm>)
      (go loop))))

と同値である。(loop というタグは他では使われていないものとする)

do*

doと同じようにループ処理を行う。 
doとだいたい同じだけど、letとlet*の違いのように、局所変数の初期化と更
新の方法にある。doはletを使って局所変数を初期化しているため、全ての初 
期値を計算してから局所変数をバインドするが，do*ではletの代わりにlet*
が使われている。またpsetqのかわりにsetqを使う。 

do*式の一般形は、 

(block nil
  (let* ((<変数1> <初期値1> <ステップ1>)
         (<変数2> <初期値2> <ステップ2>)
                  ...
         (<変数m> <初期値m> <ステップm>))
    (tagbody
      loop
      (when <終了条件>
        (return (progn <後式1> ... <後式p>)))
      <式1>
      ...
      <式n>
     (setq <変数1> <ステップ1>
              ...
           <変数m> <ステップm>)
      (go loop))))

と同値である。(loop というタグは他では使われていないものとする)

dolist

リストの長さ分だけ繰り返しを行います。 

  (dolist (<変数> <リスト式> <値>)
    <式1> ... <式n>)

まず<リスト式>を評価する。その後リストの要素ごとに変数をその要素に
バインドして，本体の<式1>〜<式n>までを評価する。本体式の評価
が全ての要素に対して終わると，<値>を評価し，dolistの値として返す。 
また<値>は省略でき，その場合はdolistの値はnilである。 

dolist式の一般形は， 
  
  (do* ((temp <リスト式> (cdr temp))
        (<変数> (car temp) (car temp)))
      ((endp temp) <値>)
    <式1>
    ...
    <式n>)
  
と同値である。 

使用例： 
  (let ((result nil))
    (dolist (item '("Lois" "Charley" "David") (nreverse result))
      (push (length item) result))))
  => (4 7 5)

dotimes

(dotimes (<変数> <整数式> <値>)
  <式1> ... <式n>)

指定された回数だけ繰り返しを行う。 

まず<整数式>を評価する。その値をnとすると，0〜n-1までのそれぞれの
整数値に対して，<変数>をその整数値にバインドして，本体の<式1>
〜<式n>までを評価する。すなわち本体式はn回繰り返される。本体式の評 
価がn回繰り返されると，<値>を評価し，dotimesの値として返す。 
また<値>は省略でき，その場合はdotimesの値はnilである。 

dotimes式の一般形は， 

(do* ((temp <整数式>)
      (<変数> 0 (1+ <変数>)))
    ((>= <変数> temp) <値>)
  <式1>
  ...
  <式n>)

と同値である。 

if

いわゆるIF文を実行します。 
TESTがnon nilならTHENを実行。nilならELSEを実行します。 

構文： 
  (if TEST THEN [ELSE])

lambda

関数に名前を付ける必要がなく、手続きだけを記述したい場合にラムダ式 
  を用いる。ラムダ式の二番目の引数はラムダリストと呼ばれ、関数の
  パラメータの名前を与える。lambda式のより完全な構文は以下である。 

  (lambda ({var}*
           [&optional {var | (var [initform [svar]])}*]
           [&rest var]
           [&key {var | ({var | (keyword var)} [initform [svar]])}*]
           [&aux {var | (var [initform])}*])
     [[{declaration}* | documentation-string]]
     {form}*)
  
  引数がラムダ式によって表される関数に適用されると、form が評価
  されて最後の form の結果が返される。form は順に評価される。 

  ((lambda (x y) (+ x y)) 10 20)        => 30
  
  ラムダリストの各要素は、パラメータ指定子や、記号＆（アンパサンド） 
  で始まるラムダリストキーワードからなる。ラムダリストは５つの部分で
  構成される。 
  
  ・必須パラメータの記述
      ラムダリストキーワードよりも前に現れる var を必須パラメータという。 
  
  ・オプショナルパラメータの記述
      &optionalから次のラムダリストキーワードまでか、ラムダリストの
      終わりまで。関数呼び出し時に、オプショナルパラメータに対応する 
      引数はあっても無くてもよい。引数が省略された場合、initform が 
      あれば initform に初期化され、無ければ nil で初期化される。 
      svar は引数が与えられたかどうかを示す。 
  
    ((lambda (x &optional (y 0 given))
         (if given (+ x y) x))
      10 20)
    => 30
  
  ・レストパラメータの記述
      &restとそれに続く一つのパラメータ指定子。関数への引数のうち、 
      必須パラメータとオプショナルパラメータに対応するもの以外 
      からなるリストが束縛される。 
  
    ((lambda (x &optional (y 1) (z 2) &rest args)
         (list x y z args))
      'a 'b 'c 'd 'e 'f)
    => (a b c (d e f))
  
  ・キーワードパラメタの記述
      &keyから次のラムダリストキーワードまでか、ラムダリストの
      終わりまで。関数が呼ばれたときに対応する keyword に対応する 
      パラメータ指定子 var に値を束縛する。 
  
    ((lambda (x &key ((:test f) #'eq))
         (if (funcall f x "word") 'True 'False))
     "word" :test #'equal)
    => True
  
    ((lambda (x &key (test #'eq))
         (if (funcall test x "word") 'True 'False))
      "word" :test #'eql)
    => False
  
  ・補助変数の記述
      ラムダリストに &aux が含まれるなら、この後の全ての指定は
      補助変数の指定子である。次に示す二つの例は同じ結果を与える。 
      これらの使用については純粋にスタイルの問題である。 
    
    ((lambda (x &aux (l (length x)))
         (list x l))
      '(a b c))
    => ((a b c) 3)
    
    ((lambda (x)
         (let ((l (length x))) (list x l)))
      '(a b c))
    => ((a b c) 3)

loop

無限ループします。 
脱出するには以下の様にreturnを使います。 

 (loop
   処理 
   (if 条件 (return 値))
   処理)

使用例： 
  ;;; 「はい」と答えるまで繰り返し
  (loop (if (yes-or-no-p "quit?") (return 123)))
  => 123

mapc

引数の渡し方はmapcarとよく似ていますが、戻り値には与えられたリストをその
まま返します。 

--- 原文 ---
Description: similar to mapcar except that the value returned is list 
rather than a list of values returned by the calls to function. As such, 
a mapc form is evaluated for its side effects rather than the value it 
returns.

--- 意訳 ---
mapcは戻り値が、FUNCTIONによって返された値のリストではなくもともとの引数
であるLISTな点を除いて、macpcarに良く似ている。そのため、mapcは戻り値
ではなく副作用を目的として評価される。 

mapcan

引数の渡し方はmapcarによく似ていますが、関数の呼び出し結果のリストをくっ
つけたものを返します。 

--- 原文 ---
Description: similar to mapcar except that the values returned by calls 
to function are combined using the destructive function nconc rather than 
the non-destructive function list. As such, mapcan can potentially destroy 
its arguments.

--- 意訳 ---
mapcanはFUNCTIONによって返された値が（non-destructiveな関数listではなく、 
destructiveな関数nconcによって）結合されることを除いて、mapcarに良く似て
いる。そのため、mapcanはその定義から引数を破壊することになっている。 

使用例： 
  ;;; mapcanとmapcarとの違い
  (mapcan #'(lambda (x) (and (characterp x) (list (char-name x))))
          '(456 #\A 789 #\b #\c 123))
  => ("latin_capital_letter_a" "latin_small_letter_b" "latin_small_letter_c")
  (mapcar #'(lambda (x) (and (characterp x) (list (char-name x))))
          '(456 #\A 789 #\b #\c 123))
  => (nil ("latin_capital_letter_a") nil ("latin_small_letter_b") ("latin_small_letter_c") nil)

mapcar

引数のリストから関数の戻り値のリストを作成して返します。 
初回は各リストのcarを、二回目はcadrを、三回目はcaddrを関数に渡します。 
リストが複数の場合が分かりにくいので図示します。 

  ;;; リストが一つ      ┌──┐┌──┐┌──┐ 
  (mapcar #'char-name '(│ #\a││ #\b││ #\c│))
                        └─┬┘└─┬┘└─┬┘ 
                    ┌───┘      │      └───┐ 
                    ↓              ↓              ↓ 
  == (list (char-name #\a) (char-name #\b) (char-name #\c))
  == (list "latin_small_letter_a" "latin_small_letter_b" "latin_small_letter_c")
  => ("latin_small_letter_a" "latin_small_letter_b" "latin_small_letter_c")

  ;;; リストが複数   ┌─┐┌─┐┌─┐ 
  (mapcar #'+      '(│ 1││ 2││ 3│ 4)
                   '(│ 1││ 3││ 5│  )
                   '(│ 1││ 4││ 9│16)
                   '(│ 1││ 8││27│  )) 
                     └┬┘└┬┘└┬┘ 
             ┌────┘┌─┘    │   
             ↓          ↓        ↓         
  == (list (+ 1 1 1 1) (+ 2 3 4 8) (+ 3 5 9 27))
  == (list 4 17 44)
  => (4 17 44)

--- 原文 ---
Description: passes successive, corresponding top level elements of each 
of the lists to function. function should thus be able to accept as many 
arguments as there are lists. The value returned by mapcar is a list of 
the values returned by each function call. If the argument lists are not 
of equal length, evaluation of the mapcar form is terminated when the 
last element of the shortest list has been passed to function. Any elements 
in the other lists that have not been processed are ignored.

--- 意訳 ---
mapcar は各リストの最上位の対応する要素群を FUNCTION に引き渡します。 
FUNCTION はリストのような多くの引数を受け入れられなければなりません。 
mapcar が返す値は、FUNCTION のそれぞれの呼び出した値のリストです。もし、 
引数のリストが同じ長さでなかったら、mapcar の評価は一番短いリストで終わ
ります。 

使用例： 
  (mapcar #'+ '(1 2 3 4) 
              '(1 3 5) 
              '(1 4 9 16) 
              '(1 8 27)) 
  => (4 17 44)

mapcon

引数の渡し方はmaplistによく似ていますが、関数の呼び出し結果のリストをくっ
つけたものを返します。 

mapl

引数の渡し方はmaplistとよく似ていますが、戻り値には与えられたリストをそ 
のまま返します。 

maplist

引数のリストから関数の戻り値のリストを作成して返します。 
初回は各リストを、二回目はcdrを、三回目はcddrを関数に渡します。 

--- 原文 ---
Description: similar to mapcar but passes successive, corresponding tails 
of the argument lists to function. So, on the first call to function, the 
argument lists are passed in their entirety. On the second call the cdr 
of each argument list is passed. On the third, the cddr of each argument 
list is passed, and so on. This process is repeated until the tail of an 
argument list is a null list. The value returned by maplist is a list of 
the values returned by each call to function.

--- 意訳 ---
maplist は、FUNCTION に対応するテイルの部分を FUNCTION に渡すことを除い 
て、mapcar に良く似ている。FUNCTION の最初の呼び出しで、引数のリストは完 
全に渡されます。二度目の呼び出しでは各引数の、 cdr  が渡されます。 

使用例： 
  (maplist #'(lambda (x) (cons 'foo x)) '(a b c d))
  => ((foo a . #1=(b . #2=(c . #3=(d)))) (foo . #1#) (foo . #2#) (foo . #3#))

multiple-value-setq

返された多値を個々の変数に設定します。 
変数の個数よりもフォームが返した値の数が多いときには余った分は捨てられま
す。少ない場合には、足りない分だけnilが設定されます。 

  VARIABLES : 変数のリスト 
  FORM      : 評価するフォーム

使用例： 
  ;;; valuesで多値を返した場合 
  (setq a (values 1 2)) => 1
  a                     => 1
  (multiple-value-setq (a b) (values 1 2))
                        => 1
  a                     => 1
  b                     => 2

or

フォームがnilの間だけ順番に評価します。 
フォームが一つでもnilでなければ、そこで評価を中断してフォームの値を返し
て終了します。全てのフォームがnilならば、nilを返します。 

  ;;; exp1 がnilなら、そこで実行を中止しnilを返す。 
  ;;; exp2 がnilなら、そこで実行を中止しnilを返す。 
  ;;; ...
  ;;; 最後に実行したexpの値を返す。 
  (or exp1 exp2 exp3 ...)

ルールに従って一つだけ値を定める場合に向いていると思います。 

  (or (get-buffer-file-name) ; バッファにファイル名があればそれを使う。 
      *foo*                  ; ファイル名がなければ、変数*foo*の値を使う。 
      (read-string "foo: ")) ; *foo*にも値が無ければ入力してもらう。 

prog1

フォームを順番に評価して最初のフォームの結果を返します。 

使用例： 
  (prog1 (print "The first form")
         (print "The second form")
         (print "The third form"))
  -> "The first form"
  -> "The second form"
  -> "The third form"
  => "The first form"

progn

フォームを順番に評価して最後のフォームの結果を返します。 

使用例： 
  (progn (print "The first form")
         (print "The second form")
         (print "The third form"))
  -> "The first form"
  -> "The second form"
  -> "The third form"
  => "The third form"

return

指定された値でブロックから脱出します。 
catchしてくれるブロックがないと例外が発生します。 

  (return RESULT) = (return-from nil RESULT)

使用例： 
  ;;; ループからの脱出の場合 
  (loop (if (yes-or-no-p "quit?") (return 123)))
  => 123

  ;;; ブロックが無いのでcatchできない場合 
  (if (yes-or-no-p "quit?") (return 123))
  => `return-from'のキャッチャを参照できません: nil

return-from

ブロックから脱出します。 
--- 原文 ---
Description: used to terminate the evaluation of the block construct with 
name NAME. The name argument is not evaluated and must be a symbol. When 
return-from is encountered the result-form is evaluated if present and 
evaluation of the block is terminated. The block returns the value returned 
by the result-form or nil if no result-form is present. If name is nil, 
return-from can be used to terminate the evaluation of do  and prog 
constructs that automatically create a block called nil to enclose their 
argument forms.

Example:

(block fred
  (setq x 10)
  (loop (incf x) (if (> x 20) (return-from fred x))))
 21

step

ステップ実行を行います。 

tagbody

labelジャンプです。 
tagbody内は任意の数のtag(シンボルもしくは数字)とstatement(S式)からなり 
実行時にはtagは無視されstatementが実行されます。(go tag)が評価されたときに
実行はtagの場所に移ります。tagbodyは終了時にnilを返します。 

throw

catchで指定されたラベルまで、非局所脱出します。 
名前はC++と同じです。 

  C++  : try    throw
  Lisp : catch  throw

使用例： 
  ;;; test2で例外を出してtest1でキャッチする。 
  (defun test1 (x)
    (catch 'label1
      (test2 x)))
  => test1
  (defun test2 (x)
    (if (zerop x)
        (throw 'label1 'division-by-zero)
        (/ 1 x)))
  => test2
  (test1 0)
  => division-by-zero

参考： 
  エラー処理関連

unless

条件が成立しない場合に実行します。whenの逆です。 

  (unless 条件式  本体 ....)

unwind-protect

PROTECTED-FORM 中に終了もしくは例外が発生しても（正常、異常を問わず） 
CLEANUP-FORM を実行します。 

使用例： 
  ;;; ゼロ除算が起きても CLEANUP-FORM が実行される。 
  (progn
    (msgbox "計算前")
    (unwind-protect (/ 1 0)
      (msgbox "計算後")))
  => 0で除算しました: /: (1 0)

values-list

指定されたリストを多値として返します。 

  (values-list '(a b c)) == (values a b c)
  (values-list list) == (apply #'values list)

when

条件がnilでなければフォームを連続して実行します。 

  TEST : 条件部
  BODY : nilでない場合に実行するフォーム

whenはマクロです。以下の様に展開されます。 

 (when exp1 exp2 exp3 ...)
 = (if exp1
      (progn exp2
             exp3
             ...))

while

条件節が成立する間、BODYを繰り返して実行します。 
BODYの実行の途中でwhileを抜けるには、returnを使います。 

  (while 条件 本体)

使用例： 
  ;;; 確認しつつ処理を実行する場合 
  (while (yes-or-no-p "次行に移動しますか？")
    (forward-line)
    (reverse-region (progn (goto-bol) (point))
                    (progn (goto-eol) (point)) t)
    (refresh-screen))
  => nil