Julia Language
उच्च-क्रम के कार्य

वाक्य - विन्यास

• foreach (f, xs)
• नक्शा (f, xs)
• फ़िल्टर (f, xs)
• कम करना (f, v0, xs)
• तह (एफ, वी 0, एक्स)
• तह (एफ, वी 0, एक्स)

टिप्पणियों

तर्क के रूप में कार्य

जूलिया में फंक्शंस ऑब्जेक्ट हैं। किसी भी अन्य वस्तुओं की तरह, उन्हें अन्य कार्यों के लिए तर्क के रूप में पारित किया जा सकता है। फ़ंक्शंस को स्वीकार करने वाले फ़ंक्शंस को उच्च-ऑर्डर फ़ंक्शंस के रूप में जाना जाता है।

उदाहरण के लिए, हम पहले पैरामीटर के रूप में एक फंक्शन f लेकर मानक लाइब्रेरी के foreach फंक्शन के बराबर को लागू कर सकते हैं।

function myforeach(f, xs)
    for x in xs
        f(x)
    end
end

हम परीक्षण कर सकते हैं कि यह फ़ंक्शन वास्तव में उसी तरह काम करता है जैसा हम उम्मीद करते हैं:

julia> myforeach(println, ["a", "b", "c"])
a
b
c

पहले पैरामीटर के रूप में एक फ़ंक्शन लेने के बाद, बाद के पैरामीटर के बजाय, हम जूलिया के ब्लॉक सिंटैक्स का उपयोग कर सकते हैं। किसी फ़ंक्शन को पहले तर्क के रूप में अनाम फ़ंक्शन पास करने के लिए ब्लॉक सिंटैक्स केवल एक सुविधाजनक तरीका है।

julia> myforeach([1, 2, 3]) do x
           println(x^x)
       end
1
4
27

ऊपर myforeach का हमारा कार्यान्वयन बिल्ट-इन foreach फ़ंक्शन के लगभग बराबर है। कई अन्य निर्मित उच्च क्रम वाले कार्य भी मौजूद हैं।

उच्च-क्रम के कार्य काफी शक्तिशाली हैं। कभी-कभी उच्च-क्रम के कार्यों के साथ काम करते समय, निष्पादित किए जा रहे सटीक संचालन महत्वहीन हो जाते हैं और कार्यक्रम काफी सार हो सकते हैं। संयोजक उच्च अमूर्त उच्च-क्रम कार्यों की प्रणालियों के उदाहरण हैं।

मानचित्र, फ़िल्टर और कम करें

मानक पुस्तकालय में शामिल सबसे मौलिक उच्च-क्रम के दो कार्य map और filter । इन कार्यों सामान्य हैं और किसी भी पर काम कर सकते हैं iterable । विशेष रूप से, वे सरणियों पर गणना के लिए अच्छी तरह से अनुकूल हैं ।

मान लीजिए हमारे पास स्कूलों का एक डेटासेट है। प्रत्येक स्कूल एक विशेष विषय पढ़ाता है, इसमें कई कक्षाएं होती हैं, और प्रति कक्षा छात्रों की औसत संख्या होती है। हम निम्नलिखित अपरिवर्तनीय प्रकार के साथ एक स्कूल मॉडल कर सकते हैं:

immutable School
    subject::Symbol
    nclasses::Int
    nstudents::Int  # average no. of students per class
end

हमारे स्कूलों का डेटासेट एक Vector{School} :

dataset = [School(:math, 3, 30), School(:math, 5, 20), School(:science, 10, 5)]

मान लीजिए कि हम एक गणित कार्यक्रम में नामांकित कुल छात्रों की संख्या का पता लगाना चाहते हैं। ऐसा करने के लिए, हमें कई चरणों की आवश्यकता होती है:

• हमें केवल स्कूलों को गणित पढ़ाना होगा, जो गणित ( filter ) सिखाते हैं
• हमें प्रत्येक स्कूल में छात्रों की संख्या की गणना करनी चाहिए ( map )
• और हमें छात्रों की संख्या को एक मान से कम करना होगा, योग ( reduce )

एक भोले (सबसे अधिक नहीं) समाधान सीधे उन तीन उच्च-क्रम के कार्यों का उपयोग करना होगा।

function nmath(data)
    maths = filter(x -> x.subject === :math, data)
    students = map(x -> x.nclasses * x.nstudents, maths)
    reduce(+, 0, students)
end

और हम सत्यापित करते हैं कि हमारे डेटासेट में 190 गणित के छात्र हैं:

julia> nmath(dataset)
190

इन कार्यों को संयोजित करने के लिए कार्य मौजूद हैं और इस प्रकार प्रदर्शन में सुधार होता है। उदाहरण के लिए, हम इस्तेमाल किया जा सकता था mapreduce एक कदम है, जो समय और स्मृति की बचत होगी में मानचित्रण और कमी प्रदर्शन करने के लिए कार्य करते हैं।

reduce करना केवल + जैसे सहयोगी संचालन के लिए सार्थक है, लेकिन कभी-कभी यह गैर-सहयोगी संचालन के साथ कमी करने के लिए उपयोगी होता है। उच्च-क्रम फ़ंक्शंस foldl और foldr एक विशेष कटौती आदेश को बाध्य करने के लिए प्रदान किए foldr हैं।