हाई स्कूल का प्यार

Julia प्रोग्रामरों को प्रोत्साहित करती है कि वे ज़्यादा से ज़्यादा कोड ऐसे फंक्शनों के अंदर डालें जिन्हें JIT-कंपाइल किया जा सके, और कई छोटे फंक्शन बनाना डिज़ाइन से ही अच्छा प्रदर्शन देता है।

इससे अक्सर कई छोटे, सरल फंक्शन बन जाते हैं, जिन्हें साधारण से आगे के कामों के लिए जोड़ना पड़ता है।

एक स्पष्ट तरीका है फंक्शन कॉल को नेस्ट करना। नीचे दिया उदाहरण बहुत बनावटी है, लेकिन बात समझाता है।

julia> first.(titlecase.(reverse.(["my", "test", "strings"])))
3-element Vector{Char}:
 'Y': ASCII/Unicode U+0059 (category Lu: Letter, uppercase)
 'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase)
 'S': ASCII/Unicode U+0053 (category Lu: Letter, uppercase)

इस तरीके का नुकसान यह है कि जैसे-जैसे नेस्टिंग गहरी होती जाती है, पढ़ने में आसानी तेज़ी से घटती जाती है।

हमें एक सरल और ज़्यादा लचीले तरीके की ज़रूरत है।

कंपोज़िशन

यह तकनीक गणितज्ञों को बहुत भाती है, और Julia गणितीय सिंटैक्स की नकल करती है।

किसी भी संख्या में फंक्शनों को ∘ ऑपरेटरों के साथ composed किया जा सकता है (\circ लिखकर टैब दबाइए)। परिणाम को एक अकेले फंक्शन की तरह इस्तेमाल किया जा सकता है।

julia> compfunc = first ∘ titlecase ∘ reverse
first ∘ titlecase ∘ reverse
julia> compfunc.(["my", "test", "strings"])
3-element Vector{Char}:
 'Y': ASCII/Unicode U+0059 (category Lu: Letter, uppercase)
 'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase)
 'S': ASCII/Unicode U+0053 (category Lu: Letter, uppercase)
# alternative syntax, giving the same result
julia> (first ∘ titlecase ∘ reverse).(["my", "test", "strings"])

ध्यान देने योग्य कुछ बातें:

• शुरुआती फंक्शन उसी क्रम में आते हैं जैसे नेस्टिंग में, और दाएँ से बाएँ क्रम में चलाए जाते हैं।
• कंपोज़ करते समय ब्रॉडकास्टिंग का इस्तेमाल करना आसान नहीं है, लेकिन कंपोज़ किए गए फंक्शन को कॉल करते समय इसे लगाया जा सकता है।

पाइपलाइनिंग

एक विकल्प को प्रोग्रामरों का तरीका माना जा सकता है, न कि गणितज्ञों का।

Pipelines का इस्तेमाल Unix शेल स्क्रिप्ट में लंबे समय से होता आया है, और हाल में मुख्यधारा की प्रोग्रामिंग भाषाओं में लोकप्रिय हुए हैं (F# को कभी-कभी इन्हें अपनाने का अग्रणी माना जाता है)।

मूल विचार यह है कि कुछ डेटा से शुरू कीजिए, फिर परिणाम पाने के लिए उसे फंक्शनों के एक क्रम से गुज़ारिए।

पाइप ऑपरेटर |> है (जैसे F# और R के हाल के वर्शनों में), हालाँकि Julia में एक ब्रॉडकास्ट वर्शन .|> भी है।

julia> ["my", "test", "strings"] .|> reverse .|> titlecase .|> first
3-element Vector{Char}:
 'Y': ASCII/Unicode U+0059 (category Lu: Letter, uppercase)
 'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase)
 'S': ASCII/Unicode U+0053 (category Lu: Letter, uppercase)

अब चलना सख्ती से बाएँ से दाएँ होता है, हर फंक्शन का आउटपुट तीर की दिशा में बहकर अगले फंक्शन का इनपुट बन जाता है।

सीमाएँ, वर्कअराउंड और अन्य विकल्प

यह कोई संयोग नहीं है कि कंपोज़िशन और पाइपलाइनिंग को समझाने वाले सभी फंक्शन एक ही आर्गुमेंट लेते हैं।

कुछ शुद्ध-फंक्शनल भाषाएँ पहले आर्गुमेंट को फंक्शन में पाइप करती हैं, लेकिन बाकी आर्गुमेंट भी शामिल करने देती हैं।

इसके उलट, Julia एक पाइपलाइन में सिर्फ फंक्शनों के नाम (या उसके बराबर कुछ) की अपेक्षा करती है, बिना किसी अतिरिक्त आर्गुमेंट के।

इसके पीछे ज़रूरी तकनीकी कारण हैं (यह इस तथ्य से जुड़ा है कि currying भाषा के डिज़ाइन का मानक हिस्सा नहीं है)। जिन बहुत से लोगों को करीइंग की समझ नहीं है, उन्हें बस यह मान लेना चाहिए कि यह सीमा लापरवाही से की गई अनदेखी नहीं है, और भविष्य के Julia वर्शनों में इसके बदलने की संभावना नहीं है।

वर्कअराउंड

हमें ऐसे फंक्शन चाहिए जो एक ही आर्गुमेंट लें और जो ज़रूरत हो वह करें। अच्छी बात है कि Julia में नए फंक्शन बनाना आसान है।

सबसे आसान तरीका यह है कि हम एक anonymous function इस्तेमाल करें। उदाहरण के लिए, अगर हमारे पास एक इनपुट स्ट्रिंग है और हम उसे अंडरस्कोर पर तोड़ना चाहते हैं:

julia> "my_test_strings" |> (s -> split(s, '_'))
3-element Vector{SubString{String}}:
 "my"
 "test"
 "strings"

उस वेक्टर को फिर पहले की तरह दूसरे फंक्शनों में पाइप किया जा सकता है।

इस मामले में अनाम फंक्शन को कोष्ठकों में लगाना वैकल्पिक है, लेकिन आम तौर पर यह अस्पष्टता कम करने का उपयोगी तरीका है।

उसी तरह, हम प्रोग्राम में पहले ही एक नाम वाला फंक्शन बना सकते हैं और ज़रूरत के हिसाब से उसे दोबारा इस्तेमाल कर सकते हैं।