高階関数

数学とコンピュータサイエンスにおいて、高階関数( HOF ) とは、次のいずれか 1 つ以上を実行する 関数です。

• 1つ以上の関数を引数として受け取ります（つまり、手続きパラメータ、つまり手続き自体が手続きである手続きのパラメータ）。
• 関数または値を結果として返します。

その他の関数はすべて1 階関数です。数学では、高階関数は演算子または関数とも呼ばれます。微積分学の微分演算子は、関数をその導関数(これも関数)にマップするため、一般的な例です。高階関数は、数学全体での「関数子」という単語の他の用法と混同しないでください。関数子 (曖昧さ回避)を参照してください。

型なしラムダ計算では、すべての関数は高階です。ほとんどの関数型プログラミング言語の派生元である型付きラムダ計算では、1 つの関数を引数として取る高階関数は、形式の型を持つ値です。 ${\displaystyle (\tau _{1}\to \tau _{2})\to \tau _{3}}$

• map多くの関数型プログラミング言語に見られる関数は、高階関数の一例です。関数fと要素のコレクションを引数として受け取り、結果として、コレクションの各要素にfを適用した新しいコレクションを返します。
• ソート関数は、比較関数をパラメータとして受け取り、プログラマーがソートアルゴリズムをソート対象の項目の比較から分離できるようにします。C標準関数は 、qsortこの例です。
• フィルター
• 折り畳み
• 適用する
• 関数合成
• 統合
• 折り返し電話
• ツリートラバーサル
• 自然言語の意味理論であるモンタギュー文法は高階関数を使用する

これらの例はプログラミング言語を比較対照するものではなく、高階関数構文の例として役立つことを目的としています。

次の例では、高階関数はtwice関数を受け取り、その関数を何らかの値に 2 回適用します。twice同じ値に複数回適用する必要がある場合は、値ではなく関数を返す方が望ましいです。これは、「同じことを繰り返さないf」という原則に沿ったものです。

      2回← { ⍺⍺ ⍺⍺ ⍵ }  

      プラススリー← { ⍵ + 3 }

      g ← {プラススリーを2回⍵ } g 7 13  
    
       

あるいは暗黙的に:

      2回← ⍣ 2

      プラススリー← + ∘ 3

      g ←プラススリーを2回g 7 13 
    
       

C++11std::functionでの使用:

#include <iostream> #include <function> 
 

auto twice = []( const std :: function < int ( int ) >& f ) { return [ f ]( int x ) { return f ( f ( x )); }; };     

       
         
    


自動plus_three = []( int i ) {戻り値i + 3 ; };    

       


int main () { auto g = twice ( plus_three ); 

       

    std :: cout << g ( 7 ) << '\n' ; // 13 }     

または、C++14 で提供される汎用ラムダを使用する場合:

#include <iostream> 

auto を2 回実行します( const auto & f ) { return [ f ]( int x ) { return f ( f ( x )); }; };     

       
         
    


自動plus_three = []( int i ) {戻り値i + 3 ; };    

       


int main () { auto g = twice ( plus_three ); 

       

    std :: cout << g ( 7 ) << '\n' ; // 13 }     

デリゲートのみを使用する:

システムの使用; 

パブリッククラスProgram { public static void Main ( string [] args ) { Func < Func < int , int > , Func < int , int >> twice = f => x => f ( f ( x ));  

        
    
                  

        Func < int , int > plusThree = i => i + 3 ;        

        var g = 2回( plusThree );   

        コンソール.WriteLine ( g ( 7 )); // 13 } } 
    

または、静的メソッドの場合も同様です。

システムの使用; 

パブリッククラスProgram {プライベート静的Func < int , int > Twice ( Func < int , int > f ) { return x => f ( f ( x )); }  

          
    
           
    

    プライベート静的int PlusThree ( int i ) => i + 3 ;        

    パブリック静的void Main (文字列[]引数) { var g = Twice ( PlusThree );    
    
           

        コンソール.WriteLine ( g ( 7 )); // 13 } } 
    

( defn を2 回[ f ] ( fn [ x ] ( f ( f x )))) 
     

(定義プラス3 [ i ] ( + i 3 )) 
   

( def g ( 2倍プラス3 ))  

( println ( g 7 )) ; 13  

2回 = 関数( f )  {
    関数 ( x ) {戻り値f ( f ( x ) ) ; }; }; 
         
    


plusThree  =  function ( i )  { 
    return  i  +  3 ; 
};

g  =  2回（プラス3 ）;

書き込み出力( g ( 7 ));  // 13

( defun twice ( f ) ( lambda ( x ) ( funcall f ( funcall f x )))) ( defun plus-three ( i ) ( + i 3 )) ( defvar g ( twice #' plus-three )) ( print ( funcall g 7 ))                                                                  
                                               
                                                                                
                                                             
                                                                          
                                                                                
                                                    
                                                                                
   

stdをインポートします。stdio : writeln ;   

エイリアスを2回繰り返す= ( f ) => ( int x ) => f ( f ( x ));        

エイリアスplusThree = ( int i ) => i + 3 ;        

void main () { auto g = twice ( plusThree ); 

       

    writeln ( g ( 7 )); // 13 } 

int Function ( int )を 2 回( int Function ( int ) f ) { return ( x ) { return f ( f ( x )); }; }     
      
         
    


int plusThree ( int i ) {戻り値i + 3 ; }   
       


void main () { final g = twice ( plusThree ); print ( g ( 7 )); // 13 }  
       
    
     

Elixirではモジュール定義と無名関数を混在させることができます

defmodule Hof do def twice ( f ) do fn ( x ) -> f . ( f . ( x )) end end end  
      
           
    


plus_three = fn ( i ) -> i + 3終了       

g =ホフ. 2 倍(プラス 3 倍)  

IO .置くg . ( 7 ) # 13  

あるいは、純粋な匿名関数を使用して構成することもできます。

2回= fn ( f ) -> fn ( x ) -> f . ( f . ( x ))終了終了   
       


plus_three = fn ( i ) -> i + 3終了       

g = 2回。(プラス3 )  

IO .置くg . ( 7 ) # 13  

or_else ([], _) -> false ; or_else ([ F | Fs ], X ) -> or_else ( Fs , X , F ( X ))。   
       

or_else ( Fs 、X 、false ) -> or_else ( Fs 、X ) ; or_else ( Fs 、_、{ false 、Y }) -> or_else ( Fs 、Y ) ; or_else (_、_、R ) -> R 。     
      
    

or_else ([ fun erlang : is_integer / 1 , fun erlang : is_atom / 1 , fun erlang : is_list / 1 ], 3 . 23 )。      

この Erlang の例では、高階関数はor_else/2関数のリスト ( Fs) と引数 ( X) を受け取ります。関数を引数として評価しますF。X関数がFfalse を返す場合、 の次の関数Fsが評価されます。関数がFを返す場合{false, Y}、 の次の関数がFs引数としてY評価されます。関数がFを返す場合、R高階関数はor_else/2を返しますR。、、および は関数になる可能性があることに注意してくださいX。Y例Rでは を返しますfalse。

2回f = f >> fとする      

plus_three = (+) 3とします。    

g = 2倍プラス3とします    

g 7 |> printf "%A" // 13     

パッケージメイン 

「fmt」をインポートする 

func twice ( f func ( int ) int ) func ( int ) int { return func ( x int ) int { return f ( f ( x )) } }      
	    
		 
	


func main () { plusThree := func ( i int ) int { return i + 3 }  
	     
		   
	

	g := 2回(プラス3 )  

	fmt . Println ( g ( 7 )) // 13 } 

関数リテラルは、識別子 ( twice) を使用して定義することも、匿名 (変数 に割り当てられるplusThree) で定義することもできることに注意してください。

def twice = { f , x -> f ( f ( x )) } def plusThree = { it + 3 } def g = twice . curry ( plusThree ) println g ( 7 ) // 13        
       
    
  

2回:: ( Int -> Int ) -> ( Int -> Int ) 2回f = f . f        
     

plusThree :: Int -> Int plusThree = ( + 3 )    
  

main :: IO () main = print ( g 7 ) -- 13ここでg = 2 倍プラス 3   
     
  
       

明確に言えば、

   二度=.副詞: 'uu y'       

   plusthree =.動詞: 'y + 3' g =. plusthree を2回g 7 13     
   
     
   
    

あるいは暗黙のうちに、

   2回=. ^: 2 

   プラススリー=. +& 3 g =.プラススリーを2回g 7 13 
   
     
   
    

関数インターフェースのみを使用する:

java.util.function.*をインポートします。 

クラス Main { public static void main ( String [] args ) { Function < IntUnaryOperator , IntUnaryOperator > twice = f -> f . andThen ( f ); 
         
              

        IntUnaryOperator plusThree = i -> i + 3 ;       

        var g = twice.apply ( plusThree ) ;​   

        システム.out.println ( g.applyAsInt ( 7 ) ) ; // 13 } }​​ 
    

または、静的メソッドの場合も同様です。

java.util.function.*をインポートします。 

クラス Main {プライベート静的IntUnaryOperator twice ( IntUnaryOperator f ) { return f . andThen ( f ); } 
         
         
    

    プライベート静的int plusThree ( int i ) { return i + 3 ; }     
           
    

    パブリック静的void main ( String [] args ) { var g = twice ( Main :: plusThree );     
           

        システム.out.println ( g.applyAsInt ( 7 ) ) ; // 13 } }​​ 
    

矢印関数の場合:

「厳密な使用」;

定数を2回繰り返すと、 f => x => f ( f ( x ) ) になります。       

const plusThree = i => i + 3 ;       

gを2回繰り返します。   

コンソール.log ( g ( 7 ) ); // 13 

あるいは古典的な構文では:

「厳密な使用」;

関数を2回実行します( f ) {関数( x )を戻します{ f ( f ( x )を戻します); }; }  
     
     
  


関数plusThree ( i ) {戻り値i + 3 ; }  
     


gを2回繰り返します。   

コンソール.log ( g ( 7 ) ); // 13 

julia> function twice ( f ) function result ( x ) return f ( f ( x )) end return result end twice (1 つのメソッドを持つ汎用関数)  
            
                
           
            
       


julia> plusthree ( i ) = i + 3 plusthree (1 つのメソッドを持つ汎用関数)     


julia> g = twice ( plusthree ) (::var"#result#3"{typeof(plusthree)}) (1 つのメソッドを持つ汎用関数)   


ジュリア> g ( 7 ) 13 

fun を2 回実行します( f : ( Int ) -> Int ): ( Int ) -> Int { return { f ( f ( it )) } }        
       


楽しいplusThree ( i : Int ) = i + 3      

fun main () { val g = twice ( :: plusThree )  
       

    println ( g ( 7 )) // 13 } 

関数を 2回実行する( f )
  関数を返す ( x ) fを返す( f ( x ))終了終了 
     
  


関数 plusThree ( i )
  戻り値 i  +  3
終了

ローカル g  =  2 回(プラス 3 回)

印刷( g ( 7 ))  -- 13

関数 結果= twice ( f )結果= @( x ) f ( f ( x ));終了  
   


プラス3 = @( i ) i + 3 ;     

g = 2倍（プラス3 ）  

ディスプ（g （7 ））; % 13 

 f x = f ( f x )を2回 繰り返す。  
    

 plus_three  = 
  (+)  3とします。

let  ()  = 
  let  g  =  2回 plus_three  in

  print_int  ( g  7 );  (* 13 *) 
  print_newline  ()

<?php

宣言します( strict_types = 1 );

function を 2 回( callable  $f ) : クロージャ { 
    return  function  ( int  $x )  use  ( $f ) :  int  { 
        return  $f ( $f ( $x )); 
    }; 
}

関数 plusThree ( int  $i ) :  int  { 
    return  $i  +  3 ; 
}

$g  =  2回( 'plusThree' );

echo  $g ( 7 ),  " \n " ;  // 13

またはすべての関数を変数に含めます:

<?php

宣言します( strict_types = 1 );

$twice  =  fn (呼び出し可能 $f ) : クロージャ =>  fn ( int  $x ) :  int  =>  $f ( $f ( $x ));

$plusThree  =  fn ( int  $i ) :  int  =>  $i  +  3 ;

$g  =  $twice ( $plusThree );

echo  $g ( 7 ),  " \n " ;  // 13

矢印関数は親スコープから来る変数を暗黙的にキャプチャしますが、^[1]匿名関数ではuse同じことを行うためにキーワードが必要であることに注意してください。

strictを使用します。warningsを使用します。 
 

sub を2 回実行します{ my ( $f ) = @_ ; sub { $f -> ( $f -> ( @_ )); }; }  
       
     
        
    


サブプラススリー{ my ( $i ) = @_ ; $i + 3 ; }  
       
      


私の$g = 2 回( \& plusThree );   

$g -> ( 7 )を印刷します。 "\n" ; #13   

またはすべての関数を変数に含めます:

strictを使用します。warningsを使用します。 
 

my $twice = sub { my ( $f ) = @_ ; sub { $f -> ( $f -> ( @_ )); }; };    
       
     
        
    


my $plusThree = sub { my ( $i ) = @_ ; $i + 3 ; };    
       
      


私の$g = $twice -> ( $plusThree );   

$g -> ( 7 )を印刷します。 "\n" ; #13