ऐरे ऑपरेशन

निर्देश

ऐरे के बुनियादी ऑपरेशन लागू कीजिए।

फंक्शनल भाषाओं में length, map और reduce जैसे ऐरे ऑपरेशन बहुत आम हैं। पहले से मौजूद फंक्शन इस्तेमाल किए बिना बुनियादी ऐरे ऑपरेशनों की एक श्रृंखला लागू कीजिए।

लागू किए जाने वाले ऑपरेशनों की सही संख्या और नाम इस बात पर निर्भर करते हैं कि आप किस ट्रैक पर हैं, ताकि मौजूदा नामों से टकराव न हो। आम तौर पर आपको जो ऑपरेशन लागू करने होंगे, उनमें ये शामिल हैं:

• append (दो ऐरे दिए जाने पर, दूसरे ऐरे के सारे एलिमेंट पहले ऐरे के अंत में जोड़िए);
• concatenate (ऐरों की एक श्रृंखला दिए जाने पर, सभी ऐरों के सारे एलिमेंट मिलाकर एक ही समतल ऐरे बनाइए);
• filter (एक प्रेडिकेट और एक ऐरे दिए जाने पर, वे सारे एलिमेंट वाला ऐरे लौटाइए जिनके लिए predicate(item) सही होता है);
• length (एक ऐरे दिए जाने पर, उसमें मौजूद कुल एलिमेंट की संख्या लौटाइए);
• map (एक फंक्शन और एक ऐरे दिए जाने पर, हर एलिमेंट पर function(item) लागू करने के नतीजों वाला ऐरे लौटाइए);
• foldl (एक फंक्शन, एक ऐरे और शुरुआती एक्युमुलेटर दिए जाने पर, हर एलिमेंट को बाईं ओर से एक्युमुलेटर में फोल्ड (रिड्यूस) कीजिए);
• foldr (एक फंक्शन, एक ऐरे और एक शुरुआती एक्युमुलेटर दिए जाने पर, हर एलिमेंट को दाईं ओर से एक्युमुलेटर में फोल्ड (रिड्यूस) कीजिए);
• reverse (एक ऐरे दिए जाने पर, एक ऐसा ऐरे लौटाइए जिसमें सारे मूल एलिमेंट हों, लेकिन उलटे क्रम में)।

ध्यान रखिए कि फोल्ड फंक्शनों (foldl, foldr) को आर्गुमेंट किस क्रम में दिए जाते हैं, यह महत्वपूर्ण है।

रुकिए, यह तो असंभव है!

Roc में इन ऐरे ऑपरेशनों को बिना किसी भी बिल्ट-इन फंक्शन का उपयोग किए लागू करना लगभग असंभव है, क्योंकि आपको ऐरे के अंत में या शुरू में एलिमेंट जोड़ने का कोई तरीका चाहिए होता है। दूसरी भाषाओं में आप Haskell के : या Python के += जैसे ऑपरेटर इस्तेमाल कर सकते हैं, लेकिन Roc में आपको List फंक्शन ही इस्तेमाल करने पड़ते हैं।

तो इस अभ्यास में आप List.append इस्तेमाल कर सकते हैं (लेकिन किसी और बिल्ट-इन फंक्शन का उपयोग करने से बचिए)।

बहुत सी फंक्शनल प्रोग्रामिंग भाषाएँ मुख्य संग्रह टाइप के रूप में लिंक्ड लिस्ट इस्तेमाल करती हैं। लिंक्ड लिस्ट में एलिमेंट को शुरू में जोड़ना या पहला एलिमेंट निकालना कुशल होता है, इसलिए उन भाषाओं में आप ऐरे ऑपरेशन List.prepend से लागू करते हैं। लेकिन Roc में List एक ऐरे होता है (बाइट्स का एक लगातार टुकड़ा)। ऐरे की विशेषताएँ लिंक्ड लिस्ट से अलग होती हैं, जैसे कि इंडेक्स के ज़रिए एलिमेंट तक कुशलता से पहुँचने और नए एलिमेंट जोड़ने की क्षमता। इसी वजह से Roc में हम List.append का इस्तेमाल अक्सर करते हैं और List.prepend का इस्तेमाल कम करते हैं।

नामकरण

Roc में सामान्य निर्देशों में दिए गए नामों से थोड़े अलग नाम इस्तेमाल होते हैं:

• append के बजाय concat
• concatenate के बजाय join
• length के बजाय len
• foldl के बजाय fold
• foldr के बजाय fold_rev

लेकिन Roc में ये फंक्शन नाम मानक हैं:

• filter
• map
• reverse

संकेत

यह आज़माकर देखिए:

match list {
    [] => ...
    [first, .. as rest] => ...
}

या

match list {
    [] => ...
    [.. as rest, last] => ...
}