// (2)
    double func(int m, int n){
        if(m > n) return 0;
        else      return (sqrt((double)m) + func(m+1,n));
    }

→Referential Transparency

Destructive update(assignment)

　破壊的更新と訳されている。題にもある通り、破壊的代入も同じ意味である。
　ある記憶領域の値を破壊して、他の値に変更することを言う。上書きすることといってもよい。
　命令型言語で書かれたプログラムは基本的に、変数の破壊的更新によって成り立っている。これがなければコマンドの並びをつながりのあるものにできないからである。詳しくは、命令型パラダイム(imperative paradigm)参照。
　これの最も典型的な操作は、代入(assignment)である。これについては、その項を参照。
　破壊的更新は、プログラミング言語に様々な問題点をもたらす。これについては、副作用(side effect)と参照透明性(referencial transparency)の項を参照。
　ただ、それらの項でも述べているように、破壊的更新は、計算機にとって見れば、非常に有効な操作であるとも言える。それは、外界とのやり取り（ファイル操作、オブジェクト操作(GUI操作)、プロセス制御等）を行う為であり、或は、状態（口座の残高等）をモデル化するためである。SICPの3.1も参照。
　ここでは具体例として、ファイル操作をあげる（エラー処理は省略）。"file"に文字列"aa"を一文字ずつ書込み、表示したいとする。
　まず、ある関数を仮定する。つまり、一文字とFILE型のオブジェクトを引数として取り、ファイルの最後にその文字を追加し、ファイル内容を結果として出す関数である。

　　　char *appended(char c, FILE *fp);

　そして、以下のようなプログラムがあるとする。

    int main(void)
    {
        FILE *fp = fopen("file","r+");

        printf("%s\n",appended('a', fp));　　　/* (1) */
        printf("%s\n",appended('a', fp));　　　/* (2) */

        fclose(fp);
        return 0;
    }

→Assignment、 Imperative paradigm、 Referential Transparency、 Side effect

Dynamic binding

　動的束縛とか単に動的バインディングなどと訳されている。dynamic scopingともいう。
　定義としては、静的束縛(static binding)と対を成すが、ある名前がどのオブジェクトにバインドされているのかがプログラムテキストからは直接には分からない束縛をいう。このために、実際のバインディングを実行時まで延期しなければならない。つまり、プログラムの動的な制御の流れに依存するのである。オブジェクト指向的に読み直すと、実行時において、メッセージ受信後に、そのメッセージと実行されるメソッドが結合されることということになろうかと思う。
　具体例を挙げる。

    const int x = 0;　　　　　　　　　　　　// (a)

    int func(int n) {
        return n * x;
    }

    void proc(void) {
        const int x = 1;　　　　　　　　　// (b)

        cout << func(5) << endl;　　　　　// (1)
    }

    int main(void) {
        cout << func(5) << endl;　　　　　// (2)

        return 0;
    }

→Binding、 Environment、 Scope、 Type checking、 Typing

Environment

　環境と訳されている。文脈(context)とも言われる。
　プログラミング言語の世界でも開発環境との関連で色々な意味で使用されているが、ここでは束縛(binding)に関連した環境を説明する。
　環境とは、束縛の集合或はその記憶である。束縛については、その項を参照。識別子の集合から実体の集合への部分関数といっても良いかもしれない。あらゆる式やコマンドは特定の環境下で評価され実行される。従って、異なった環境では式やコマンドの結果も異なってくることになる。
　具体例を挙げる。

    int x;

    void proc(int x)
    {
        double y;
        ...　　　　　　　　　　　　　　　　　// (1)
    }

    int main(void)
    {
        ...　　　　　　　　　　　　　　　　　// (2)
        double x;
        int y;
        ...　　　　　　　　　　　　　　　　　// (3)
        proc(10)
        ...
        return 0;
    }

→Binding、 Block、 Dynamic binding、 Closure、 Side effect

Evaluation order

　評価順序などと訳されていると思う。計算モデルのレベルでは、簡約戦略(reduction strategy)と言われる。
　評価順序というからには、文字通り式が評価される順番のことだが、関数型言語の場合、プログラムが関数適用と関数定義のみによって成り立っているので、結局、結合性(associativity)と優先順位(precedence)を除くと、関数の実引数（部分項）がいつ評価されるのかという問題だけが残る（複数の条件式の評価順序の問題も残されているが、これは問題といえるような問題ではないので特に考慮の必要は無いと思う）。
　従って、評価順序とは、関数の実引数が評価される時期に関する概念である。以下の3つが考えられる。

　�@eager evaluation (call-by-value)
　�Acall-by-name
　�Blazy evaluation (call-by-need)

　�@は、先取評価とか、先行評価とか訳されるものであり、計算モデルのレベルでは、applicative-order evaluation(reduction)とか、innermost evaluation(reduction)（最内簡約）とか、strict evaluation（正格評価）と呼ばれる。また、data-driven evaluation（データ駆動評価）ともいわれることがある。定義としては、関数適用の一番内側（つまりは、実引数）から評価するというものということであり、値渡しに相当する。つまり、関数呼出し時にまず実引数を評価してしまう（関数本体は、その後に実行される）というものである。従って、仮引数に束縛されるのは、常に実引数の評価結果である。関数定義の中に出現している仮引数には全て、この評価結果が代入されることになる。call-by-valueについては、copy mechanismの項を参照。
　�Aは、名前渡しとか名前呼び等と訳され、�Bは、遅延評価（必要渡し）等と訳される。これらは、normal order evaluation(reduction)（正規順序簡約）とか、leftmost-outermost evaluation(reduction)（最左最外簡約）とかnon-strict evaluation（非正格評価）と呼ばれる。遅延評価に関しては、更にdemand-driven evaluation（要求駆動評価）とも呼ばれたりする。定義としては、関数適用の一番外側の一番左側から評価するというものということである。これは結局簡単に言うと、実引数が関数定義の中で仮引数の出現があった時に評価されるということになる。従って、仮引数に束縛されるのは、実引数それ自体である。関数定義の中に出現している仮引数には全て、（評価されていない）実引数それ自体が代入されることとなる。出現(occurrence)については、その項を参照。
　�@と�A・�Bの評価の違いを以下に例示する。

    int func(int a){
        return a * a;
    }

    ...

    func(5+2);          /* (1) */

    *****************************************

    値呼びの場合

    func(5+2)
    => func(7)
    => 7 * 7
    => 49

    名前呼びの場合

    func(5+2)
    => (5+2) * (5+2)
    => 7 * (5+2)
    => 7 * 7
    => 49

    /* funcは停止しない関数であればなんでも良い */
    int func(void);
    {
        while(1);
        return 1;
    }

    int sum(int a, int b)
    {
        int s;
        s = a + a;
        return s;
    }

    ...

    sum(1,func());               /* (1) */

    int f(int a) {return a*a*a;}

    int g(int x, int y) {return x;}

    ...

    g( f(3), f(4) );

    g(f(3),f(4))
    => g(3*3*3, f(4))
    => g(27, f(4))
    => g(27, 4*4*4)
    => g(27,64)
    => 27

    g(f(3),f(4))
    => f(3)
    => 3*3*3
    => 27

    int f(int a){return a*a*a*}

    int g(int a){return a+a+a;}

    ...

    g(f(4));

    g(f(4))
    => g(4*4*4)
    => g(64)
    => 192

    g(f(4))
    => f(4) + f(4) + f(4)
    => 4*4*4 + 4*4*4 + 4*4*4
    => 64 + 64 + 64
    => 192

    g(f(4))
    => f(4) + f(4) + f(4)
    => 4*4*4 + 4*4*4 + 4*4*4
    => 64 + 4*4*4 + 4*4*4
    => 64 + 64 + 4*4*4
    => 64 + 64 + 64
    => 192

→Parameter mechanism、 Occurrence、 Termination、 Strictness、 Copy mechanism

Event

　主としてオブジェクト指向における概念だが、関数型言語にも出て来るので説明する。
　一般的には、出来事、事件などと訳されるが、プログラミングの世界では、単にイベントと訳されることが多い。ただ、事象とも訳されたりする。
　定義としては、プログラムを実行している環境に一定の状態変化を起こす出来事をこのようにいう。例をあげると、マウスの移動、クリックやキーボードによる入力等である。
　これが果たす役割に付いては、イベント駆動プログラミング(event-driven programming)を参照。

→Event-driven programming、 Call-back function

Event-driven programming

　イベント駆動プログラミングと訳されている。単にイベントドリブンプログラミングとも言う。
　定義としては、イベント(event)の発生を待つループが存在し、イベントが発生すれば、それに関連付けられた処理手続(event handler)が実行されることを特徴とするプログラミングスタイルをこのように言う。event、event handlerとプログラミングスタイルに付いては、event、call-back function、paradigmの各項を参照。具体的には、以下の図を参照。

→Event、 Paradigm、 Call-back function

Expression

　式とか表現とか訳されている。
　プログラミング言語に限っていうならば、評価されるもの、つまり、値を返すものということになると思う。もっと単純に、演算とオペランドの列だといってもよいかもしれない。（純粋な）関数型的に言うと、関数適用のことといってよいだろう。
　これだけでは何の事かわからないかもしれないので、具体例を挙げる。
　例えば、リテラル(数字の3とか"Hello"等の文字列それ自体)、関数呼出(function call、当然演算子も含む)、条件式(C言語の(x > y) ? x : y等、条件コマンドとは違う)などである。
　これは、命令型にも多く存在するものだが、純粋な関数型の場合は、これしかない。他の、例えば、コマンド等は存在しない。
　ただ、念の為に言っておくと、多くの命令型言語では、式とコマンドを余り明確に区別せずに論じている場合がある（例、代入式(assignment expression）、実質的には手続と言える関数呼出等）。

→Command、 Abstraction、 Functional paradigm、 Literal、 Constant applicative form、 Lambda

First-class object

　第１級オブジェクトなどとも訳されるが、単にファーストクラスオブジェクトとも言われる。
　定義としては、数学的オブジェクトとしての権利を全て取得しているオブジェクトのことである。詳細には、以下の能力を持つプログラム言語要素のことである。
　１．オブジェクトに名前がつけられる。
　２．引数として関数・手続に渡すことができる。
　３．結果値として関数から帰って来ることができる。
　４．データ構造に組み込むことができる。
　通常は、単純なデータ又はデータ構造しかこのような身分を持つことはないのだが、関数型言語では、関数にもこのような身分を持たせている。
　このことの持つ意義については、高階関数(higher-order function)を参照。

→Higher-order function、 Anonymous function

Free variable

　自由変数と訳されている。
　束縛変数(bound variable)と同じように、論理学における概念と同じであり、関数型言語ではラムダ計算で使用される概念である。
　あるブロックについて自由な出現(free occurence)を持つ変数のことを言う。出現については、その項を参照。つまり、そのブロックによっては束縛されていない変数のことである。関数プログラミングとしては、関数引数ではないがその関数によって参照される変数のことである。ある意味では、大域変数ともいえるが、深くネストされたスコープのあるプログラムでは、全てがそうであるわけではない。具体例については、束縛変数参照。
　この変数の存在は、プログラムにとって必ずしもよいものではない。というのも、関数や手続等の呼出し毎に様々な意味を持ち得ることを意味するからである。これは、モジュールの参照透明性(referential transparency)を壊す元になる。参照透明性はその項を参照。

→Bound variable、 Referential Transparency、 Binding、 Occurrence、 Constant applicative form、 Closure、 Variable

Functional paradigm

　関数型パラダイムとでも訳すことになるのだろうか。訳としてはそういうもので良いと思う。
　関数型のプログラミングスタイルのことを言う。つまり、式(expression)と純粋関数のみで成り立っているプログラミングのことである。式と関数については、式と抽象(abstraction)の項を参照。変数の値の変更を伴わない（副作用がない）プログラミングと言ってもよいと思う。計算の基本単位が関数適用であるプログラミングともいえるかもしれない。
　これは、命令型言語と比較してみれば明らかになることだと思うので、命令型パラダイム(imperative paradigm)の項を参照。
　ただ、ここでもいくつか説明しておく。プログラムというのは一般に関数であるということができる。つまり、ある入力値を取り結果値を返すものがプログラムであるということができる。このような考えに立つ場合、命令型言語の場合は、この関数がコマンドによって間接的に実現されているといえる。つまり、�@入力値の読込、�A操作、�B結果の出力ということが、記憶領域に保存されている変数の変更によって媒介されている。具体例としては、命令型パラダイムの項を参照してもらえれば分かると思う。コマンド間の関係が変数によって仲立ちされているのである。これに対して、関数型の場合はそのようなことがなく、関数としてのプログラムを直接的に表現している。つまり、プログラムが関数の集合によってのみ成り立っているので、�@関数1の入力、�A関数1の出力＝関数2の入力、�B関数2の出力＝以下続く...というように、関数間の関係が変数によって媒介されるということがない。
　そのような副作用を招く変数の存在がないことから、関数プログラミングの要素たる関数は参照透明性(referencial transparency)という重要な特徴を有する結果になった。これに関しては、その項を参照。また、副作用(side effect)の項も参照。
　そして、以上のことから、標語的に、関数型言語のプログラムは、どのようになされるべきかではなく、何がなされるべきかについて記述するものであるといわれている。その意味から、関数プログラミングは、宣言的プログラミング(decralative programming)のサブクラスともされる。関数型言語のプログラムは、実行可能な仕様なのである（理想的には）。
　一応具体例を示しておく。階乗関数を示す。まずは命令型。

    function factorial(n : integer) : integer;
    var product : integer;
    begin
        product := 1;
        while n > 0 do
        begin
            product := product * n;
            n := n - 1
        end;
        factorial := product
    end;

    function factorial(n : integer) : integer;
    begin
        if n > 0 then factorial := n * factorial(n-1)
        else factorial := 1
    end;

→Abstraction、 Expression、 Imperative paradigm、 Correctness、 Command、 Paradigm、 Referential Transparency、 Lambda

Higher-order function

　高階関数と訳されている。数学で学ぶ内容と同じといってよいと思う。
　つまり、他の関数を引数として、又は結果値として扱うことのできる関数である。これに対して、データしか扱えない関数を一階関数(first-order function)という。
　このような関数があることは関数型言語の大きな特徴とされている。というのも、この可能性によって、飛躍的に表現力が高まるといえるからである。具体的に例を示すというと長くなるので、Cleanの翻訳やSICPを参照。まあ、一般的にいうと、アルゴリズムをよりモジュール化できるということになるということになろうかと思う。具体的な関数の例としては特に、map、filter、fold関数などを見てもらえれば分かると思う。
　また、これを扱えることから、関数合成(functional composition)、部分適用(partial application)やカリー化(currying)の可能性も開けてくる。詳しくは各々の項を参照。
　高階関数では、関数それ自体が第１級のオブジェクト(first-class object)である。これに関しては、その項を参照。
　関数ポインタ等を知っている人にとっては、それとどう違うのかと思う人がいると思うが、基本的には役割が違うということになるだろうか。関数型言語では、関数の集合によってプログラムが成り立っているので、自然に高階関数が表現力の増大に大きな貢献をするが、命令型言語の場合は、関数ポインタは多相性の文脈で語られる程度で、表現力の増大という観点からは関数型ほど大きな貢献をするというわけではない。また、関数ポインタはその名の如く、やはりポインタという形を経由してしか高階関数を実現できないので、他のデータと同じように扱うことで表現力の増大を図ろうとするものとは違うと言える。

→Currying、 First-class object、 Partial application

Imperative paradigm

　命令型パラダイムと言われている。このように略さず、imperative programming paradigmともいうことがある。パラダイムに付いては、その項を参照。
　imperativeというのは、ラテン語のimperareから来ていて、それは「命令する(to command)」という意味である。
　定義としては、簡単に言うと、記憶領域に保存される変数の更新を行うコマンドの並びに基づいて成り立つプログラミングスタイルのことである。コマンド(command)については、その項を参照。また、フォン・ノイマンのアーキテクチャを維持したスタイルと言ってもよい。つまり、言語のステートメントの逐次的実行及び変数の変更が、そのままハードウェアのマシン命令の逐次的読取・実行及び記憶領域の変更を反映しているスタイルである。
　このスタイルに基づく言語が現在のソフトウェア開発の主流を占めている。その理由には、主として2つあると考えられる。
　第一に、マシンのハードウェアレベルの構成と非常に近い対応関係を持っていることがある。つまり、現在のコンピュータは、基本的に機械語命令によるメモリのフェッチ及び更新によってその動作を実現しているので、それに非常に近い対応関係を持つ命令型言語は、シンプルにしかも効率的な言語プロセッサを実現しやすいのである（ただ、現在では、ことによると命令型より高速な実装も登場しているので、シンプルさではやはり負けるが、効率性に関しては一概には言えなくなってはいる）。
　第二に、関数型言語からしてみるとこちらの方が重要だが、時間に沿って状態を変化させる実世界のオブジェクト（銀行口座、飛行機、車、人等）をモデル化することが非常に自然にしかも簡単に行えるということがある。オブジェクト指向は、命令型のこの特徴を最大限生かそうとするものであるといえる。破壊的更新(destructive update)も参照。
　ただ、このような長所ばかりではない。
　第一に、計算の中間結果の保持に変数を使用し、その変数の変化を通じて計算を実現しようとする所にある。つまり、コマンド間の関係が、両者がアクセスできる変数を仲立ちにして形成されるということである。
　具体例を挙げる。SICPの1.2も参照するとよい。
　aからbまでの総和を求めたいとする。

    function sum(a : integer; b : integer) : integer;
    var product, i : integer;
    begin
      product:=0;
      if a>b then sum:=0;
      else begin
      for i:=a to b do
        product := product + i;
        sum := product
      end
    end;

    function sum(a : Integer; b : Integer) : integer;
    begin
      if a>b then sum:=0;
      else sum := a + sum(a+1,b)
    end;

→Command、 Referential Transparency、 Paradigm、 SICP、 Functional paradigm、 Destructive update(assignment)

Infinite data structure

　無限データ構造と訳されていると思う。
　定義は難しいものではない。つまり、要素が無限数あるデータ構造のことをこのようにいう。
　通常、計算機のリソースの有限性から、データ構造の要素は有限であるが、遅延評価(lazy evaluation)により一部分しか評価しないことによってデータ構造の要素を無限数あるかのように表現できる。従って、実際に無限数要素を持つデータ構造をそのままの形で表現できるわけではない。ただ、それによって要素が無限数あるデータも処理できるので、プログラミング言語の表現力増大にとっては重要である。遅延評価に付いては、Evaluation orderを参照。
　具体例は後日追加する。

Lambda

　ラムダと発音する。ギリシア文字のλ（小文字）とΛ（大文字）の英語の綴りである。これ自体は、何ら特に意味のないギリシア文字の１つに過ぎないのだが、ラムダ計算(lambda-calculus)といわれる計算モデルの中では、特別の意味を持つ記号として使用されている（計算モデル(computation model)については、その項を参照）。つまり、ラムダとは、ラムダ計算の中で使用されるラムダ式(lambda expression)を表す記号である。
　ここで、ラムダ式とは何かを説明しておくと、ラムダ式とは、ラムダ項(lambda term)とも言われ、ラムダ計算の中での基本的な計算単位である。具体的には、ラムダ抽象(lambda abstraction)、適用、変数又は定数のいずれかである式のことである。ラムダ抽象とは、無名関数を定義できるラムダ式のことで、通常の（関数）プログラミング言語でいうと、関数定義に相当する。無名関数と関数定義については、anonymous functionの項と、abstractionの項を参照。適用とは、ラムダ抽象の適用のことで、関数適用に相当することになる。BNF的に表現すると、以下のようになる。

    Lambda式   =   ラムダ抽象 | 適用
                 | 変数       | 定数;
    Lambda抽象 = '(' 'λ' 変数 '.' Lambda式 ')';
    適用       = '(' Lambda式 Lambda式 ')';

→Abstraction、 Expression、 Functional paradigm、 Anonymous function

Lifetime

　生存時間とでも訳すべきか。storage durationとも言われるので、記憶期間としてもよいかもしれない。
　定義としては、簡潔に、変数の発生から消滅までの期間をいう。
　生存時間という概念を認める実益は、効率性に帰着する。つまり、変数は必ず生存している間一定の記憶領域を占拠しているので、使われなくなった場合には、それを依然として残しておくことは記憶領域の無駄ということになる。従って、プログラム実行中全体に渡って全ての変数を存続させる必要の無い場合には、適当な時点で破棄されるようにした方がよい。その観点から、変数はブロック内でのみ生存時間を持つという手法が広く行われている。
　例を挙げる。

　　　// ここから

　　　int x = 1;　　　　　　　　　　　// (1)

　　　int main(void)
　　　{
　　　　　　int y = 10;　　　　　　　 // (2)

　　　　　　for(int i=1;i<10;i++) {　 // (3)
　　　　　　...
　　　　　　}

　　　　　　proc();

　　　　　　return 0;
　　　}

　　　void proc(void) {
　　　　　　int z = 20;　　　　　　　 // (4)
　　　　　　...
　　　}

　　　// ここまで

→Block、 Constant applicative form

Literal

　単にリテラルと訳されている。即値や直定数と訳されることもある。
　通常の意味は、｢文字通りの｣とか「ありのままの」とかいう意味だが、プログラミング言語の世界では、特定の型の不動で明白な値を表す、最も単純な式を言う。式(expression)に関しては、その項を参照。つまり、評価後もそのままの形で残っている式である。あるいは、出現する場所とは関係なく常に同一値を出力する式といっても良いかもしれない。これは簡単だと思うが、一応例を挙げておく。

    24       ->  整数リテラル
    24.5     ->  実数リテラル
    'C'      ->  文字リテラル
    "String" ->  文字列リテラル

→Expression、 Constant applicative form

Name

　そのまま名前と訳されている。
　オブジェクト自体ではなくそれの名前のことである。
　主として、プログラムの可読性を高める為にあるといえる。
　別の名前として、識別子(identifier)がある。どちらでも基本的には同じ意味である。

→Namespace、 Declaration、 Variable、 Anonymous function

Namespace

　名前空間と訳されている。あるいは単にネームスペースという場合もある。
　定義としては、全てが一意に定まる名前の集合ということでよいと思う。名前(name)に付いては、その項を参照。あるいは、名前とオブジェクトの対応関係が一意に定まる範囲と言ってもいいかもしれない。
　通用範囲に非常に近い存在であり（というより、ほとんど同じ）、実際、通用範囲規則は、ある名前がどの名前空間に属しているのかを決める。通用範囲(scope)に付いては、その項を参照。また、クラスの名前に果たす役割にも類似する。
　名前空間は、一般に、プログラムの論理的な構造を明確に表現する為に認められた機能である。端的にいえば、（特に大規模プログラム開発において）名前の競合を防ぐ為であり、少し詳しく言うと、あるライブラリ（或はモジュール）が他のライブラリから独立している（モジュラーである）ことを保証し、可読性、再利用性やメンテナンス性を高めることを助ける為に認められた機能である。モジュール(module)に関しては、その項を参照。
　名前空間は、昔の言語であると１つしかないことが多いらしいが、例えば、C++等では、原則として複数存在する。
　名前空間に関しては、Bjarne氏のC++の本が読みやすいと思われる。

→Scope、 Name

Occurrence

　一般的には、生起、発生、出来事等とも訳されるが、プログラミング言語の文脈では主として出現と訳されている。それは、論理学の概念から輸入しているからである。
　まず、論理学における出現とは、項や論理式の中に現れる位置のことをいう。これに関しては、論理学を参照してもらうほかないが、プログラミング言語でも大体同じような意味である。つまり、あるオブジェクトが式の中に現れる位置のことである。
　例を挙げる。

    int func(int x)             // (1)
    {
        ...
        cout << x << endl;      // (2)
        ...
    }

    int x;                      // (1)

    void func(int y)            // (2)
    {
        ...
        cout << x << endl;      // (3)
        cout << y << endl;      // (4)
        ...
    }

→Binding、 Free variable 、 Evaluation order

Paradigm

　訳としては、理論的枠組であるとか、方法論又は単にパラダイムとされている。場合によっては、プログラミングスタイルと呼ばれることもある。
　定義としては、プログラミングスタイルそのままに、プログラムを構成する形のことと言ってよいと思う。
　パラダイムは、２つの意味で使用されることがあるように思われる。第一に、計算モデルに対応した理論的枠組であり、第二に、プログラム構成法というような意味合いで使われる場合である。計算モデル(computation model)については、その項を参照。
　第１の観点からすると、プログラミングには大別して３つのパラダイムがある。即ち、命令型(imperative)（手続型(procedural)）、関数型(functional)、論理型(logical)である。それに対応する具体的な言語には、命令型として、C/C++,Pascal,Java,C#等があり、関数型には、Scheme,Lisp,ML,Haskell,Clean等があり、論理型には、Prologがある。命令型は、フォン・ノイマン型(von Neumann)とも呼ばれる。また、関数型、論理型は総称して、非手続型とか、宣言型(declarative)とか言われる。個々のパラダイムについては、各項を参照。これらパラダイムは、１つの言語内、或は、１つのアーキテクチャ内では、原則として共存できない(整合しない)とされる。
　第２の観点からは、いくつかのプログラミングスタイルが考えられる。即ち、手続プログラミング、関数プログラミング、抽象データ型プログラミング、モジュールプログラミング、オブジェクト指向プログラミング、汎用プログラミング、宣言型プログラミング等である（並行プログラミングもあり得るが、ここではそうしない）。これらのパラダイムは、１つの言語内で共存可能なものが多い。例えば、C++は、このうちの、かなりの部分をカバーしている。また、ML等も、関数型の他、汎用プログラミング、抽象データ型プログラミング等もカバーする。このうち、オブジェクト指向型を特にデータ主導型、手続型、関数型、宣言型等を計算主導型と言ったりもする。これら全てのプログラミングについては、説明しない。少なくともC/C++等を学んでいれば分かるような内容だからである。
　ただ、関数プログラミングに関連して、ここでは、手続型と非手続型（宣言型）の区別を簡単に説明する。
　手続型のプログラムの記述には、プロセッサがどのような操作をするのかについてのステップ単位の記述を必要とするということと、その実行順序も正確に記述しなければならないという特徴がある。一方で、非手続型は、基本的にはプログラムを数学的記述と捉えるものという特徴づけができる。つまり、詳細な実行を記述する必要がない。標語的にいわれているが、手続型のプログラムは、どのように(how)実行されるべきかが記述されているのに対して、非手続型は何が(what)実行されるべきかが記述されている。
　現在命令型言語が主流である。それ理由は至って単純で、現在のコンピュータのハードウェアの構成がチューリングマシン互換だからである。つまり、マシン語とプログラム言語とのかなり近い対応関係が成り立つためである。また、シンプルでもある。そして、効率性の観点からも、入出力等の処理の観点からも優位性をもたらしている。しかし、宣言的なプログラムの方がプログラムの記述と言う観点から望ましい属性を持っていることは事実であり、その弱点を克服する試みが色々なされている。

→Imperative paradigm、 Functional paradigm、 Event-driven programming

Parameter association

　訳は特に知らない。調べてみたが分からなかった。多分、引数結合とでも訳すことになるのだろうか。parameter correspondenceともいう。
　引数機構の１分類で、仮引数と実引数の照合方法に関する概念である。実現方法としては、大別して２つの方法が考えられる。
　第１に、位置的照合(positional association(correnspondence))といわれるもので、関数が呼出されると、コンマ又はスペースで区切られた実引数を順序通りにリストするというものである。これは、実引数の順序、型が仮引数のそれと一致していなければならないということを意味する。従って、省略したい実引数がある場合には、その部分にプレースホルダを使用するか、デフォルト引数を予め指定しておかなければならない。この照合方法の特徴は、未定義の実引数リストを取り扱うことができるということである。例えば、C/C++のコマンドライン引数等がその具体例である。この照合方法はかなり一般的で、C、Pascal、Javaなどほとんどの言語によって採用されている。
　第２に、キーワード照合(keyword(name) association(correspondence))といわれるもので、位置ではなく、仮引数と実引数の名前の一致で照合するというものである。これは、実引数の順序が仮引数のそれと一致していなくともよいということを意味している。また、省略したい実引数がある場合にも問題なく行うことができる。従って、可変数の実引数を取り扱うことができるという特徴がある。また、どの実引数がどの仮引数にバインドされたかが一目で分かるので可読的であるということもできる。これを採用している言語は多くないので、例を挙げる。キーワード結合であると以下のような呼出も認められる。それは、名前の一致でバインドを決定するからである。

　　　int func(char *name, char *address, int age){ ... }

　　　func(age=50, name="anonymous", address="Japan");　// (1)
　　　func(age=50, name="anonymous");　　　　　　　　　 // (2)

→Parameter mechanism

Parameter mechanism

　引数機構のこと。つまり、仮引数と実引数の結合方法に関する仕組みのことである。因みに、引数を渡すことは、parameter passingという。
　いくつかの観点から多種の引数機構を考えることができる。
　第1に、渡すオブジェクトがその評価結果又はそれ自体のコピーである場合である。この観点からは、実現方法として、call-by-value、call-by-result、call-by-result-valueがある。詳しくは、copy mechanismの項を参照。
　第2に、渡すものが渡したいオブジェクトそれ自体である場合である。これについては、constant parameter、variable(or reference)parameter、function(or procedure) parameterが考えられる。詳しくは、definitional mechanismの項を参照。
　第3に、実引数の評価時期という観点である。これに関しては、eager evaluation、lazy evaluationがある。詳しくは、evaluation orderの項参照。
　第4に、引数の照合方法という観点である。この実現方法としては、named parameter associationとpositional parameter associationがある。詳しくは、parameter associationの項を参照。

→Copy mechanism、 Parameter association、 Definitional mechanism、 Evaluation order

Partial application

　主に部分適用と訳されている。partial parametrization（部分パラメータ化）も同様の意味である。
　定義としては、複数の引数を持つ関数において、その引数の最大数よりも少ない数の引数による関数適用のことをいう。例えば、ある関数の引数の数が3だった場合に、それより少ない数、つまり、前から1つ又は2つの引数で関数を呼び出すことをそのように言う。多くの命令型言語においては、これをする能力はない。
　このようなものを認める実益は、関数型言語においては、高階関数の表現力を更に高める為である。つまり、例えば、部分適用を引数とした関数を使用できるので、部分的に引数を指定できない場合よりも、可読性や簡潔性が増す場合が存在するのである。
　具体例はとりあえず省略する。

→Higher-order function、 Application

Partial evaluation

　部分評価と訳されている。実装上の技術で、プログラミング言語の意味とは余り関係ないが、関数型言語には重要なので説明しておく。
　部分評価とは、最適化技術の一種であり、一定の条件を満たす部分式をコンパイル時に予め評価・変換し、実行時の実行ステップ数を減らす技術をこのように言う。
　その一定の条件とは、プログラムの入力（実引数）の変化に依存しないことを言う。
　以下によく挙げられる具体例を示す。

    int power(int x, int y) {
        if(y=0) return 1;
        else return x * power(x, y-1);
    }

    /*  (a)   */
    int func(int a) {
        return power(a, 5);
    }

    **************************************
    /*  (b)   */
    int func(int a) {
        return a * a * a * a * a * 1;
    }

    **************************************
    /*  (c)   */
    inf func(int a) {
        return a * a * a * a * a;
    }

Purity

　純粋性と訳されている。一般的な訳と変わらない。
　プログラミング言語の文脈では、関数が副作用をもたないことを言う。関数については、抽象(abstraction)の項を、副作用(side effect)についてはその項を参照。
　関数型言語の文脈でも大体同様の意味なのだが、「関数が純粋である」と言うより、「純粋な言語」というように使用される。つまり、purely functionalであるとは、（純粋な）関数適用によってのみ計算を行う言語に付けられる形容詞である。それは、副作用もなければ、命令型に特徴的なもの（コマンド等）もないということである。
　例えば、命令型的な変数もない。通常、変数というと代入によって時間毎に変化する値を持つものということになるが、純粋な関数型言語では、数学と同じで、その通用範囲内においての未知の定数という意味になる。つまり、極めて静的でダイナミックに変化させられるということがない。
　また、副作用もないので、参照透明性が確保できる場合が多い。これについては、参照透明性の項を参照。
　以上が純粋性の基本的な内容なのだが、別の意味でも使用される。つまり、副作用があり、破壊的更新が可能でありながら、関数が、実引数が同じであれば常に同じ値になるという属性（参照透明性）を依然として有している場合には、その関数を純粋であると言い、それのみによって成り立つ言語も純粋関数型言語と言う。HaskellやCleanの純粋性は、この意味である。
　従って、定義としては、�@関数が副作用を持たないこと、�A関数に副作用はあるが、参照透明であることの２つの意味があると考えてよい。

→Abstraction、 Referential Transparency

Referential Transparency

　参照透明性とか、参照透過性などと訳されており、関数型言語の主要な特性の１つとされている。
　ありていに言えば、式・関数の結果値は実引数が同じであれば必ず１つに定まることをいう。つまり、実引数が何であるかにのみ依存していて、評価順序がなんであるか等という事には依存していない。
　計算モデルのレベルでは、Church-Rosser propertyやdiamond property、合流性(confluency)等がこれに相当する。
　命令型言語では、関数の結果値は実引数が同じであっても１つに定まるわけではない。これは主として、命令型が副作用(side effect)を持つからである（勿論全ての原因を副作用に求めることができるわけではない）。
　例えば、以下のコードを考える。

    #include <stdio.h>

    int flag = 0;

    int func(int n)
    {
        if(!flag) flag++;
        else flag=0;

        if(flag) n--;
        else n++;
        return n;
    }

    int main(void)
    {
        printf("First  : %d\n", func(0));   /* 注1 */
        printf("Second : %d\n", func(0));   /* 注2 */
        return 0;
    }

→Correctness、 Free variable 、 Abstraction、 Purity、 Definitional mechanism、 Strictness analysis、 Imperative paradigm、 Functional paradigm、 Destructive update(assignment)、 Side effect、 deforestation

Scope

　有効範囲とか通用範囲などと訳されている。単にスコープともいう。論理学では、作用域と訳される。
　オブジェクトの名前が可視的である或は意味をなしているプログラムコードの部分のことである。つまり、その有効な範囲内においてのみ、オブジェクトの名前は、そのバインドされている実体にアクセスできる。ある名前によってそれにバインドされている実体を参照できる範囲といってもよい。
　これだけでは何とも意味がわからないと思うので、例を挙げる。

    -------------------------(1)
    int x;                       // A

    -------------------------(2)
    int main(...)
    {
        int x;                   // B

    -------------------(3)
        for(...)
        {
            int x;               // C
        }
    -------------------(/3)

    return 0;
    }
    -------------------------(/2)

    -------------------------(4)
    function(...)
    {
        int x;　　　　　　　　　　// D
    }
    -------------------------(/4)
    -------------------------(/1)

→Bound variable、 Block、 Static binding、 Dynamic binding、 Namespace

SICP

　「計算機プログラムの構造と解釈(Structure and Interpretation of Computer Programs)」（by Abelson & Sussman）という本の略称。ビアソンから翻訳が出ている。
　表紙に魔術師が描かれていることから、ウィザード本などとも言われている。
　Schemeを使って、計算機科学の基礎の勉強についてMIT等で使用されている本である。
　ただ、基礎とはいうものの、関数プログラミングにとって基礎ともいい得るような本である。非常に優れているだけでなく、一読の価値があるものである。
　但し和訳はいささか読みにくいのでそこは注意。まあ、人のことはいえないかもしれないが。原書は、Web上にもアップされている。
　ここを参照。

→Assignment、 B&W、 Imperative paradigm

Side effect

　副作用と訳されている。一般の場合と同じである。
　定義としては、ある演算が実行される場合の結果値以外の全ての効果ということになるが、もうちょっと画定すると、実行環境(environment)の状態(state)を変更/修正する言語の構成要素又は効果それ自体ということになるかと思う。図式的に見てもらった方が分かると思うので、抽象(abstraction)を参照。
　具体例としては、グローバル変数の例を参照透明性(referencial transparency)の所で載せ、別名の問題をdefinitional mechanismのところで載せたので（各項を参照）、ここでは、別の例を2つ取り上げる。
　まず、以下のような例である。

    int a=1;
    int b=-1;
    ...

    void swap(int& a, int& b)
    {
        int tmp;
        tmp=a;
        a=b;
        b=tmp;
    }

    ...
    swap(a,b);                                              // (a)
    cout << "a : " << a << ' ' << "b : " << b << endl;      // (1)

    swap(a,b);                                              // (b)
    cout << "a : " << a << ' ' << "b : " << b << endl;      // (2)

    /* サンプルA */
    int main(argc int,char *argv[])
    {
        FILE *fin = fopen(argv[1],"r");

        if(fgetc(fin)=='M') puts("男だよ");             /* (1) */
        else if(fgetc(fin)=='F') puts("女だよ");        /* (2) */
        else puts("？");

        fclose(fin);
        return 0;
    }

    /* サンプルB */
    int main(argc int,char *argv[])
    {
        FILE *fin = fopen(argv[1],"r");
        int c;

        if((c=fgetc(fin))=='M') puts("male");   /* (1) */
        else if(c=='F') puts("female");          /* (2) */
        else puts("?");

        fclose(fin);
        return 0;
    }

→Abstraction、 Environment、 Definitional mechanism、 Destructive update(assignment)、 Referential Transparency、 Correctness

Static binding

　静的束縛とか訳されている。或は静的バインディングなどともいわれる。同一の意味を持つ言葉に、static scoping(scope)がある。lexical scoping(binding)等ともいわれる。
　定義としては、ある名前がどのオブジェクトにバインドされているのかがプログラムテキストから直接分かるような束縛をいう。テキストから直接分かるというのは、人間から見て分かるというのではなく、字句解析によって直接分かるという意味である。
　静的束縛は、このために、束縛を実行時ではなくコンパイル時に行うことができる。
　具体例については、動的束縛(dynamic binding)の項を参照。

→Binding、 Scope

Strictness

　正格性とか狭義性とか訳されている。厳密性とも訳されたりしている。或は単にストリクト性などとも言われる。これの反対は、非正格性(non-strictness)である。
　定義としては記号的表現で定式化できるのだが、ここではそれはしない。そして、これは、関数又はその引数の属性であり、関数引数の評価によっては当該プログラムの停止性が変更されないという性質を言う。より簡単に言うと、関数の実引数がその関数の評価前に評価されるという性質をいう。別の言い方をすると、関数評価の際には引数の値が常に必要とされるという性質である。
　計算モデルのレベルでは、applicative orderやinnermost reduction等に相当する。
　また、評価順序(evaluation order)の観点からは、先行評価(eager evaluation)に相当する。
　正格性に関してあげるべき特徴は主として3つある。つまり、非正格性に比べて効率的な実装を達成できること、ある関数がある引数に関して正格であると関数の停止性(termination)を充足しない場合が多いということ、及び、関数の結果に関係ない不必要な引数を評価する場合もあるということである。これらの関する詳しい説明は、evaluation orderの項を参照。
　なお、引数を完全に先行評価する場合を、ハイパー正格(hyperstrict)などと言う。完全にというのは、渡される引数が合成データ構造等である場合に、その個々の要素も関数本体評価前に評価するという意味である。関数適用前にその属性を持つ引数は常に正規形であるという意味であると言ってもいいかもしれない。

→Termination、 Strictness analysis、 Evaluation order

Strictness analysis

　正格性検査、ストリクト性解析などと訳されている。個人的には、正格性分析の方が正確だとは思うが、それはどうでもよい。
　定義としては至って簡単で、関数の引数の正格性を検査することをいう。正格性(strictness)に関しては、その項を参照。もうちょっと詳しく言うと、関数を評価する際に、その引数の値が必要かどうかを調べることをいう。これは、実行時にではなく、コンパイル時に行われる。従って、正格性情報を取得する為のコンパイル時検査ということができるだろう。
　正格性分析は、抽象解釈(abstract interpretation)と呼ばれる技術を使用して、ラムダ計算の中で説明されることが多い。抽象解釈は、その項を参照。ただ、Cleanの場合は、計算モデルがラムダ計算ではなくて、グラフ書換えシステムなので、それに伴って抽象簡約(abstract reduction)と呼ばれている。
　このような分析が有用である理由は、効率性の為である。つまり、純粋関数型言語では、参照透明性(referencial transparency)が確保されている為、様々な評価順序(evaluation order)の選択肢を取り得るのだが、停止性(termination)の観点から、遅延評価(lazy evaluation)を基本的に採用している。しかし、遅延評価は、ほとんどの場合において先取評価(eager evaluation)よりも効率が悪い。そこで、正格であっても停止性を満足する関数引数に付いては、先取評価に変換した方が効率的であるということで、正格でもよい引数を検査することにしているのである。以上に出てきた各概念についてはその項を参照。

→Strictness、 Referential Transparency、 Termination、 Abstract interpretation

Substitution

　数学上の代入に相当するものである。代入とも訳されているのが、計算機科学の世界では、代入にはassignmentをあてているので、置換とも訳される。
　定義としては、数学の代入を知っている人ならばすぐに分かると思うが、ある式内においてある変数をある値で置き換えることである。
　これは、assignment（これも代入と訳されている）とは異なる。assignmentは、正確には割当とでも言うべきもので、同一プログラム又は関数内で記憶状態たるオブジェクトの値を他のものに変更することを言う。assignmentについては、その項を参照。substitutionには、記憶状態の破壊的変更という要素はない。変数の名前とある値を束縛するに過ぎない。

→Assignment、 Variable

Termination

　停止性とか訳されている。
　別に難しい概念ではない。プログラムがその意図通りに動く為には、そのプログラムが必ず（正常に）終了しなければならないが、その必ず停止する性質を停止性という。これについては特に例を挙げない。すぐに分かることだと思う。
　関数型言語との関連では、遅延評価(lazy evaluation)と全的正当性(total correctness)との関係が重要である。詳しくは、評価順序(evaluation order)と正当性(correctness)の項を参照。

→Correctness、 Strictness、 Strictness analysis、 Evaluation order

Type checking

　型検査と訳されている。あるいは型チェックなどとも言う。
　定義としては、ある演算（関数、手続等）が適切な型を持つデータ構造に適用されているかを検査することをいう。
　型検査の意義については、説明しない。それは型の意義の中に含まれているからである。
　型検査は、いくつかの観点からいくつかの区別がなされている。
　まず、検査時期に関して、コンパイル時に行うことを静的型検査(static type checking)といい、実行時に行うことを動的型検査(dynamic type checking)という。これは、型付け(typing)に関連してくるので、この区別に関してはそちらの項を参照。
　次に、型エラーに関して、合格すれば型エラーがないという検査を強い型検査(strong type checking)といい、合格しても型エラーから自由であるとは限らない検査を弱い型検査(weak type checking)という。これも型付けに関連してくるので、そちらの項を参照。
　第三に、検査方法に関連して、２つの区別がある。まず、同一名の型を持つ場合に同じ型だとされる検査をName Equivalenceといい、同一のデータ構造を持つ場合に同じ型だとされる検査をStructural Equivalenceという。これら2つを合わせてType Equivalenceという。
　例を挙げる。

    typedef int YetAnother

    int a;
    YetAnother b;

    ...

    a=b;                        /* (1) */

→Typing、 Type inference、 Dynamic binding

Type inference

　型推論と訳されている。
　これは命令型では比較的馴染みの無い概念であると思う。それはMLを中心として発展してきたという歴史的な理由が大きい。ただ、別に関数型に限られるわけではなく、命令型の言語に限っても知っておくと有意義であると思う。
　定義としては、明示的な型宣言が無い場合にオブジェクトの型を意味の通るように、プロセッサが、コード上の手かがりを頼りに推論して決定することを言う。例えば、以下に例を挙げる。

    ? fac(? n)
    {
        if(n==0) return 1;
        else return n * fac(n-1);
    }

    ? identity(? n)
    {
        return n;
    }

→Type checking

Typing

　型付きなどと訳されている。typingという形ではなく、typedというようにも使用される。
　定義としては、型という概念をもっている言語の属性である。特に難しいことではないと思う。もう少し厳密に言うと、プログラム中に現れる式が取ることのできる値に制限（つまり、型）のある言語の性質をいう。
　そして、型のある言語を一般に、型付き言語(typed language)といい、型のない言語を型無し言語(untyped language)という。
　その型付き言語は一般に、2つの基準から4つの種類に分けることができる。
　まず、強い型付け(strong typing)と弱い型付け(weak typing)である。つまり、強く型付けされているとは、言語プロセッサの型検査に合格したプログラムは、型エラーを持たないことが保証されていることを言う。逆に、弱く型付けされているとは、それが保証されているわけではないことをいう。型検査(type checking)については、その項を参照。
　次に、静的な型付け(static typing)と動的な型付け(dynamic typing)である。静的な型付けとは、あらゆる式等がプログラマの指定した型を持ち、その型のまま固定され、他に変更されることのない性質をいう。従って、型検査をコンパイル時に行うことができる（静的型検査）。静的に型付けされた言語は、全ての式をコンパイル時に型検査できるので、全て強く型付けされた言語であるともいわれている。
　これに対して、動的な型付けとは、全ての式等がプログラマの指定した型を持つわけではなく、異なった場所では異なった型を持ち得る性質をいう。値だけが固定した型を持つといってもよい。従って、型検査は実行時に行われることになる（動的型検査）。
　具体例を挙げる。

    int even(int n)
    {
        return (n % 2) == 0;
    }

    even(n)
    {
        return (n % 2) == 0;
    }

→Type checking、 Dynamic binding

Variable

　変数と訳されることがほとんどである。プログラミング言語においてはまさに中核概念である。
　定義としては、命令型プログラミングと宣言プログラミングの世界では異なる。つまり、命令型言語における変数とは、値を持っているオブジェクトのことである。値(と名前(name))を持っている箱（正確にはメモリ領域）と言っていいかもしれない。従って、その変数には値を変える操作、つまり代入(assignment)が可能である。一方で、宣言プログラミング、なかんずく関数型言語における変数とは、数学上の変数と同じく、未知数である。つまり、未だに分かっていない未知の値のこととなる。この場合、代入はsubstitutionであり、１つの通用範囲内では、１つの変数に１回しかない。従って、値を変える操作というものは観念し得ない。各代入に付いては、各項を参照。
　変数は、色々な観点から数種に分類できるが、それはとりあえず省略する。その中のものとしては、自由変数(free variable)と束縛変数(bound variable)もあり、既述なので、各項を参照。
また、宣言方法、束縛方法等も色々に渡り、この用語集全体に渡るので、全体を参照した方が良いかもしれない。

→Assignment、 Bound variable、 Free variable 、 Name、 Substitution