高階関数

2回← { ⍺⍺ ⍺⍺ ⍵ }プラス3 ← { ⍵ + 3 }g ← {プラス3を2回⍵ } g 7 13

あるいは暗黙のうちに：

2回← ⍣ 2プラス3 ← + ∘ 3g ←プラス3を2回g 7 13

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

import std ;auto twice = []( const std :: function < int ( int ) >& f ) -> auto { return [ f ]( int x ) -> int { return f ( f ( x )); }; } ;auto plusThree = []( int i ) -> int { return i + 3 ; };int main () { auto g = twice ( plusThree );std :: println ( "{}" , g ( 7 )); // 13 }

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

import std ;auto twice = []( const auto & f ) -> auto { return [ f ]( int x ) -> int { return f ( f ( x )); }; };auto plusThree = []( int i ) -> int { return i + 3 ; };int main () { auto g = twice ( plusThree );std :: println ( "{}" , g ( 7 )); // 13 }

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

Systemを使用します。public class 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 = twice ( plusThree );Console.WriteLine ( g ( 7 ) ); // 13 } }

あるいは、静的メソッドを使えば、同様に次のようになります。

Systemを使用します。public class Program { private static Func < int , int > Twice ( Func < int , int > f ) { return x => f ( f ( x )); }private static int PlusThree ( int i ) => i + 3 ;public static void Main ( string [] args ) { var g = Twice ( PlusThree );Console.WriteLine ( g ( 7 ) ); // 13 } }

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

defmodule Hof do def twice ( f ) do fn ( x ) -> f . ( f . ( x )) end end endplus_three = fn ( i ) -> i + 3 endg = Hof.twice ( plus_three )​​IO.puts g . ( 7 ) # 13​

あるいは、純粋な匿名関数を用いて合成することも可能です。

twice = fn ( f ) -> fn ( x ) -> f . ( f . ( x )) end endplus_three = fn ( i ) -> i + 3 endg = 2回. (プラス3 )IO.puts 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関数を評価します。関数がfalse を返すと、 の次の関数が評価されます。関数がを返すと、引数を持つの次の関数が評価されます。関数がを返すと、高階関数は を返します。、、 は関数であることに注意してください。この例では を返します。FXFFsF{false, Y}FsYFRor_else/2RXYRfalse

パッケージメインimport "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 := twice ( plusThree )fmt.Println ( g ( 7 ) ) // 13 }

関数リテラルは、識別子 ( twice) を使用して定義することも、匿名で定義することもできます (変数 に代入plusThree)。

具体的に言うと、

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

あるいは暗黙のうちに、

2回=. ^: 2プラス3 =. +& 3 g =.プラス3 2g 7 13

機能的なインターフェースのみを使用する：

import java.util.function.* ;class 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 ) ;​System.out.println ( g.applyAsInt ( 7 ) ) ; // 13 } }​​​

あるいは、静的メソッドを使えば、同様に次のようになります。

import java.util.function.* ;class Main { private static IntUnaryOperator twice ( IntUnaryOperator f ) { return f . andThen ( f ); }private static int plusThree ( int i ) { return i + 3 ; }public static void main ( String [] args ) { var g = twice ( Main :: plusThree );System.out.println ( g.applyAsInt ( 7 ) ) ; // 13 } }​​​

矢印関数を使用する場合：

「use strict」;const twice = f => x => f ( f ( x ));const plusThree = i => i + 3 ;const g = twice ( plusThree );console.log ( g ( 7 ) ) ; // 13

または、古典的な構文で：

「use strict」;function twice ( f ) { return function ( x ) { return f ( f ( x )); }; }function plusThree ( i ) { return i + 3 ; }const g = twice ( plusThree );console.log ( g ( 7 ) ) ; // 13

<?phpdeclare ( strict_types = 1 );function twice ( callable $f ) : Closure { return function ( int $x ) use ( $f ) : int { return $f ( $f ( $x )); }; }function plusThree ( int $i ) : int { return $i + 3 ; }$g = twice ( 'plusThree' );echo $g ( 7 ), " \n " ; // 13

または、すべての関数を変数に格納する場合：

<?phpdeclare ( strict_types = 1 );$twice = fn ( callable $f ) : Closure => fn ( int $x ) : int => $f ( $f ( $x ));$plusThree = fn ( int $i ) : int => $i + 3 ;$g = $twice ( $plusThree );echo $g ( 7 ), " \n " ; // 13

アロー関数は親スコープから来る変数を暗黙的にキャプチャしますが、^{[ 1 ]}匿名関数ではuse同じことを行うためにキーワードが必要です。

use strict ; use warnings ;sub twice { my ( $f ) = @_ ; sub { $f -> ( $f -> ( @_ )); }; }sub plusThree { my ( $i ) = @_ ; $i + 3 ; }my $g = twice ( \& plusThree );print $g -> ( 7 ), "\n" ; # 13

または、すべての関数を変数に格納する場合：

use strict ; use warnings ;my $twice = sub { my ( $f ) = @_ ; sub { $f -> ( $f -> ( @_ )); }; };my $plusThree = sub { my ( $i ) = @_ ; $i + 3 ; };my $g = $twice -> ( $plusThree );print $g -> ( 7 ), "\n" ; # 13

def twice ( f : Callable [ Any ]) -> Any : def result ( x : Any ) -> Any : return f ( f ( x )) return resultplus_three : Callable [ int ] = lambda i : i + 3g : int = twice ( plus_three )print ( g ( 7 )) # 13と出力されます

Pythonのデコレータ構文は、関数を、その関数を高階関数に渡した結果に置き換えるためによく使用されます。例えば、この関数はg以下のように同等に実装できます。

@twice def g ( i : int ) -> int : return i + 3print ( g ( 7 )) # 13と出力されます

sub twice ( Callable:D $f ) { return sub { $f ( $f ( $^x )) }; } sub plusThree ( Int:D $i ) { return $i + 3 ; } my $g = twice ( &plusThree ); $ g ( 7 ); #13

Rakuでは、すべてのコードオブジェクトはクロージャであるため、関数内ではレキシカル変数が「閉じられている」ため、外部スコープから内部の「レキシカル」変数を参照できます。また、Rakuはラムダ式のための「ポインティングブロック」構文をサポートしており、変数に代入したり、匿名で呼び出したりすることができます。

2回設定{{ f x } {apply $f [apply $f $x ] }} plusThree {{ i } {return [expr $i + 3 ]}}# 結果: 13 puts [apply $twice $plusThree 7 ]

Tcl は apply コマンドを使用して匿名関数を適用します (バージョン 8.6 以降)。

XACML規格では、属性バッグの複数の値に関数を適用するための高階関数が定義されています。

ルールallowEntry {許可条件anyOfAny(function [ stringEqual ], citizenships , allowedCitizenships ) }

XACMLの高階関数の一覧は、こちらで確認できます。

C、C++、Fortran、Pascalなどの言語における関数ポインタは、プログラマが関数への参照をやり取りすることを可能にします。以下のCコードは、任意の関数の積分の近似値を計算します。

#include <stdio.h>double square ( double x ) { return x * x ; }double cube ( double x ) { return x * x * x ; }/* 区間 [a,b] 内で f() の積分を計算する */ double integral ( double f ( double x ), double a , double b , int n ) { int i ; double sum = 0 ; double dt = ( b - a ) / n ; for ( i = 0 ; i < n ; ++ i ) { sum += f ( a + ( i + 0.5 ) * dt ); } return sum * dt ; }int main () { printf ( "%g \n " , integral ( square , 0 , 1 , 100 )); printf ( "%g \n " , integral ( cube , 0 , 1 , 100 )); return 0 ; }

C標準ライブラリのqsort関数は、関数ポインタを使用して高階関数の動作をエミュレートします。

マクロは、高階関数と同様の効果を実現するためにも使用できます。ただし、マクロでは変数キャプチャの問題を容易に回避することはできません。また、大量の重複コードが発生する可能性があり、コンパイラによる最適化が難しくなる場合があります。マクロは一般的に厳密な型付けはされませんが、厳密な型付けコードを生成することもあります。

他の命令型プログラミング言語では、評価スコープ内でコードを動的に実行すること（ EvalまたはExecute操作と呼ばれることもあります）によって、高階関数で得られるアルゴリズム的な結果の一部を実現することが可能です。ただし、このアプローチには重大な欠点があります。

• 実行される引数コードは通常、静的型付けされていません。これらの言語は一般的に、実行されるコードの整形式性と安全性を判断するために動的型付けに依存しています。
• 引数は通常文字列として渡され、その値は実行時まで分からない場合があります。この文字列は、プログラム実行中にコンパイルされる（ジャストインタイムコンパイルを使用する）か、解釈によって評価される必要があり、実行時に多少のオーバーヘッドが発生し、通常は効率の低いコードが生成されます。

高階関数をサポートしないオブジェクト指向プログラミング言語では、オブジェクトが効果的な代替手段となります。オブジェクトのメソッドは本質的に関数のように動作し、メソッドはオブジェクトをパラメータとして受け取り、オブジェクトを戻り値として生成することができます。ただし、オブジェクトは純粋関数に比べて実行時のオーバーヘッドが増加することが多く、オブジェクトとそのメソッドの定義とインスタンス化のための定型コードも追加されます。スタックベース（ヒープベースではなく）のオブジェクトや構造体を許可する言語は、この方法においてより高い柔軟性を提供できます。

Free Pascalで、関数を返す関数とシンプルなスタックベースのレコードを使用する例を以下に示します。

プログラム例;type int = integer ; Txy = record x , y : int ; end ; Tf = function ( xy : Txy ) : int ; function f ( xy : Txy ) : int ; begin Result := xy . y + xy . x ; end ;function g ( func : Tf ) : Tf ; begin result := func ; end ;変数a : Tf ; xy : Txy = ( x : 3 ; y : 7 ) ;begin a := g ( @ f ) ; // "a" に関数を返すwriteln ( a ( xy )) ; // 10 を出力するend .

この関数はレコードを入力としてa()受け取りTxy、レコードのフィールドの合計の整数値（3 + 7）を返しxますy。

関数非化は、第一級関数を持たない言語で高階関数を実装するために使用できます 。

// 非機能化された関数データ構造template < typename T > struct Add { T value ; }; template < typename T > struct DivBy { T value ; }; template < typename F , typename G > struct Composition { F f ; G g ; };// 非機能化された関数適用実装テンプレート< typename F , typename G , typename X > auto apply ( Composition < F , G > f , X arg ) { return apply ( f . f , apply ( f . g , arg )); }template < typename T , typename X > auto apply ( Add < T > f , X arg ) { return arg + f . value ; }template < typename T , typename X > auto apply ( DivBy < T > f , X arg ) { return arg / f . value ; }// 高階合成関数テンプレート< typename F , typename G > Composition < F , G > compose ( F f , G g ) { return Composition < F , G > { f , g }; }int main ( int argc , const char * argv []) { auto f = compose ( DivBy < float > { 2.0f }, Add < int > { 5 }); apply ( f , 3 ); // 4.0f apply ( f , 9 ); // 7.0f return 0 ; }

この場合、関数オーバーロードによって異なる関数をトリガーするために異なる型が使用されます。この例のオーバーロードされた関数のシグネチャは ですauto apply。