固定小数点コンビネータ

コンピュータサイエンスの組合せ論理において、固定小数点コンビネータ（または固定点コンビネータ）^{[1] : p.26} は、高階関数（つまり、関数を引数として受け取る関数）であり、引数関数の固定小数点（それ自身にマッピングされた値）が存在する場合にそれを返します。

正式には、が固定小数点コンビネータであり、関数が1つ以上の固定小数点を持つ場合、はこれらの固定小数点の1つ、つまり ${\displaystyle {\textrm {修正}}}$${\displaystyle f}$${\displaystyle {\textrm {fix}}\ f}$

${\displaystyle f\ ({\textrm {fix}}\ f)={\textrm {fix}}\ f\ .}$

固定小数点コンビネータは、ラムダ計算と関数型プログラミング言語で定義でき、再帰的な定義を可能にする手段を提供します。

古典的な型なしラムダ計算では、すべての関数は不動点を持つ。の特定の実装はHaskell Curryの逆説的コンビネータYであり、 ^{[2]で与えられる: 131  [注1] [注2]}${\displaystyle {\textrm {修正}}}$

${\displaystyle Y=\lambda f.\ (\lambda xf\ (x\ x))\ (\lambda xf\ (x\ x))}$

(ここでは、ラムダ計算の標準的な表記法と規則を使用します。 Y は、1 つの引数fを受け取り、最初のピリオドに続く式全体を返す関数です。式 は、関数として考えられる1 つの引数xを受け取り、式 を返す関数を 表します。ここで、 はx が自身に適用されたことを表します。式の並置は関数の適用を表し、左結合で、ピリオドよりも優先順位が高くなります。) ${\displaystyle \lambda xf\ (x\ x)}$${\displaystyle f\ (x\ x)}$${\displaystyle (x\ x)}$

次の計算は、 が実際に関数 の不動点であることを確認します。 ${\displaystyle Yg}$${\displaystyle g}$

ラムダ項は、一般に、項 にβ 簡約されない場合があります。ただし、示されているように、両方の項は同じ項 β 簡約されます。 ${\displaystyle g\ (Y\ g)}$${\displaystyle Y\ g}$

1 つの変数を持つ関数に適用した場合、Y コンビネータは通常終了しません。2 つ以上の変数を持つ関数に Y コンビネータを適用すると、より興味深い結果が得られます。追加の変数は、カウンターまたはインデックスとして使用できます。結果として得られる関数は、命令型言語のwhileまたはforループのように動作します。

このように使用すると、Y コンビネータは単純な再帰を実装します。ラムダ計算では、多くのプログラミング言語のように関数をその定義内の項として出現させることはできませんが、関数を再帰的に適用する高階関数に引数として渡すことはできます。

Y コンビネータは、カリーのパラドックスの実装にも使用できます。カリーのパラドックスの核心は、型なしラムダ計算が演繹システムとしては不健全であるという点であり、Y コンビネータは匿名式がゼロ、あるいは複数の値を表せるようにすることでこれを実証します。これは数学的論理では矛盾しています。

以下に、 R 言語での Y の実装例を示します。

Y <- \ ( f ) { g <- \ ( x ) f ( x ( x )) g ( g ) }   
     
  

これを使用して、次のように階乗を実装できます。

fact <- \ ( f ) \ ( n ) if ( n == 0 ) 1 else n * f ( n - 1 ) Y ( fact )( 5 ) # 結果は 5! = 120   
           
  
 

Y は関数名がない場合にのみ必要です。関数名が不要になるようにすべての定義を 1 行に置き換えると、次のようになります。

( \ ( f ) ( \ ( x ) f ( x ( x )))( \ ( x ) f ( x ( x )))) ( \ ( f ) \ ( n ) if ( n == 0 ) 1 else n * f ( n - 1 )) ( 5 )                

これは、R が遅延評価を使用するため機能します。

Python、C++などの厳密な評価を使用する言語では、多くの場合 Y を表現できますが、スタック オーバーフローによって終了するまで無限にループするため、実装は実際には役に立ちません。

Y コンビネータは、ラムダ計算における固定小数点コンビネータの実装です。固定小数点コンビネータは、他の関数型言語や命令型言語でも簡単に定義できます。ラムダ計算での実装は、ラムダ計算の制限により困難です。固定小数点コンビネータは、さまざまな分野で使用できます。

• 一般数学
• 型なしラムダ計算
• 型付きラムダ計算
• 関数型プログラミング
• 命令型プログラミング

固定小数点コンビネータはさまざまな関数に適用できますが、通常は追加のパラメータがない限り終了しません。固定する関数がそのパラメータを参照する場合、関数への別の呼び出しが呼び出されるため、計算は開始されません。代わりに、追加のパラメータを使用して計算の開始をトリガーします。

固定小数点の型は、固定される関数の戻り値の型です。これは、実数、関数、またはその他の型である可能性があります。

型なしラムダ計算では、固定小数点コンビネータを適用する関数は、チャーチ エンコーディングなどのエンコーディングを使用して表現できます。この場合、特定のラムダ項 (関数を定義する) は値と見なされます。エンコーディング上で固定小数点コンビネータを「実行」(ベータ削減) すると、結果のラムダ項が生成され、これを固定小数点値として解釈できます。

あるいは、関数は、純粋にラムダ計算で定義されたラムダ項と見なすこともできます。

これらの異なるアプローチは、数学者とプログラマーが固定小数点コンビネータをどのように捉えるかに影響します。数学者は、関数に適用された Y コンビネータを固定小数点方程式を満たす式、つまり解として捉える場合があります。

対照的に、固定小数点コンビネータを一般的なプログラミング タスクにのみ適用したい人は、それを再帰を実装する手段としてのみ見るかもしれません。

多くの関数には固定小数点がありません。たとえば、 です。チャーチ エンコーディングを使用すると、自然数をラムダ計算で表現でき、この関数f をラムダ計算で定義できます。ただし、その定義域には自然数を表すラムダ式だけでなく、すべてのラムダ式が含まれるようになります。 fに適用された Y コンビネータはfの固定小数点を生成しますが、この固定小数点は自然数を表しません。実際のプログラミング言語で Y f を計算しようとすると、無限ループが発生します。${\displaystyle f:\mathbb {N} \to \mathbb {N} }$${\displaystyle f(n)=n+1}$

不動点コンビネータは数学で定義され、その後他の言語で実装されることがあります。一般的な数学では、関数はその拡張的性質に基づいて定義されます。^{[3]つまり、2 つの関数は同じマッピングを実行する場合、それらは等しいということです。ラムダ計算とプログラミング言語では、関数の同一性は}内包的性質とみなされます。関数の同一性はその実装に基づいています。

ラムダ計算関数 (または項) は、数学関数の実装です。ラムダ計算には、固定小数点コンビネータの数学的定義を満たすコンビネータ (実装) が多数あります。

組み合わせ論理は高階関数理論です。コンビネータは閉じたラムダ式であり、自由変数を持たないことを意味します。コンビネータを組み合わせることで、値を変数として指定することなく、式内の正しい場所に導くことができます。

固定小数点コンビネータは関数の再帰定義を実装するために使用できます。ただし、実際のプログラミングではほとんど使用されません。^[4] 単純型ラムダ計算などの強く正規化された 型システムでは非終了が許可されないため、固定小数点コンビネータには型を割り当てることができなかったり、複雑な型システムの機能が必要になったりすることがよくあります。さらに、固定小数点コンビネータは、関数の削減が多く必要であり、相互再帰定義のグループごとにタプルを構築して分解する必要があるため、再帰を実装するための他の戦略と比較して非効率的であることがよくあります。^{[1] : 232 ページ}

階乗関数は、固定小数点コンビネータを使用して再帰関数を定義する方法の良い例です。数学における階乗関数の標準的な再帰定義は次のように記述できます。

${\displaystyle \operatorname {fact} \ n={\begin{cases}1&{\text{if}}~n=0\\n\times \operatorname {fact} (n-1)&{\text{otherwise.}}\end{cases}}}$

ここで、n は負でない整数です。整数がチャーチ エンコーディングを使用して表現されるラムダ計算でこれを実装する場合、ラムダ計算では関数の定義で関数の名前 (「fact」) を使用できないという問題に遭遇します。これは、次のように固定小数点コンビネータを使用して回避できます。 ${\displaystyle {\textsf {fix}}}$

2つの引数fとn を持つ関数F を定義します。

${\displaystyle F\ f\ n=(\operatorname {IsZero} \ n)\ 1\ (\operatorname {multiply} \ n\ (f\ (\operatorname {pred} \ n)))}$

(ここでは、2 つの引数を取り、 n =0 の場合は最初の引数を返し、それ以外の場合は 2 番目の引数を返す関数を示します。評価結果はn -1になります。) ${\displaystyle (\operatorname {IsZero} \ n)}$${\displaystyle \operatorname {pred} \ n}$

ここで を定義します。すると はFの不動点となり、次の式が得られます。 ${\displaystyle \operatorname {fact} ={\textsf {fix}}\ F}$${\displaystyle \operatorname {事実} }$

${\displaystyle {\begin{aligned}\operatorname {fact} n&=F\ \operatorname {fact} \ n\\&=(\operatorname {IsZero} \ n)\ 1\ (\operatorname {multiply} \ n\ (\operatorname {fact} \ (\operatorname {pred} \ n)))\ \end{aligned}}}$

ご希望に応じて。

Yコンビネータはハスケル・B・カリーによって発見され、次のように定義される。

${\displaystyle Y=\lambda f.(\lambda xf\ (x\ x))\ (\lambda xf\ (x\ x))}$

型なしラムダ計算では、固定小数点コンビネータは特に珍しいものではありません。実際、それらは無限に存在します。^[5] 2005年にメイヤー・ゴールドバーグは、型なしラムダ計算の固定小数点コンビネータの集合が再帰的に列挙可能であることを示しました。^[6]

YコンビネータはSKI計算では次のように 表現できる。

${\displaystyle Y=S(K(SII))(S(S(KS)K)(K(SII)))}$

追加のコンビネータ（B、C、K、Wシステム）を使用すると、はるかに短い定義が可能になります。自己適用コンビネータを使用すると、およびなので、上記は次のようになります。 ${\displaystyle U=SII}$${\displaystyle S(Kx)yz=x(yz)=Bxyz}$${\displaystyle Sx(Ky)z=xzy=Cxyz}$

${\displaystyle Y=S(KU)(SB(KU))=BU(CBU)}$

SK計算における最も単純な不動点コンビネータはジョン・トロンプによって発見され、

${\displaystyle Y'=SSK(S(K(SS(S(SSK))))K)}$

ただし、これは通常の形式ではなく、より長い形式であることに注意してください。このコンビネータは、ラムダ式に対応します。

${\displaystyle Y'=(\lambda xy.xyx)(\lambda yx.y(xyx))}$

次の固定小数点コンビネータは Y コンビネータよりも単純で、Y コンビネータに β 還元されます。これは Y コンビネータ自体として引用されることもあります。

${\displaystyle X=\lambda f.(\lambda x.xx)(\lambda xf(xx))}$

もう一つの一般的な固定小数点コンビネータは、チューリング固定小数点コンビネータ（発見者であるアラン・チューリングにちなんで名付けられた）である。^{[7] [2] : 132}

${\displaystyle \Theta =(\lambda xy.y(xxy))\ (\lambda xy.y(xxy))}$

に対する利点は、が にベータ還元されることです^{[注 3]} 。 一方、 とは共通項にのみベータ還元されます。 ${\displaystyle Y}$${\displaystyle \Theta \ f}$${\displaystyle f\ (\Theta f)}$${\displaystyle Y\ f}$${\displaystyle f\ (Yf)}$

${\displaystyle \Theta}$単純な値渡し形式もあります:

${\displaystyle \Theta _{v}=(\lambda xy.y(\lambda z.xxyz))\ (\lambda xy.y(\lambda z.xxyz))}$

相互再帰の類似物は多変数固定点コンビネータ^{[8] [9] [10]}であり、Y*と表記されることもある。

厳密なプログラミング言語では、 Yコンビネータはスタックオーバーフローが発生するまで拡張するか、末尾呼び出し最適化の場合は停止しません。^{[11] Zコンビネータは}厳密な言語（応用評価順序が適用される、熱心な言語とも呼ばれる）で機能します。Zコンビネータでは、次の引数が明示的に定義されており、定義の右側のの展開を防ぎます。 ^[12]${\displaystyle Zg}$

${\displaystyle Zgv=g(Zg)v\ .}$

ラムダ計算では、これはYコンビネータのイータ展開です。

${\displaystyle Z=\lambda f.(\lambda x.f(\lambda v.xxv))\ (\lambda x.f(\lambda v.xxv))\ .}$

Fが型なしラムダ計算における固定小数点コンビネータである場合、

${\displaystyle F=\lambda x.Fx=\lambda x.x(Fx)=\lambda x.x(x(Fx))=\cdots }$

固定小数点コンビネータと同じベーム木を持つ項、つまり同じ無限拡張を持つ項は、非標準固定小数点コンビネータと呼ばれます。任意の固定小数点コンビネータは非標準でもありますが、非標準固定小数点コンビネータの中には、「標準」の固定小数点コンビネータを定義する固定小数点方程式を満たさないものもあるため、すべての非標準固定小数点コンビネータが固定小数点コンビネータであるわけではありません。これらのコンビネータは、厳密に非標準固定小数点コンビネータと呼ばれます。次のコンビネータがその例です。 ${\displaystyle \lambda x.x(x(x\cdots ))}$

${\displaystyle N=BM(B(BM)B)}$

どこ

${\displaystyle B=\lambda xyz.x(yz)}$

${\displaystyle M=\lambda x.xx\ .}$

非標準固定小数点コンビネータの集合は再帰的に列挙できない。^[6]

Y コンビネータは、ラムダ計算における固定小数点コンビネータの特定の実装です。その構造は、ラムダ計算の制限によって決まります。他の言語で固定小数点コンビネータを実装する際にこの構造を使用する必要はありませんし、役に立ちません。

いくつかのプログラミング パラダイムで実装された固定小数点コンビネータの簡単な例を以下に示します。

Haskellのような遅延評価をサポートする言語では、慣例的に と呼ばれる固定小数点コンビネータの定義式を使用して固定小数点コンビネータを定義することができます。Haskell には遅延データ型があるため、このコンビネータはデータコンストラクタの固定小数点を定義するためにも使用できます (再帰関数を実装するためだけではありません)。ここでは定義を示し、その後に使用例をいくつか示します。Hackage での元のサンプルは次のとおりです: ^[13]fix

fix , fix' :: ( a -> a ) -> a fix f = let x = f x in x -- ラムダは削除されました。共有します。-- 元の定義は Data.Function にあります。-- 代替: fix' f = f ( fix' f ) -- ラムダが解除されました。非共有です。       
                  
                                 

                   

fix ( \ x -> 9 ) -- これは 9 と評価されます                       

fix ( \ x -> 3 : x ) -- 遅延無限リスト [3,3,3,...] に評価されます                     

fact = fix fac -- 階乗関数を評価します。ここで、fac f 0 = 1 fac f x = x * f ( x - 1 )                      
       
               

事実5 -- 評価結果は120                            

厳密な関数型言語では、OCamlで以下に示すように、 fへの引数は事前に展開され、無限の呼び出しシーケンスが生成されます。

${\displaystyle f\ (f...(f\ ({\mathsf {fix}}\ f))...)\ x}$。

この問題は、追加のパラメータを使用して fix を定義することで解決できる可能性があります。

let  rec  fix  f  x  =  f  ( fix  f )  x  (* 余分な x に注意してください。ここでは、fix f = \x-> f (fix f) x *)

let  factabs  fact  =  function    (* factabs にはラムダ抽象化のレベルが追加されています *) 
   0  ->  1 
 |  x  ->  x  *  fact  ( x - 1 )

let  _  =  ( fix  factabs )  5        (* は "120" と評価されます *)

Lispのようなマルチパラダイム関数型言語（命令型の機能を備えた言語）では、ピーター・ランディンは変数割り当てを使用して固定小数点コンビネータを作成することを提案しました。^[14]以下の例はSchemeを使用したものです。

( define Y! ( lambda ( f ) (( lambda ( i ) ( set! i ( f ( lambda ( x ) ( i x )))) ;; (set! i expr) は i に expr iの値を割り当てます) ;; 現在のレキシカルスコープ#fで置き換えます))) 
   
                            
              
                                     
     

Y!ラムダ計算と代入文の公理を用いると、 call-by-value Yコンビネータと同じ固定小数点法則を満たすことが示される。 ^{[15] [16]}

${\displaystyle (Y_{!}\ \lambda x.e)e'=(\lambda x.e)\ (Y_{!}\ \lambda x.e)e'}$

letより慣用的な現代の Lisp の使用法では、これは通常、レキシカル スコープ ラベル (式)を介して処理されます。これは、レキシカル スコープが 1970 年代まで Lisp に導入されていなかったためです。

( Y*を定義します( lambda ( f ) (( lambda ( i ) ( let (( i ( f ( lambda ( x ) ( i x ))))) ;; (let ((i expr)) i) は i を expr iとしてローカルに定義します)) ;; 非再帰的: したがって expr の i は expr #fではありません))) 
   
     
              
	                                  
     

または内部ラベルなしの場合:

( Yを定義(ラムダ( f ) ((ラムダ( i ) ( i i )) (ラムダ( i ) ( f (ラムダ( x ) ( ( i i ) xを適用))))))) 
   
       
      
         
	           

この例は、固定小数点コンビネータの少し解釈的な実装です。fixerと呼ばれるクラスを使用して、 fix関数を含めます。修正される関数は、fixer から継承するクラスに含まれています。fix関数は、修正される関数に仮想関数としてアクセスします。厳密な関数定義と同様に、fix には追加のパラメーターxが明示的に指定されているため、遅延評価は必要ありません。

テンプレート< typename R 、typename D >クラスfixer { public : R fix ( D x ) { return f ( x ); } private : virtual R f ( D ) = 0 ; };    
 


      
    
         
    

        


クラスfact : public fixer < long , long > { virtual long f ( long x ) { if ( x == 0 ) { return 1 ; } return x * fix ( x -1 ); } };     

       
    
           
        
             
        
           
    


長い結果= fact (). fix ( 5 );   

別の例として、 SKI コンビネータ計算(組み合わせ論理からの鳥の名前を指定) を使用して Z コンビネータを構築し、トランポリンによって Tail callのような動作を実現する方法を示します。

var K = a => b => a ; // チョウゲンボウvar S = a => b => c => a ( c )( b ( c )); // ムクドリvar I = S ( K )( K ); // 識別var B = S ( K ( S ))( K ); // ルリツグミvar C = S ( B ( B )( S ))( K ( K )); // カージナルvar W = C ( S )( I ); // ウグイスvar T = C ( I ); // ツグミvar V = B ( C )( T ); // タイリクモズvar I_ = C ( C ( I )); // 識別鳥除去; C(B(B)(I))(I) と同じvar C_ = B ( C ); // カージナル除去var R_ = C_ ( C_ ); // コマドリ除去var V_ = B ( R_ )( C_ ); // タイリクガメを一度除去var I__ = R_ ( V ); // アイデンティティバードを二度除去var Z = B ( W ( I_ ))( V_ ( B )( W ( I__ )));        
          
    
    
    
    
    
    
    
    
    
    
    
   

var Z2 = S ( K ( S ( S ( K ( S ( S ( K )( K ))( S ( K )( K ))))( S ( K ( S ( K ( S ))( K )) )( S ( K ( S ( S ( K )( K ))))( K ))))( K ( S ( S ( K ))))))( S ( S ( K ( S ( S ( K ( S ( K ( S ))( K )))( S ))( K ( K ))))( S ( K ( S ( S ( K ( S ( K ( S ))( K )))( S ))( K ( K ))))( S ( K ( S ))( K ))))( K ( S ( S ( K ( S ( S ( K )( K ))( S ( K )( K )))( S ( K ( S ( K ( S ))( K )))( S ( K ( S ( S ( K )( K ))))( K ) ) ))( K ( S ( K ( S ( S ( K ( S ( S ( K ( S ( K ( S ))( K )))( S ))( K ( K ))))( S ( K ( S ( S (   K ( S ( K ( S ))( K )))( S ))( K ( K ))))( S ( K ( S ( S ( K )( K )))) )( K ) ))))); // 完全に展開された代替形式。
	

var trampoline = fn => { let ctx = fn ; while ( ctx instanceof Function ) ctx = ctx (); return ctx ; };     
	   
	   
		  
	 


var count_fn = self => n => ( console . log ( n ), n === 0 ) ? n : () => self ( n - 1 ); // 代わりにサンク "() => self(n - 1)" を返します。      
	   
		 
		      

トランポリン( Z ( count_fn )( 10 ));
トランポリン( Z2 ( count_fn )( 10 ));

システムF （多態的ラムダ計算）では、多態的固定小数点コンビネータは^{[17]型を持つ。}

∀a.(a → a) → a

ここで、 aは型変数です。つまり、fix はa → a をマップする関数を受け取り、それを使用して型 a の値を返します。

再帰データ型で拡張された単純型ラムダ計算では、固定小数点演算子を記述できますが、「有用な」固定小数点演算子 (アプリケーションが常に返す演算子) の型は制限される場合があります。

単純型ラムダ計算では、固定小数点コンビネータYに型を割り当てることはできない^[18]。なぜなら、ある時点で自己適用サブ項をアプリケーションルールによって処理することになるからである。 ${\displaystyle x~x}$

${\displaystyle {\Gamma \vdash x\!:\!t_{1}\to t_{2}\quad \Gamma \vdash x\!:\!t_{1}} \over {\Gamma \vdash x~x\!:\!t_{2}}}$

ここで、 は無限型 を持ちます。固定小数点コンビネータは実際には型付けできません。これらのシステムでは、再帰のサポートは言語に明示的に追加する必要があります。 ${\displaystyle x}$${\displaystyle t_{1}=t_{1}\to t_{2}}$

再帰データ型をサポートするプログラミング言語では、型レベルで再帰を適切に考慮することで、Yコンビネータを型付けすることができます。変数xを自己適用する必要性はRec a、( )と同型になるように定義された型( Rec a -> a)を使用して管理できます。

例えば、次のHaskellコードでは、とがIn同型out性の2つの方向の名前であり、型は次のようになります。^{[19] [20]}

イン:: ( Rec a -> a ) -> Rec aアウト:: Rec a -> ( Rec a -> a )        
        

これにより、次のように記述できます。

新しい型Rec a = In { out :: Rec a -> a }            

y :: ( a -> a ) -> a y = \ f -> ( \ x - > f ( out x x )) ( In ( \ x -> f ( out x x )))      
                

または、OCaml では次のようになります。

タイプ ' a  recc  =  In  of  ( ' a  recc  ->  ' a ) 
let  out  ( In  x )  =  x

 y  f  =  ( fun  x  a  ->  f  ( out  x  x )  a )  ( in  ( fun  x  a  ->  f  ( out  x  x )  a ))とします。

あるいは:

 y  f  =  ( fun  x  ->  f  ( fun  z  ->  out  x  x  z ))  ( in  ( fun  x  ->  f  ( fun  z  ->  out  x  x  z )))とします。

固定小数点コンビネータは再帰の実装に使用できるため、固定小数点反復、反復メソッド、リレーショナルデータベースの再帰結合、データフロー分析、文脈自由文法の非終端記号の FIRST セットと FOLLOW セット、推移的閉包、その他のタイプの閉包操作などの特定のタイプの再帰計算を記述するために使用できます。

すべての入力が不動点である関数は恒等関数と呼ばれます。正式には次のようになります。

${\displaystyle \forall x(f\ x=x)}$

全体にわたる普遍量化とは対照的に、固定小数点コンビネータはの固定小数点である1 つの値を構築します。固定小数点コンビネータの注目すべき特性は、任意の与えられた関数に対して固定小数点を構築することです。 ${\displaystyle x}$${\displaystyle f}$${\displaystyle f}$

他の関数には、一度適用すると、それ以上適用しても効果がないという特別な特性があります。より正式には、次のようになります。

${\displaystyle \forall x(f\ (f\ x)=f\ x)}$

このような関数はべき等関数と呼ばれます(射影 (数学)も参照)。このような関数の例としては、すべての偶数に対して0 を返し、すべての奇数に対して 1 を返す関数があります。

ラムダ計算では、計算の観点から、固定小数点コンビネータを恒等関数またはべき等関数に適用すると、通常は終了しない計算になります。たとえば、

${\displaystyle (Y\ \lambda x.x)=(\lambda x.(xx)\ \lambda x.(xx))}$

結果の項はそれ自身にのみ還元され、無限ループを表します。

固定小数点コンビネータは、より制限的な計算モデルには必ずしも存在しません。たとえば、単純に型付けされたラムダ計算には存在しません。

Yコンビネータは、言語にネイティブな再帰サポートを必要とせずに、再帰を書き換え規則の集合として定義することを可能にする。 ^{[21 ] [22]}

匿名関数をサポートするプログラミング言語では、固定小数点コンビネータによって匿名再帰関数の定義と使用が可能になり、そのような関数を識別子にバインドする必要がなくなります。この設定では、固定小数点コンビネータの使用は匿名再帰と呼ばれることもあります。^{[注 4] [23]}