उच्च-क्रम फलन

गणित और कंप्यूटर विज्ञान में, एक उच्च-क्रम फ़ंक्शन (HOF) एक फ़ंक्शन (गणित) है जो निम्न में से कम से कम एक कार्य करता है: अन्य सभी कार्य प्रथम क्रम के कार्य हैं। गणित में उच्च-क्रम के कार्यों को संचालक (गणित) या कार्यात्मक (गणित) भी कहा जाता है। गणना में अंतर ऑपरेटर एक सामान्य उदाहरण है, क्योंकि यह एक फ़ंक्शन को इसके व्युत्पन्न के लिए मैप करता है, यह एक फ़ंक्शन भी है। पूरे गणित में फ़ंक्टर शब्द के अन्य उपयोगों के साथ उच्च-क्रम के कार्यों को भ्रमित नहीं किया जाना चाहिए, फ़ंक्टर (बहुविकल्पी) देखें।
 * तर्क के रूप में एक या एक से अधिक कार्य करता है (यानी एक प्रक्रियात्मक पैरामीटर, जो एक उपनेमका का एक पैरामीटर (कंप्यूटर विज्ञान) है जो स्वयं एक प्रक्रिया है),
 * इसके परिणाम के रूप में एक समारोह देता है।

अनटाइप्ड लैम्ब्डा कैलकुलस में, सभी फंक्शन उच्च-क्रम वाले होते हैं; एक टाइप किए गए लैम्ब्डा कैलकुस में, जिसमें से अधिकांश कार्यात्मक प्रोग्रामिंग भाषाएं व्युत्पन्न होती हैं, उच्च-क्रम के फ़ंक्शन जो एक फ़ंक्शन को तर्क के रूप में लेते हैं, फॉर्म के प्रकारों के साथ मान होते हैं $$(\tau_1\to\tau_2)\to\tau_3$$.

सामान्य उदाहरण

 * फ़ंक्शन, कई कार्यात्मक प्रोग्रामिंग भाषाओं में पाया जाता है, उच्च-क्रम फ़ंक्शन का एक उदाहरण है। यह तर्क के रूप में एक फ़ंक्शन f और तत्वों का एक संग्रह लेता है, और परिणामस्वरूप, संग्रह से प्रत्येक तत्व पर लागू f के साथ एक नया संग्रह देता है।
 * सॉर्टिंग फ़ंक्शंस, जो एक तुलना फ़ंक्शन को एक पैरामीटर के रूप में लेते हैं, प्रोग्रामर को सॉर्टिंग एल्गोरिथ्म को सॉर्ट किए जा रहे आइटमों की तुलना से अलग करने की अनुमति देता है। सी (प्रोग्रामिंग भाषा) मानक समारोह (कंप्यूटर विज्ञान)  इसका एक उदाहरण है।
 * फ़िल्टर (उच्च-क्रम फ़ंक्शन)
 * गुना (उच्च-क्रम समारोह)
 * आवेदन करना
 * फंक्शन रचना (कंप्यूटर विज्ञान)
 * अभिन्न
 * कॉलबैक (कंप्यूटर प्रोग्रामिंग)
 * ट्री ट्रैवर्सल
 * मोंटेग व्याकरण, प्राकृतिक भाषा का एक सिमेंटिक सिद्धांत, उच्च-क्रम के कार्यों का उपयोग करता है

प्रत्यक्ष समर्थन
उदाहरणों का उद्देश्य प्रोग्रामिंग भाषाओं की तुलना और तुलना करना नहीं है, बल्कि उच्च-क्रम फ़ंक्शन सिंटैक्स के उदाहरण के रूप में काम करना है

निम्नलिखित उदाहरणों में, उच्च-क्रम फ़ंक्शन twice एक फ़ंक्शन लेता है, और फ़ंक्शन को दो बार कुछ मान पर लागू करता है। अगर twice इसके लिए कई बार आवेदन करना पड़ता है f यह अधिमानतः एक मूल्य के बजाय एक फ़ंक्शन वापस करना चाहिए। यह स्वयं को न दोहराने के सिद्धांत के अनुरूप है।

एपीएल
<वाक्यविन्यास प्रकाश लैंग = एपीएल> दो बार←{⍺⍺ ⍺⍺ ⍵}

plusthree←{⍵+3}

g←{प्लसथ्री दो बार ⍵} जी 7 13 

या मौन तरीके से:

<वाक्यविन्यास प्रकाश लैंग = एपीएल> दो बार←⍣2

plusthree←+∘3

जी←प्लसथ्री दो बार जी 7 13 

=सी++===

का उपयोग करते हुए std::function सी ++ 11 में:

<वाक्यविन्यास प्रकाश लैंग = सी ++>
 * 1) शामिल
 * 2) शामिल <कार्यात्मक>

ऑटो दो बार = [] (स्थिरांक एसटीडी :: समारोह  और च) {   वापसी [एफ] (इंट एक्स) { वापसी एफ (एफ (एक्स)); }; };

ऑटो प्लस_थ्री = [] (इंट आई) {   वापसी मैं + 3; };

मुख्य प्रवेश बिंदु {   ऑटो जी = दो बार (प्लस_थ्री);

एसटीडी :: अदालत << जी (7) << '\n'; // 13 } 

या, सी ++ 14 द्वारा प्रदान किए गए सामान्य लैम्ब्डा के साथ:

<वाक्यविन्यास प्रकाश लैंग = सी ++>
 * 1) शामिल

ऑटो दो बार = [] (स्थिरांक ऑटो और च) {   वापसी [एफ] (इंट एक्स) { वापसी एफ (एफ (एक्स)); }; };

ऑटो प्लस_थ्री = [] (इंट आई) {   वापसी मैं + 3; };

मुख्य प्रवेश बिंदु {   ऑटो जी = दो बार (प्लस_थ्री);

एसटीडी :: अदालत << जी (7) << '\n'; // 13 } 

सी#
केवल प्रतिनिधियों का उपयोग करना:

<वाक्यविन्यास प्रकाश लैंग = csharp> सिस्टम का उपयोग करना;

सार्वजनिक वर्ग कार्यक्रम {   सार्वजनिक स्थैतिक शून्य main (String [] args) {       Func, Func> दो बार = f => x => f(f(x));

Func plusThree = i => i + 3;

वर जी = दो बार (प्लसथ्री);

कंसोल.राइटलाइन (जी (7)); // 13 } } 

या समतुल्य, स्थिर विधियों के साथ:

<वाक्यविन्यास प्रकाश लैंग = csharp> सिस्टम का उपयोग करना;

सार्वजनिक वर्ग कार्यक्रम {   निजी स्थैतिक फ़ंक  दो बार (Func  f)    { रिटर्न एक्स => एफ (एफ (एक्स)); }

निजी स्थिर int PlusThree (int i) => i + 3;

सार्वजनिक स्थैतिक शून्य main (String [] args) {       वर जी = दो बार (प्लसथ्री);

कंसोल.राइटलाइन (जी (7)); // 13 } } 

क्लोजर
<वाक्यविन्यास प्रकाश लैंग = क्लोजर> (दो बार परिभाषित करें [एफ] (एफएन [एक्स] (एफ (एफ एक्स))))

(डीएफ़एन प्लस-थ्री [i] (+ मैं 3))

(डीईएफ़ जी (दो बार प्लस-थ्री))

(प्रिंटल (जी 7)); 13 

कोल्ड फ्यूजन मार्कअप लैंग्वेज (CFML)
<वाक्यविन्यास प्रकाश लैंग = सीएफएस> दो बार = समारोह (च) { वापसी समारोह (एक्स) { वापसी एफ (एफ (एक्स)); }; };

plusThree = फ़ंक्शन (i) { वापसी मैं + 3; };

जी = दो बार (प्लसथ्री);

राइटआउटपुट (जी (7)); // 13 

आम लिस्प
<वाक्यविन्यास प्रकाश लैंग = लिस्प> (दो बार परिभाषित करें (च) (लैम्ब्डा (एक्स) (फनकॉल एफ (फंककॉल एफ एक्स)))) (डिफ्यूज प्लस-थ्री (i) (+ मैं 3)) (डेफवर जी (दो बार #'प्लस-थ्री)) (प्रिंट (फंककॉल जी 7)) 

=डी===

<वाक्यविन्यास प्रकाश लैंग = डी> आयात std.stdio : writeln;

उपनाम दो बार = (एफ) => (इंट एक्स) => एफ (एफ (एक्स));

उर्फ प्लसथ्री = (इंट आई) => आई + 3;

शून्य मुख्य {   ऑटो जी = दो बार (प्लसथ्री);

लेख (जी (7)); // 13 } 

डार्ट
<वाक्यविन्यास लैंग = डार्ट> इंट फंक्शन (इंट) दो बार (इंट फंक्शन (इंट) एफ) { वापसी (एक्स) { वापसी एफ (एफ (एक्स)); }; }

इंट प्लस थ्री (इंट आई) { वापसी मैं + 3; }

शून्य मुख्य { अंतिम जी = दो बार (प्लसथ्री); प्रिंट (जी (7)); // 13 } </वाक्यविन्यास हाइलाइट>

अमृत
अमृत ​​​​में, आप मॉड्यूल परिभाषाओं और अनाम कार्यों को मिला सकते हैं

<वाक्यविन्यास लैंग = अमृत> डिफमॉड्यूल हॉफ डू def दो बार (एफ) करते हैं fn(x) -> f.(f.(x)) अंत अंत अंत

plus_three = fn (i) -> 3 + i समाप्त

जी = हॉफ। दो बार (प्लस_थ्री)

IO.puts g.(7) # 13 </वाक्यविन्यास हाइलाइट>

वैकल्पिक रूप से, हम शुद्ध अनाम कार्यों का उपयोग करके रचना भी कर सकते हैं।

<वाक्यविन्यास लैंग = अमृत> दो बार = एफएन (एफ) -> fn(x) -> f.(f.(x)) अंत अंत

plus_three = fn (i) -> 3 + i समाप्त

जी = दो बार। (प्लस_थ्री)

IO.puts g.(7) # 13 </वाक्यविन्यास हाइलाइट>

एरलांग
<वाक्यविन्यास लैंग = erlang> or_else([], _) -> झूठा; or_else ([एफ | एफएस], एक्स) -> or_else (एफएस, एक्स, एफ (एक्स))।

or_else(Fs, X, false) -> or_else(Fs, X); or_else(Fs, _, {false, Y}) -> or_else(Fs, Y); or_else (_, _, आर) -> आर।

or_else([मजेदार erlang:is_integer/1, fun erlang:is_atom/1, fun erlang:is_list/1], 3.23)। </वाक्यविन्यास हाइलाइट>

इस Erlang उदाहरण में, उच्च-क्रम फ़ंक्शन or_else/2 कार्यों की एक सूची लेता है (Fs) और तर्क (X). यह फ़ंक्शन का मूल्यांकन करता है F तर्क के साथ X तर्क के रूप में। यदि समारोह F झूठा लौटाता है फिर अगला कार्य करता है Fs मूल्यांकन किया जाएगा। यदि समारोह F रिटर्न {false, Y} फिर अगला समारोह में Fs तर्क के साथ Y मूल्यांकन किया जाएगा। यदि समारोह F रिटर्न R उच्च-क्रम समारोह or_else/2 वापसी करेंगे R. ध्यान दें कि X, Y, और R कार्य हो सकते हैं। उदाहरण लौटता है false.

एफ#
<वाक्यविन्यास लैंग = fsharp> माना दो बार f = f >> f

माना plus_three = (+) 3

चलो जी = दो बार प्लस_थ्री

जी 7 |> प्रिंटफ% ए // 13 </वाक्यविन्यास हाइलाइट>

जाओ
<वाक्यविन्यास प्रकाश लैंग = जाओ> मुख्य पैकेज

एफएमटी आयात करें

func दो बार (f func (int) int) func (int) int { रिटर्न फंक (एक्स इंट) इंट { रिटर्न एफ (एफ (एक्स)) } }

फंक मेन { plusThree := func(i int) int { वापसी मैं + 3 }

जी := दो बार (प्लस तीन)

fmt.Println (जी (7)) // 13 } </वाक्यविन्यास हाइलाइट>

ध्यान दें कि एक फ़ंक्शन शाब्दिक या तो पहचानकर्ता के साथ परिभाषित किया जा सकता है (twice) या गुमनाम रूप से (वैरिएबल को असाइन किया गया plusThree).

हास्केल
<वाक्यविन्यास लैंग = हैकेल> दो बार :: (इंट -> इंट) -> (इंट -> इंट) दो बार एफ = एफ। एफ

plusThree :: इंट -> इंट जमा तीन = (+3)

मुख्य :: आईओ मुख्य = प्रिंट (जी 7) - 13 कहाँ जी = दो बार प्लस थ्री </वाक्यविन्यास हाइलाइट>

जे
स्पष्ट रूप से,

<वाक्यविन्यास प्रकाश लैंग = जे> दो बार =। क्रिया विशेषण: 'यू यू वाई'

प्लसथ्री =। क्रिया : 'वाई + 3' जी =। plusthree दो बार जी 7 13 </वाक्यविन्यास हाइलाइट>

या चुपचाप,

<वाक्यविन्यास प्रकाश लैंग = जे> दो बार =। ^:2

प्लसथ्री =। +&3 जी =। plusthree दो बार जी 7 13 </वाक्यविन्यास हाइलाइट>

जावा (1.8+)
केवल कार्यात्मक इंटरफेस का उपयोग करना:

<वाक्यविन्यास प्रकाश लैंग = जावा> आयात java.util.function.*;

वर्ग मुख्य { सार्वजनिक स्थैतिक शून्य main (String [] args) { फंक्शन <IntUnaryOperator, IntUnaryOperator> दो बार = f -> f.andThen (f);

IntUnaryOperator plusThree = i -> i + 3;

var g = दो बार। लागू करें (प्लसथ्री);

System.out.println(g.applyAsInt(7)); // 13 } } </वाक्यविन्यास हाइलाइट>

या समतुल्य, स्थिर विधियों के साथ:

<वाक्यविन्यास प्रकाश लैंग = जावा> आयात java.util.function.*;

वर्ग मुख्य { निजी स्थिर इंटयूनरीऑपरेटर दो बार (इंटयूनरीऑपरेटर एफ) { वापसी f.andThen (एफ); }

निजी स्थिर इंट प्लस थ्री (इंट आई) { वापसी मैं + 3; }

सार्वजनिक स्थैतिक शून्य main (String [] args) { वर जी = दो बार (मुख्य :: plusThree);

System.out.println(g.applyAsInt(7)); // 13 } } </वाक्यविन्यास हाइलाइट>

जावास्क्रिप्ट
तीर कार्यों के साथ:

<वाक्यविन्यास लैंग = जावास्क्रिप्ट> सख्त प्रयोग करें;

const दो बार = f => x => f(f(x));

const plusThree = i => i + 3;

कॉन्स्ट जी = दो बार (प्लसथ्री);

कंसोल.लॉग (जी (7)); // 13 </वाक्यविन्यास हाइलाइट>

या शास्त्रीय वाक्य रचना के साथ:

<वाक्यविन्यास लैंग = जावास्क्रिप्ट> सख्त प्रयोग करें;

समारोह दो बार (च) { वापसी समारोह (एक्स) { वापसी एफ (एफ (एक्स)); }; }

फ़ंक्शन प्लस थ्री (i) { वापसी मैं + 3; }

कॉन्स्ट जी = दो बार (प्लसथ्री);

कंसोल.लॉग (जी (7)); // 13 </वाक्यविन्यास हाइलाइट>

जूलिया
<वाक्यविन्यास लैंग = jlcon> जूलिया> दो बार कार्य करें (च) कार्य परिणाम (एक्स) रिटर्न एफ (एफ (एक्स)) अंत वापसी परिणाम अंत दो बार (1 विधि के साथ सामान्य कार्य)

जूलिया> प्लसथ्री (i) = i + 3 plusthree (1 विधि के साथ सामान्य कार्य)

जूलिया> जी = दो बार (प्लसथ्री) (::var #result#3 {typeof(plusthree)}) (1 विधि के साथ सामान्य कार्य)

जूलिया> जी(7) 13 </वाक्यविन्यास हाइलाइट>

कोटलिन
<वाक्यविन्यास लैंग = कोटलिन> मज़ा दो बार (एफ: (इंट) -> इंट): (इंट) -> इंट { वापसी {एफ (एफ (यह))} }

फन प्लस थ्री (आई: इंट) = आई + 3

मज़ा मुख्य { वैल जी = दो बार (:: प्लस थ्री)

प्रिंट्लन (जी (7)) // 13 } </वाक्यविन्यास हाइलाइट>

दो
<वाक्यविन्यास लैंग = लुआ> समारोह दो बार (च) वापसी समारोह (एक्स) रिटर्न एफ (एफ (एक्स)) अंत अंत

फ़ंक्शन प्लस थ्री (i) वापसी मैं + 3 अंत

स्थानीय जी = दो बार (प्लसथ्री)

प्रिंट (जी (7)) - 13 </वाक्यविन्यास हाइलाइट>

मतलब
<वाक्यविन्यास प्रकाश लैंग = matlab> कार्य परिणाम = दो बार (च) परिणाम = @आंतरिक

फ़ंक्शन वैल = आंतरिक (एक्स) वैल = एफ (एफ (एक्स)); अंत अंत

plusthree = @(i) i + 3;

जी = दो बार (प्लसथ्री)

विवाद (जी (7)); % 13 </वाक्यविन्यास हाइलाइट>

ओकैमल
<वाक्यविन्यास प्रकाश लैंग = ओकैमल प्रारंभ = 1> माना दो बार f x = एफ (एफ एक्स)

मान लीजिए plus_three = (+) 3

चलो = चलो जी = दो बार प्लस_थ्री इन

Print_int (जी 7); (* 13 *) प्रिंट_न्यूलाइन </वाक्यविन्यास हाइलाइट>

= पीएचपी ===

<वाक्यविन्यास लैंग = php> <?php

घोषित करें (सख्त_प्रकार = 1);

फ़ंक्शन दो बार (कॉल करने योग्य $ f): क्लोजर { रिटर्न फ़ंक्शन (int $x) उपयोग ($f): int { वापसी $f($f($x)); }; }

फ़ंक्शन प्लस थ्री (इंट $ i): इंट { वापसी $i + 3; }

$ जी = दो बार ('प्लसथ्री');

प्रतिध्वनि $g(7), \n; // 13 </वाक्यविन्यास हाइलाइट>

या चर में सभी कार्यों के साथ:

<वाक्यविन्यास लैंग = php> <?php

घोषित करें (सख्त_प्रकार = 1);

$ दो बार = एफएन (कॉल करने योग्य $ एफ): क्लोजर => एफएन (इंट $ एक्स): इंट => $ एफ ($ एफ ($ एक्स));

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

$g = $दो बार($plusThree);

प्रतिध्वनि $g(7), \n; // 13 </वाक्यविन्यास हाइलाइट>

ध्यान दें कि एरो फ़ंक्शंस मूल रूप से पैरेंट स्कोप से आने वाले किसी भी वेरिएबल को कैप्चर करता है, जबकि अनाम कार्यों की आवश्यकता होती है use ऐसा करने के लिए कीवर्ड।

पर्ल
<वाक्यविन्यास प्रकाश लैंग = पर्ल> सख्त उपयोग; चेतावनियों का उपयोग करें;

उप दो बार { मेरा ($ च) = @_; विषय { $f->($f->(@_)); }; }

सब प्लस थ्री { मेरा ($i) = @_; $ मैं + 3; }

मेरा $g = दो बार (\&plusThree);

प्रिंट $g->(7), \n ; # 13 </वाक्यविन्यास हाइलाइट>

या चर में सभी कार्यों के साथ:

<वाक्यविन्यास प्रकाश लैंग = पर्ल> सख्त उपयोग; चेतावनियों का उपयोग करें;

मेरा $ दो बार = उप { मेरा ($ एफ) = @_; विषय { $f->($f->(@_)); }; };

मेरा $ प्लस थ्री = सब { मेरी ($ एक्स) = @_; $ एक्स + 3; };

my $g = $twice->($plusThree);

प्रिंट $g->(7), \n ; # 13 </वाक्यविन्यास हाइलाइट>

पायथन
<वाक्यविन्यास लैंग = पिकॉन> >>> दो बार डीईएफ़ (च): ... डीफ़ परिणाम (एक्स): ... रिटर्न एफ (एफ (एक्स)) ... वापसी परिणाम

>>> plus_three = लैम्ब्डा i: i + 3

>>> जी = दो बार (प्लस_तीन) >>> जी(7) 13 </वाक्यविन्यास हाइलाइट>

पायथन डेकोरेटर सिंटैक्स का उपयोग अक्सर किसी फ़ंक्शन को उच्च-क्रम फ़ंक्शन के माध्यम से उस फ़ंक्शन को पारित करने के परिणाम के साथ बदलने के लिए किया जाता है। उदा., समारोह g समान रूप से लागू किया जा सकता है:

<वाक्यविन्यास लैंग = पिकॉन> >>> @दो बार ... डीईएफ़ जी (मैं): ... वापसी मैं + 3

>>> जी(7) 13 </वाक्यविन्यास हाइलाइट>

आर
<वाक्यविन्यास प्रकाश लैंग = आर> दो बार <- फ़ंक्शन (एफ) { वापसी (फ़ंक्शन (एक्स) {   एफ (एफ (एक्स))  }) }

plusThree <- फ़ंक्शन (i) { वापसी (मैं + 3) }

जी <- दो बार (प्लसथ्री)

> प्रिंट (जी (7)) [1] 13 </वाक्यविन्यास हाइलाइट>

राकु
<वाक्यविन्यास प्रकाश लैंग = perl6> उप दो बार (कॉल करने योग्य: डी $ एफ) { वापसी उप { $f($f($^x)) }; }

सब प्लसथ्री(इंट:डी $i) { वापसी $i + 3; }

मेरा $g = दो बार (&plusThree);

कहो $जी(7); # 13 </वाक्यविन्यास हाइलाइट>

राकू में, सभी कोड ऑब्जेक्ट क्लोजर हैं और इसलिए आंतरिक लेक्सिकल वैरिएबल को बाहरी दायरे से संदर्भित कर सकते हैं क्योंकि लेक्सिकल वैरिएबल फ़ंक्शन के अंदर बंद है। Raku लैम्ब्डा एक्सप्रेशंस के लिए नुकीले ब्लॉक सिंटैक्स का भी समर्थन करता है जिसे एक चर के लिए असाइन किया जा सकता है या गुमनाम रूप से लागू किया जा सकता है।

रुबी
<वाक्यविन्यास लैंग = रूबी> डीईएफ़ दो बार (च) ->(x) { f.call(f.call(x)) } अंत

plus_three = -> (i) {i + 3}

जी = दो बार (प्लस_थ्री)

जी कॉल (7) # 13 डालता है </वाक्यविन्यास हाइलाइट>

जंग
<वाक्यविन्यास प्रकाश लैंग = जंग> fn दो बार (f: impl Fn(i32) -> i32) -> impl Fn(i32) -> i32 { चाल |x| एफ (एफ (एक्स)) }

fn plus_three (i: i32) -> i32 { मैं + 3 }

एफएन मुख्य { चलो जी = दो बार (प्लस_थ्री);

Println! ({}, जी (7)) // 13 } </वाक्यविन्यास हाइलाइट>

स्काला
<वाक्यविन्यास प्रकाश लैंग = स्कैला> वस्तु मुख्य { def दो बार (एफ: इंट => इंट): इंट => इंट = f रचना f

डीईएफ़ प्लस थ्री (आई: इंट): इंट = मैं + 3

def मुख्य (तर्क: ऐरे [स्ट्रिंग]): यूनिट = { वैल जी = दो बार (प्लसथ्री)

प्रिंट (जी (7)) // 13 } } </वाक्यविन्यास हाइलाइट>

योजना
<वाक्यविन्यास लैंग = योजना> (परिभाषित करें (x y जोड़ें) (+ x y)) (परिभाषित करें (एफ एक्स) (लैम्ब्डा (y) (+ x y))) (प्रदर्शन ((च 3) 7)) (प्रदर्शन (3 7 जोड़ें)) </वाक्यविन्यास हाइलाइट>

इस योजना उदाहरण में, उच्च-क्रम फ़ंक्शन (f x) करी को लागू करने के लिए प्रयोग किया जाता है। यह एक तर्क लेता है और एक फ़ंक्शन देता है। अभिव्यक्ति का मूल्यांकन ((f 3) 7) पहले मूल्यांकन के बाद एक फ़ंक्शन लौटाता है (f 3). लौटाया गया कार्य है (lambda (y) (+ 3 y)). फिर, यह तर्क के रूप में 7 के साथ दिए गए फ़ंक्शन का मूल्यांकन करता है, 10 लौटाता है। यह अभिव्यक्ति के बराबर है (add 3 7), तब से (f x) के करी रूप के बराबर है (add x y).

तेज
<वाक्यविन्यास प्रकाश लैंग = तेज> func दो बार (_ f: @escaping (Int) -> Int) -> (Int) -> Int { वापसी { f(f($0)) } }

चलो plusThree = { $0 + 3 }

चलो जी = दो बार (प्लस तीन)

प्रिंट (जी (7)) // 13 </वाक्यविन्यास हाइलाइट>

टीसीएल
<वाक्यविन्यास लैंग = टीसीएल> दो बार सेट करें {{f x} {apply $f [apply $f $x]}} प्लस थ्री सेट करें {{i} {return [expr $i + 3]}} पुट [लागू $दो बार $ प्लस तीन 7] </वाक्यविन्यास हाइलाइट> अनाम फ़ंक्शन (8.6 के बाद से) को लागू करने के लिए टीसीएल लागू कमांड का उपयोग करता है।
 * 1) परिणाम: 13

XACML
XACML मानक विशेषता बैग के एकाधिक मानों पर फ़ंक्शन लागू करने के लिए मानक में उच्च-क्रम फ़ंक्शन को परिभाषित करता है।

<वाक्यविन्यास लैंग = xquery> नियम अनुमति प्रवेश { आज्ञा देना किसी भी स्थिति में (फ़ंक्शन [स्ट्रिंगइक्वल], नागरिकता, अनुमत नागरिकता) } </वाक्यविन्यास हाइलाइट>

XACML में उच्च-क्रम के कार्यों की सूची XACML# उच्च क्रम के कार्यों को मिल सकती है।

एक्सक्वायरी
<वाक्यविन्यास लैंग = xquery> फ़ंक्शन को स्थानीय घोषित करें: दो बार ($ f, $ x) { $f($f($x)) };

फ़ंक्शन स्थानीय घोषित करें: प्लसथ्री ($ i) { $ आई + 3 };

स्थानीय: दो बार (स्थानीय: plusthree#1, 7) (: 13 :) </वाक्यविन्यास हाइलाइट>

फंक्शन पॉइंटर्स
C (प्रोग्रामिंग लैंग्वेज), C++, और पास्कल (प्रोग्रामिंग भाषा) जैसी भाषाओं में फंक्शन पॉइंटर्स प्रोग्रामर्स को फंक्शन्स के संदर्भ में पास करने की अनुमति देते हैं। निम्नलिखित सी कोड एक मनमानी समारोह के अभिन्न अंग के अनुमान की गणना करता है:

<वाक्यविन्यास प्रकाश लैंग = सी>
 * 1) शामिल <stdio.h>

डबल स्क्वायर (डबल एक्स) {   वापसी एक्स * एक्स; }

डबल क्यूब (डबल एक्स) {   वापसी एक्स * एक्स * एक्स; }

/* इंटरवल [a,b] के भीतर f के इंटीग्रल की गणना करें */ डबल इंटीग्रल (डबल एफ (डबल एक्स), डबल ए, डबल बी, इंट एन) {   int मैं; दोहरा योग = 0; डबल डीटी = (बी - ए) / एन; के लिए (i = 0; i <n; ++i) { योग + = एफ (ए + (आई + 0.5) * डीटी); }   वापसी राशि * डीटी; }

मुख्य प्रवेश बिंदु {   प्रिंटफ (% जी \ n, अभिन्न (वर्ग, 0, 1, 100)); प्रिंटफ (% जी \ n, अभिन्न (घन, 0, 1, 100)); वापसी 0; } </वाक्यविन्यास हाइलाइट>

सी मानक लाइब्रेरी से qsort फ़ंक्शन उच्च-क्रम फ़ंक्शन के व्यवहार का अनुकरण करने के लिए फ़ंक्शन पॉइंटर का उपयोग करता है।

मैक्रोज़
उच्च-क्रम के कार्यों के कुछ प्रभावों को प्राप्त करने के लिए मैक्रो (कंप्यूटर विज्ञान) का भी उपयोग किया जा सकता है। हालाँकि, मैक्रोज़ आसानी से वेरिएबल कैप्चर की समस्या से नहीं बच सकते हैं; उनके परिणामस्वरूप बड़ी मात्रा में डुप्लिकेट कोड भी हो सकता है, जो कि एक कंपाइलर के लिए अनुकूलित करना अधिक कठिन हो सकता है। मैक्रोज़ आमतौर पर दृढ़ता से टाइप नहीं किए जाते हैं, हालांकि वे दृढ़ता से टाइप किए गए कोड का उत्पादन कर सकते हैं।

डायनेमिक कोड मूल्यांकन
अन्य अनिवार्य प्रोग्रामिंग भाषाओं में, मूल्यांकन के दायरे में गतिशील रूप से निष्पादित कोड (कभी-कभी Eval या निष्पादन संचालन कहा जाता है) द्वारा उच्च-क्रम के कार्यों के माध्यम से प्राप्त किए गए समान एल्गोरिथम परिणामों में से कुछ को प्राप्त करना संभव है। इस दृष्टिकोण में महत्वपूर्ण कमियां हो सकती हैं:
 * निष्पादित किया जाने वाला तर्क कोड आमतौर पर टाइप सिस्टम # स्टेटिक टाइपिंग नहीं है; निष्पादित किए जाने वाले कोड की सुगठितता और सुरक्षा निर्धारित करने के लिए ये भाषाएं आम तौर पर टाइप सिस्टम#डायनेमिक टाइपिंग पर निर्भर करती हैं।
 * तर्क आमतौर पर एक स्ट्रिंग के रूप में प्रदान किया जाता है, जिसका मूल्य रन-टाइम तक ज्ञात नहीं हो सकता है। इस स्ट्रिंग को या तो प्रोग्राम के निष्पादन के दौरान संकलित किया जाना चाहिए (समय-समय पर संकलन का उपयोग करके) या दुभाषिया (कंप्यूटिंग) द्वारा मूल्यांकन किया जाना चाहिए, जिससे रन-टाइम पर कुछ अतिरिक्त ओवरहेड होता है, और आमतौर पर कम कुशल कोड उत्पन्न होता है।

वस्तुएँ
वस्तु-उन्मुख प्रोग्रामिंग भाषाओं में जो उच्च-क्रम के कार्यों का समर्थन नहीं करते हैं, वस्तु (कंप्यूटर विज्ञान) एक प्रभावी विकल्प हो सकता है। एक वस्तु की विधि (कंप्यूटर विज्ञान) कार्यों की तरह सार में कार्य करती है, और एक विधि वस्तुओं को मापदंडों के रूप में स्वीकार कर सकती है और वस्तुओं को रिटर्न मान के रूप में उत्पन्न कर सकती है। शुद्ध कार्यों की तुलना में वस्तुओं में अक्सर जोड़ा गया रन-टाइम ओवरहेड होता है, हालांकि, और किसी वस्तु और उसकी विधि को परिभाषित करने और तत्काल करने के लिए बॉयलरप्लेट कोड जोड़ा जाता है। स्टैक-आधारित मेमोरी आवंटन-आधारित (डायनेमिक मेमोरी आवंटन-आधारित बनाम) ऑब्जेक्ट्स या रिकॉर्ड (कंप्यूटर विज्ञान) की अनुमति देने वाली भाषाएं इस पद्धति के साथ अधिक लचीलापन प्रदान कर सकती हैं।

फ़्री पास्कल में एक फंक्शन के साथ एक साधारण स्टैक आधारित रिकॉर्ड का उपयोग करने का एक उदाहरण जो एक फंक्शन लौटाता है:

<वाक्यविन्यास लैंग = पास्कल> कार्यक्रम का उदाहरण;

प्रकार इंट = पूर्णांक; Txy = रिकॉर्ड x, y: int; अंत; Tf = फ़ंक्शन (xy: Txy): int; फलन f(xy: Txy): int; शुरू परिणाम := xy.y + xy.x; अंत;

फ़ंक्शन जी (फंक: टीएफ): टीएफ; शुरू परिणाम := func; अंत;

वर ए: टीएफ; xy: Txy = (x: 3; y: 7);

शुरू ए: = जी (@ एफ); // एक फ़ंक्शन को वापस करें राइटलन (ए (एक्सवाई)); // प्रिंट 10 अंत। </वाक्यविन्यास हाइलाइट>

कार्यक्रम  लिया जाता है एक   रिकॉर्ड इनपुट के रूप में और रिकॉर्ड के योग का पूर्णांक मान लौटाता है   और   फ़ील्ड्स (3 + 7)।

निष्क्रियता
डिफंक्शनलाइजेशन का उपयोग उन भाषाओं में उच्च-क्रम के कार्यों को लागू करने के लिए किया जा सकता है जिनमें प्रथम श्रेणी के कार्यों की कमी होती है | प्रथम श्रेणी के कार्य:

<वाक्यविन्यास लैंग = सीपीपी> // निष्क्रिय फ़ंक्शन डेटा संरचनाएं टेम्प्लेट <टाइपनेम टी> स्ट्रक्चर एड {टी वैल्यू; }; टेम्प्लेट <टाइपनेम टी> स्ट्रक्चर डिवबी {टी वैल्यू; }; टेम्पलेट <टाइपनाम एफ, टाइपनाम जी> संरचना संरचना {एफ एफ; जी जी; };

// डिफंक्शनलाइज्ड फंक्शन एप्लीकेशन इम्प्लीमेंटेशन टेम्पलेट <टाइपनाम एफ, टाइपनाम जी, टाइपनाम एक्स> स्वतः लागू (रचना <F, G> f, X arg) { रिटर्न अप्लाई (f.f, अप्लाई (f.g, arg)); }

टेम्पलेट <टाइपनाम टी, टाइपनाम एक्स> स्वतः लागू (जोड़ें <टी> एफ, एक्स तर्क) { वापसी तर्क + f.value; }

टेम्पलेट <टाइपनाम टी, टाइपनाम एक्स> स्वतः लागू (DivBy<T> f, X arg) { वापसी तर्क / f.value; }

// हायर-ऑर्डर कंपोज़ फंक्शन टेम्पलेट <टाइपनाम एफ, टाइपनाम जी> रचना<F, G> रचना(F f, G g) { वापसी संरचना <एफ, जी> {एफ, जी}; }

int main(int argc, const char* argv[]) { ऑटो f = लिखें (DivBy<फ्लोट>{2.0f}, जोड़ें {5}); लागू करें (एफ, 3); // 4.0f लागू करें (एफ, 9); // 7.0 एफ वापसी 0; } </वाक्यविन्यास हाइलाइट>

इस मामले में, समारोह अधिभार के माध्यम से विभिन्न कार्यों को ट्रिगर करने के लिए विभिन्न प्रकारों का उपयोग किया जाता है। इस उदाहरण में अतिभारित कार्य में हस्ताक्षर हैं.

यह भी देखें

 * प्रथम श्रेणी समारोह
 * संयुक्त तर्क
 * फंक्शन-लेवल प्रोग्रामिंग
 * कार्यात्मक प्रोग्रामिंग
 * कप्पा कलन - कार्यों के लिए एक औपचारिकता जो उच्च-क्रम के कार्यों को बाहर करती है
 * रणनीति पैटर्न
 * उच्च आदेश संदेश