उच्च-क्रम फलन
गणित और कंप्यूटर विज्ञान में, एक उच्च-क्रम फ़ंक्शन (HOF) एक फ़ंक्शन (गणित) है जो निम्न में से कम से कम एक कार्य करता है:
- तर्क के रूप में एक या एक से अधिक कार्य करता है (यानी एक प्रक्रियात्मक पैरामीटर, जो एक उपनेमका का एक पैरामीटर (कंप्यूटर विज्ञान) है जो स्वयं एक प्रक्रिया है),
- इसके परिणाम के रूप में एक समारोह देता है।
अन्य सभी कार्य प्रथम क्रम के कार्य हैं। गणित में उच्च-क्रम के कार्यों को संचालक (गणित) या कार्यात्मक (गणित) भी कहा जाता है। गणना में अंतर ऑपरेटर एक सामान्य उदाहरण है, क्योंकि यह एक फ़ंक्शन को इसके व्युत्पन्न के लिए मैप करता है, यह एक फ़ंक्शन भी है। पूरे गणित में फ़ंक्टर शब्द के अन्य उपयोगों के साथ उच्च-क्रम के कार्यों को भ्रमित नहीं किया जाना चाहिए, फ़ंक्टर (बहुविकल्पी) देखें।
अनटाइप्ड लैम्ब्डा कैलकुलस में, सभी फंक्शन उच्च-क्रम वाले होते हैं; एक टाइप किए गए लैम्ब्डा कैलकुस में, जिसमें से अधिकांश कार्यात्मक प्रोग्रामिंग भाषाएं व्युत्पन्न होती हैं, उच्च-क्रम के फ़ंक्शन जो एक फ़ंक्शन को तर्क के रूप में लेते हैं, फॉर्म के प्रकारों के साथ मान होते हैं .
सामान्य उदाहरण
mapफ़ंक्शन, कई कार्यात्मक प्रोग्रामिंग भाषाओं में पाया जाता है, उच्च-क्रम फ़ंक्शन का एक उदाहरण है। यह तर्क के रूप में एक फ़ंक्शन f और तत्वों का एक संग्रह लेता है, और परिणामस्वरूप, संग्रह से प्रत्येक तत्व पर लागू f के साथ एक नया संग्रह देता है।- सॉर्टिंग फ़ंक्शंस, जो एक तुलना फ़ंक्शन को एक पैरामीटर के रूप में लेते हैं, प्रोग्रामर को सॉर्टिंग एल्गोरिथ्म को सॉर्ट किए जा रहे आइटमों की तुलना से अलग करने की अनुमति देता है। सी (प्रोग्रामिंग भाषा) मानक समारोह (कंप्यूटर विज्ञान)
qsortइसका एक उदाहरण है। - फ़िल्टर (उच्च-क्रम फ़ंक्शन)
- गुना (उच्च-क्रम समारोह)
- आवेदन करना
- फंक्शन रचना (कंप्यूटर विज्ञान)
- अभिन्न
- कॉलबैक (कंप्यूटर प्रोग्रामिंग)
- ट्री ट्रैवर्सल
- मोंटेग व्याकरण, प्राकृतिक भाषा का एक सिमेंटिक सिद्धांत, उच्च-क्रम के कार्यों का उपयोग करता है
प्रोग्रामिंग भाषाओं में समर्थन
प्रत्यक्ष समर्थन
उदाहरणों का उद्देश्य प्रोग्रामिंग भाषाओं की तुलना और तुलना करना नहीं है, बल्कि उच्च-क्रम फ़ंक्शन सिंटैक्स के उदाहरण के रूप में काम करना है
निम्नलिखित उदाहरणों में, उच्च-क्रम फ़ंक्शन twice एक फ़ंक्शन लेता है, और फ़ंक्शन को दो बार कुछ मान पर लागू करता है। अगर twice इसके लिए कई बार आवेदन करना पड़ता है f यह अधिमानतः एक मूल्य के बजाय एक फ़ंक्शन वापस करना चाहिए। यह स्वयं को न दोहराने के सिद्धांत के अनुरूप है।
एपीएल
twice←{⍺⍺ ⍺⍺ ⍵}
plusthree←{⍵+3}
g←{plusthree twice ⍵}
g 7
13
Or in a tacit manner:
twice←⍣2
plusthree←+∘3
g←plusthree twice
g 7
13
सी++==
का उपयोग करते हुए std::function सी ++ 11 में:
#include <iostream>
#include <functional>
auto twice = [](const std::function<int(int)>& f)
{
return [f](int x) {
return f(f(x));
};
};
auto plus_three = [](int i)
{
return i + 3;
};
int main()
{
auto g = twice(plus_three);
std::cout << g(7) << '\n'; // 13
}
Or, with generic lambdas provided by C++14:
#include <iostream>
auto twice = [](const auto& f)
{
return [f](int x) {
return f(f(x));
};
};
auto plus_three = [](int i)
{
return i + 3;
};
int main()
{
auto g = twice(plus_three);
std::cout << g(7) << '\n'; // 13
}
}
C#
Using just delegates:
using 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
}
}
Or equivalently, with static methods:
using 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
}
}
क्लोजर
(defn twice [f]
(fn [x] (f (f x))))
(defn plus-three [i]
(+ i 3))
(def g (twice plus-three))
(println (g 7)) ; 13
कोल्ड फ्यूजन मार्कअप लैंग्वेज (CFML)
twice = function(f) {
return function(x) {
return f(f(x));
};
};
plusThree = function(i) {
return i + 3;
};
g = twice(plusThree);
writeOutput(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))
डी==
import std.stdio : writeln;
alias twice = (f) => (int x) => f(f(x));
alias plusThree = (int i) => i + 3;
void main()
{
auto g = twice(plusThree);
writeln(g(7)); // 13
}
डार्ट
int Function(int) twice(int Function(int) f) {
return (x) {
return f(f(x));
};
}
int plusThree(int i) {
return i + 3;
}
void main() {
final g = twice(plusThree);
print(g(7)); // 13
}
अमृत
अमृत में, आप मॉड्यूल परिभाषाओं और अनाम कार्यों को मिला सकते हैं
defmodule Hof do
def twice(f) do
fn(x) -> f.(f.(x)) end
end
end
plus_three = fn(i) -> 3 + i end
g = Hof.twice(plus_three)
IO.puts g.(7) # 13
वैकल्पिक रूप से, हम शुद्ध अनाम कार्यों का उपयोग करके रचना भी कर सकते हैं।
twice = fn(f) ->
fn(x) -> f.(f.(x)) end
end
plus_three = fn(i) -> 3 + i end
g = twice.(plus_three)
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). यह फ़ंक्शन का मूल्यांकन करता है F तर्क के साथ X तर्क के रूप में। यदि समारोह F झूठा लौटाता है फिर अगला कार्य करता है Fs मूल्यांकन किया जाएगा। यदि समारोह F रिटर्न {false, Y} फिर अगला समारोह में Fs तर्क के साथ Y मूल्यांकन किया जाएगा। यदि समारोह F रिटर्न R उच्च-क्रम समारोह or_else/2 वापसी करेंगे R. ध्यान दें कि X, Y, और R कार्य हो सकते हैं। उदाहरण लौटता है false.
एफ#
let twice f = f >> f
let plus_three = (+) 3
let g = twice plus_three
g 7 |> printf "%A" // 13
जाओ
package main
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).
हास्केल
twice :: (Int -> Int) -> (Int -> Int)
twice f = f . f
plusThree :: Int -> Int
plusThree = (+3)
main :: IO ()
main = print (g 7) -- 13
where
g = twice plusThree
जे
स्पष्ट रूप से,
twice=. adverb : 'u u y'
plusthree=. verb : 'y + 3'
g=. plusthree twice
g 7
13
या चुपचाप,
twice=. ^:2
plusthree=. +&3
g=. plusthree twice
g 7
13
जावा (1.8+)
केवल कार्यात्मक इंटरफेस का उपयोग करना:
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
जूलिया
julia> function twice(f)
function result(x)
return f(f(x))
end
return result
end
twice (generic function with 1 method)
julia> plusthree(i) = i + 3
plusthree (generic function with 1 method)
julia> g = twice(plusthree)
(::var"#result#3"{typeof(plusthree)}) (generic function with 1 method)
julia> g(7)
13
कोटलिन
fun twice(f: (Int) -> Int): (Int) -> Int {
return { f(f(it)) }
}
fun plusThree(i: Int) = i + 3
fun main() {
val g = twice(::plusThree)
println(g(7)) // 13
}
दो
function twice(f)
return function (x)
return f(f(x))
end
end
function plusThree(i)
return i + 3
end
local g = twice(plusThree)
print(g(7)) -- 13
मतलब
function result = twice(f)
result = @inner
function val = inner(x)
val = f(f(x));
end
end
plusthree = @(i) i + 3;
g = twice(plusthree)
disp(g(7)); % 13
ओकैमल
let twice f x =
f (f x)
let plus_three =
(+) 3
let () =
let g = twice plus_three in
print_int (g 7); (* 13 *)
print_newline ()
पीएचपी ==
<वाक्यविन्यास लैंग = 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 </वाक्यविन्यास हाइलाइट>
ध्यान दें कि एरो फ़ंक्शंस मूल रूप से पैरेंट स्कोप से आने वाले किसी भी वेरिएबल को कैप्चर करता है,[1] जबकि अनाम कार्यों की आवश्यकता होती है 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]}}
- परिणाम: 13
पुट [लागू $दो बार $ प्लस तीन 7] </वाक्यविन्यास हाइलाइट> अनाम फ़ंक्शन (8.6 के बाद से) को लागू करने के लिए टीसीएल लागू कमांड का उपयोग करता है।
XACML
XACML मानक विशेषता बैग के एकाधिक मानों पर फ़ंक्शन लागू करने के लिए मानक में उच्च-क्रम फ़ंक्शन को परिभाषित करता है।
<वाक्यविन्यास लैंग = xquery> नियम अनुमति प्रवेश {
आज्ञा देना किसी भी स्थिति में (फ़ंक्शन [स्ट्रिंगइक्वल], नागरिकता, अनुमत नागरिकता)
} </वाक्यविन्यास हाइलाइट>
XACML में उच्च-क्रम के कार्यों की सूची XACML# उच्च क्रम के कार्यों को मिल सकती है।
एक्सक्वायरी
<वाक्यविन्यास लैंग = xquery> फ़ंक्शन को स्थानीय घोषित करें: दो बार ($ f, $ x) {
$f($f($x))
};
फ़ंक्शन स्थानीय घोषित करें: प्लसथ्री ($ i) {
$ आई + 3
};
स्थानीय: दो बार (स्थानीय: plusthree#1, 7) (: 13 :) </वाक्यविन्यास हाइलाइट>
विकल्प
फंक्शन पॉइंटर
C (प्रोग्रामिंग लैंग्वेज), C++, और पास्कल (प्रोग्रामिंग भाषा) जैसी भाषाओं में फंक्शन पॉइंटर्स प्रोग्रामर्स को फंक्शन्स के संदर्भ में पास करने की अनुमति देते हैं। निम्नलिखित सी कोड एक मनमानी समारोह के अभिन्न अंग के अनुमान की गणना करता है:
<वाक्यविन्यास प्रकाश लैंग = सी>
- शामिल <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
अंत। </वाक्यविन्यास हाइलाइट>
कार्यक्रम a() लिया जाता है एक Txy रिकॉर्ड इनपुट के रूप में और रिकॉर्ड के योग का पूर्णांक मान लौटाता है x और y फ़ील्ड्स (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}, जोड़ें<int>{5});
लागू करें (एफ, 3); // 4.0f
लागू करें (एफ, 9); // 7.0 एफ
वापसी 0;
} </वाक्यविन्यास हाइलाइट>
इस मामले में, समारोह अधिभार के माध्यम से विभिन्न कार्यों को ट्रिगर करने के लिए विभिन्न प्रकारों का उपयोग किया जाता है। इस उदाहरण में अतिभारित कार्य में हस्ताक्षर हैं auto apply.
यह भी देखें
- प्रथम श्रेणी समारोह
- संयुक्त तर्क
- फंक्शन-लेवल प्रोग्रामिंग
- कार्यात्मक प्रोग्रामिंग
- कप्पा कलन - कार्यों के लिए एक औपचारिकता जो उच्च-क्रम के कार्यों को बाहर करती है
- रणनीति पैटर्न
- उच्च आदेश संदेश
संदर्भ
- ↑ "PHP: Arrow Functions - Manual". www.php.net. Retrieved 2021-03-01.
