Julia Language
बंद

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

• x -> [शरीर]
• (x, y) -> [शरीर]
• (xs ...) -> [शरीर]

टिप्पणियों

समारोह रचना

हम प्रदर्शन करने के लिए एक समारोह को परिभाषित कर सकते समारोह रचना का उपयोग कर अज्ञात फ़ंक्शन वाक्य रचना :

f ∘ g = x -> f(g(x))

ध्यान दें कि यह परिभाषा निम्नलिखित परिभाषाओं में से प्रत्येक के बराबर है:

∘(f, g) = x -> f(g(x))

या

function ∘(f, g)
    x -> f(g(x))
end

यह याद करते हुए कि जूलिया में, f ∘ g is f ∘ g ∘(f, g) लिए सिंटेक्स चीनी है।

हम देख सकते हैं कि यह फ़ंक्शन सही ढंग से रचना करता है:

julia> double(x) = 2x
double (generic function with 1 method)

julia> triple(x) = 3x
triple (generic function with 1 method)

julia> const sextuple = double ∘ triple
(::#17) (generic function with 1 method)

julia> sextuple(1.5)
9.0

julia> @code_llvm sextuple(1)

define i64 @"julia_#17_71238"(i64) #0 {
top:
  %1 = mul i64 %0, 6
  ret i64 %1
}

यह उच्च-क्रम फ़ंक्शन कैसे काम करता है? यह एक तथाकथित बंद बनाता है, जिसमें न केवल इसका कोड होता है, बल्कि इसके दायरे से कुछ चर भी होते हैं। जूलिया में सभी कार्य जो शीर्ष स्तर के दायरे में नहीं बने हैं, वे बंद हैं।

julia> (sin ∘ cos).f
sin (generic function with 10 methods)

julia> (sin ∘ cos).g
cos (generic function with 10 methods)

क्युरिंग लागू करना

क्लोजर का एक आवेदन आंशिक रूप से एक फ़ंक्शन लागू करना है; यही है, अब कुछ तर्क प्रदान करें और एक फ़ंक्शन बनाएं जो शेष तर्कों को लेता है। करी आंशिक अनुप्रयोग का एक विशिष्ट रूप है।

आइए सरल फ़ंक्शन curry(f, x) जो एक फ़ंक्शन को पहला तर्क प्रदान करेगा, और बाद में अतिरिक्त तर्क की उम्मीद करेगा। परिभाषा काफी सीधी है:

curry(f, x) = (xs...) -> f(x, xs...)

एक बार फिर, हम अनाम फ़ंक्शन सिंटैक्स का उपयोग करते हैं , इस बार वेरिएडिक तर्क सिंटैक्स के संयोजन में।

हम इस curry फ़ंक्शन का उपयोग करके कुछ बुनियादी कार्यों को टैसिट (या बिंदु-मुक्त) शैली में लागू कर सकते हैं।

julia> const double = curry(*, 2)
(::#19) (generic function with 1 method)

julia> double(10)
20

julia> const simon_says = curry(println, "Simon: ")
(::#19) (generic function with 1 method)

julia> simon_says("How are you?")
Simon: How are you?

कार्य अपेक्षित उदारता बनाए रखते हैं:

julia> simon_says("I have ", 3, " arguments.")
Simon: I have 3 arguments.

julia> double([1, 2, 3])
3-element Array{Int64,1}:
 2
 4
 6

क्लोजर का परिचय

कार्य जूलिया प्रोग्रामिंग का एक महत्वपूर्ण हिस्सा हैं। उन्हें सीधे मॉड्यूल के भीतर परिभाषित किया जा सकता है, जिस स्थिति में फ़ंक्शन को शीर्ष-स्तर के रूप में संदर्भित किया जाता है । लेकिन कार्यों को अन्य कार्यों के भीतर भी परिभाषित किया जा सकता है। ऐसे कार्यों को " क्लोजर " कहा जाता है।

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

x = 0  # global
function toplevel(y)
    println("x = ", x, " is a global variable")
    println("y = ", y, " is a parameter")
    z = 2
    println("z = ", z, " is a local variable")
end

दूसरी ओर, एक बंद, बाहरी कार्यों से चर के अलावा उन सभी का उपयोग कर सकता है जो इसे कैप्चर करते हैं:

x = 0  # global
function toplevel(y)
    println("x = ", x, " is a global variable")
    println("y = ", y, " is a parameter")
    z = 2
    println("z = ", z, " is a local variable")

    function closure(v)
        println("v = ", v, " is a parameter")
        w = 3
        println("w = ", w, " is a local variable")
        println("x = ", x, " is a global variable")
        println("y = ", y, " is a closed variable (a parameter of the outer function)")
        println("z = ", z, " is a closed variable (a local of the outer function)")
    end
end

यदि हम c = toplevel(10) चलाते हैं, तो हम देखते हैं कि परिणाम क्या है

julia> c = toplevel(10)
x = 0 is a global variable
y = 10 is a parameter
z = 2 is a local variable
(::closure) (generic function with 1 method)

ध्यान दें कि इस फ़ंक्शन की पूंछ अभिव्यक्ति अपने आप में एक फ़ंक्शन है; यह एक बंद है। हम क्लोजर c को कॉल कर सकते हैं जैसे कि यह कोई अन्य फ़ंक्शन था:

julia> c(11)
v = 11 is a parameter
w = 3 is a local variable
x = 0 is a global variable
y = 10 is a closed variable (a parameter of the outer function)
z = 2 is a closed variable (a local of the outer function)

ध्यान दें कि c अभी भी toplevel कॉल से चर y और z तक toplevel - भले ही toplevel पहले ही वापस आ गया हो! प्रत्येक बंद, यहां तक कि एक ही फ़ंक्शन द्वारा लौटाए गए, विभिन्न चर पर बंद हो जाते हैं। हम फिर से toplevel कह सकते हैं

julia> d = toplevel(20)
x = 0 is a global variable
y = 20 is a parameter
z = 2 is a local variable
(::closure) (generic function with 1 method)

julia> d(22)
v = 22 is a parameter
w = 3 is a local variable
x = 0 is a global variable
y = 20 is a closed variable (a parameter of the outer function)
z = 2 is a closed variable (a local of the outer function)

julia> c(22)
v = 22 is a parameter
w = 3 is a local variable
x = 0 is a global variable
y = 10 is a closed variable (a parameter of the outer function)
z = 2 is a closed variable (a local of the outer function)

ध्यान दें कि एक ही कोड होने के बावजूद d और c , और समान तर्क पास किए जाने के बावजूद, उनका आउटपुट अलग है। वे अलग-अलग क्लोजर हैं।