🤷 😳 🐤 एर्लांग में सोचना और लिखना सीखना (उदाहरण के रूप में दो संयोजन समस्याओं का उपयोग करके) 📎 🤝 🤵🏽

- ... तो मैं उसे थूथन देता हूं ... नहीं, आप हरा नहीं सकते हैं!
"इस तथ्य का तथ्य यह है कि आप हरा नहीं सकते," पैनिकोवस्की ने पाखंडी ढंग से कहा। - बेंडर की अनुमति नहीं है।
आई। इलफ़, ई। पेट्रोव। गोल्डन बछड़ा ।

कॉलस ब्रागा एक पारदर्शी बर्तन में रहते थे और ऐसे थे
मजबूत है कि डरावनी भी। वह पेट से पसंद नहीं है - मुंह से सही
सिर पर हाथ फेरा और वहां से दूसरी तरफ फेंकना शुरू किया,
मानसिक ब्रेसिज़ और गढ़ों को तोड़ना।
एम। उसपेन्स्की। जहां हम नहीं हैं ।

शायद हर कोई जो सबसे पहले एरलांग का अध्ययन करना शुरू करता है, वह खुद को शूरा बालगानोव की स्थिति में महसूस करता है, जिसे एकमात्र सुलभ और समझने योग्य विधि का उपयोग करने के लिए मना किया गया था: "आप हरा नहीं सकते ..."। एरलैंग के पास अधिकांश आधुनिक भाषाओं की अवधारणाओं से परिचित है जैसे कि एक चर को फिर से असाइन करना और तदनुसार, एक चर में परिणाम को जमा करना। (निष्पक्षता के लिए, यह ध्यान दिया जाना चाहिए कि "ग्लोबल मल्टीपल-चेंजिंग वैरिएबल" की एरलैंग-शैली का व्यवहार अभी भी लागू किया जा सकता है। इसके लिए, प्रत्येक प्रक्रिया में एक हैश शब्दकोश होता है जो प्रोग्रामर-डिफाइन्ड की-वैल्यू पेयर को स्टोर करता है। इसमें बिल्ट-इन फ़ंक्शंस डाले गए हैं (की, वैल्यू)। (कुंजी) और कुछ अन्य सहायक कार्य, लेकिन अनुप्रयोगों में इस तरह के शब्दकोश का उपयोग करना एक बुरी शैली माना जाता है और केवल असाधारण मामलों में इसकी सिफारिश की जाती है ( http://www.erlang.org/doc/man/erlang.html\#put-2 )। नतीजतन, एक पाश में पुनरावृत्तियों को पुनरावृत्त चर के मूल्यों के सामान्य रूप से लागू नहीं किया जा सकता है। परिणाम का संचय केवल पुनरावृत्ति के माध्यम से किया जाता है, और पूंछ पुनरावृत्ति के माध्यम से चक्र का संगठन। (बेशक, लूप में परिणाम का पुनरावृत्ति और संचय सूची के लिए लाइब्रेरी फ़ंक्शंस के माध्यम से लागू किया जा सकता है: फ़ॉरच्यू (फ़ंक्शन, सूची), सूचियाँ: foldl (फ़ंक्शन, StartValue, सूची), सूचियाँ: foldr (फ़ंक्शन, StartValue, सूची) ( http ) : //www.erlang.org/doc/man/lists.html ) और उनके सेट के लिए एनालॉग ( http://www.erlang.org/doc/man/sets.html , http://www.erlang.org /doc/man/ordsets.html , http://www.erlang.org/doc/man/gb_sets.html ) और सरणियाँ ( http://www.erlang.org/doc/man/array.html ) लेकिन हमारा लक्ष्य यह सीखना है कि कैसे चक्र लिखना है, और तैयार किए गए समाधानों का उपयोग नहीं करना है, इसलिए यहां हम ऐसे पुस्तकालयों का उपयोग करने से बचेंगे)।

इस प्रकार, एरलांग को सोच के अभ्यस्त पैटर्न को तोड़ना है और उन्हें नए पैटर्न के साथ बदलना है जो केवल इस प्रोग्रामिंग भाषा के लिए विशिष्ट हैं। बेशक, आदर्श उपाय एक ब्रेनवॉश है जो सभी "मानसिक समर्थन और गढ़" को तोड़ने में सक्षम है। लेकिन हमारे लिए, यह शायद एक माध्यम है, और हम दूसरे रास्ते पर जाएंगे।

सेंट एंथोनी द ग्रेट के जीवन में उनके एक शिष्य के बारे में एक कहानी है। एक शिष्य चर्च में खड़ा था और उसने सेंट एंथोनी को स्तोत्र पढ़ते हुए सुना। जैसे ही पहले भजन की पहली कविता सुनाई दी:
, ...
छात्र ने मंदिर छोड़ दिया। तब से लगभग 30 वर्षों तक किसी ने भी उसे नहीं देखा था, और जब वह मंदिर में फिर से प्रकट हुआ, तो एंथनी द ग्रेट ने पूछा कि उसने उन्हें इतने लंबे समय तक क्यों छोड़ दिया और वह कहां गायब हो गया। शिष्य ने उत्तर दिया: "पिता, मैंने भजन के शब्दों को सुना, और इन शब्दों में जो कहा गया है, उसे पूरा करने के लिए जंगल में सेवानिवृत्त हो गया, अर्थात दुष्ट विचारों की परिषद में मत जाओ। ” दूसरे शब्दों में, उन्होंने इन शब्दों से एक व्यावहारिक सबक सीखा, और अब आगे पढ़ने के लिए आया है। दुर्भाग्य से, हमारे पास ऐसा समय नहीं है, और हमारे लक्ष्य इतने अधिक नहीं हैं। लेकिन मूल अवधारणा को अपनाया जा सकता है।
हम दो मानक संयुक्त समस्याओं पर विचार करेंगे:

एन तत्वों के दिए गए सेट से सभी संभव क्रमपरिवर्तन की खोज करें
एन तत्वों के दिए गए सेट से सभी संभावित संयोजनों की खोज करें

और हम ठोस उदाहरणों का उपयोग करके इस भाषा में प्रोग्रामिंग की कुछ विशेषताओं को समझने और मास्टर करने के लिए, एरलांग प्रोग्रामिंग भाषा का उपयोग करके उन्हें हल करने के लिए विभिन्न तरीकों और तरीकों का विश्लेषण करेंगे।

सभी उदाहरण combinat.erl मॉड्यूल में एकत्र किए गए हैं और यहां उपलब्ध हैं: https://github.com/raven29/combinat_erl.git

दो लक्ष्य - दो पुनरावर्ती

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

सूची से सभी संभावित मूल्यों पर लूपिंग और मौजूदा परिणामों में इनमें से प्रत्येक मान को जोड़ना;
एक नई सूची के हस्तांतरण के साथ पुनरावर्ती कॉल जिसमें से पहले से ही उपयोग किए गए मूल्यों को बाहर रखा गया है।

दूसरे शब्दों में, प्रक्रिया में दो चरण होते हैं: किसी दिए गए स्तर पर चक्रीय खोज और अगले स्तर पर संक्रमण। तदनुसार, इन दो लक्ष्यों को दोहराए जाने वाले कॉल की आवश्यकता होती है। (एल्गोरिथ्म भोली कल्पना पर आधारित है और इसलिए, अनुकूलन की आवश्यकता है। हालांकि, यह हमारे उद्देश्यों के लिए काफी उपयुक्त है, क्योंकि, सबसे पहले, इसकी सादगी और स्पष्टता के कारण, यह इस्तेमाल की जाने वाली विधियों और तकनीकों को चित्रित करना आसान बनाता है, और दूसरी बात, यह दोनों समस्याओं पर विचार के तहत लागू होता है। न्यूनतम अंतर के साथ, जो उचित तुलना और समानताएं बनाना संभव बनाता है)।

आधार कार्यान्वयन

बुनियादी कार्यक्षमता कोम्बिनाट में लागू किया जाता है: permuts_out (सूची, संख्या) और संयोजन: combs_out (सूची, संख्या) फ़ंक्शन, जो क्रमशः क्रमांक के तत्वों से सभी क्रमपरिवर्तन और संख्या लंबाई के सभी संयोजनों को प्रिंट करते हैं। निम्नलिखित एक permuts_out (सूची, संख्या) फ़ंक्शन है जो क्रमपरिवर्तन प्रिंट करता है। इस फ़ंक्शन को दो बार पुनरावर्ती कहा जाता है: पंक्ति 6 में - के माध्यम से लूपिंग के लिए, पंक्ति 7 में - पुनरावृत्ति के अगले स्तर पर जाने के लिए। यह इस अंतिम कॉल में है कि परिणाम परिवर्तनशील [RemainH | परिणाम] में वृद्धि हुई है, साथ ही सामान्य परिणाम से इस परिणाम में शामिल तत्वों का बहिष्करण अगले स्तर पर पुनरावृत्ति के लिए पारित किया गया है। सूची में चौथा तर्क उन वस्तुओं की स्रोत सूची है, जिन्हें केवल क्रमपरिवर्तन के मामले में शेष की सही गणना करने की आवश्यकता है।

 permuts_out(List, Number) -> permuts_out(List, [], Number, List). permuts_out(_Remain, Result, Number, _List) when length(Result) == Number -> io:format("~w~n", [Result]); permuts_out([], _Result, _Number, _List) -> ok; permuts_out([RemainH|RemainT], Result, Number, List) -> permuts_out(RemainT, Result, Number, List), permuts_out(List -- [RemainH|Result], [RemainH|Result], Number, List).

संयोजनों के लिए एक समान कार्य केवल पिछले नियम से संचरित शेष की गणना और चौथे तर्क सूची की अनुपस्थिति में एक सरल नियम में भिन्न होता है।

 combs_out(List, Number) -> combs_out(List, [], Number). combs_out(_Remain, Result, Number) when length(Result) == Number -> io:format("~w~n", [Result]); combs_out([], _Result, _Number) -> ok; combs_out([RemainH|RemainT], Result, Number) -> combs_out(RemainT, Result, Number), combs_out(RemainT, [RemainH|Result], Number).

दो पुनरावर्ती - दो कार्य

अधिक स्पष्टता के लिए, दो पुनरावर्ती कॉल को दो अलग-अलग कार्यों द्वारा दर्शाया जा सकता है। कार्यों के नामों की समाप्ति उनके उद्देश्यों के अनुरूप है: * _iteration - किसी दिए गए पुनरावर्तन स्तर पर शेष सूची से अधिक पुनरावृत्ति के लिए, * _recursion - अगले पुनरावृत्ति स्तर पर जाने के लिए।

 permuts_out_2(List, Number) -> permuts_out_iteration(List, [], Number, List). permuts_out_iteration([], _Result, _Number, _List) -> ok; permuts_out_iteration([RemainH|RemainT], Result, Number, List) -> permuts_out_iteration(RemainT, Result, Number, List), permuts_out_recursion(List -- [RemainH|Result], [RemainH|Result], Number, List). permuts_out_recursion(_Remain, Result, Number, _List) when length(Result) == Number -> io:format("~w~n", [Result]); permuts_out_recursion(Remain, Result, Number, List) -> permuts_out_iteration(Remain, Result, Number, List). combs_out_2(List, Number) -> combs_out_iteration(List, [], Number, List). combs_out_iteration([], _Result, _Number, _List) -> ok; combs_out_iteration([RemainH|RemainT], Result, Number, List) -> combs_out_iteration(RemainT, Result, Number, List), combs_out_recursion(RemainT, [RemainH|Result], Number, List). combs_out_recursion(_Remain, Result, Number, _List) when length(Result) == Number -> io:format("~w~n", [Result]); combs_out_recursion(Remain, Result, Number, List) -> combs_out_iteration(Remain, Result, Number, List).

अत्यधिक बोझिलता के कारण शायद इस विकल्प को एंटीपैटर्न माना जा सकता है।

परिणाम प्रस्तुत करें!

यदि आप एक पुस्तकालय फ़ंक्शन लिखना चाहते हैं, तो मानक स्ट्रीम में आउटपुट का कम उपयोग होता है। आपको परिणाम प्राप्त करने और क्लाइंट कोड में इसे किसी रूप में पास करने की आवश्यकता है। Erlang के पास परिणाम जमा करने के लिए कोई वैश्विक चर या स्थिर क्षेत्र नहीं है। इसके बजाय, कार्यात्मक भाषाओं के लिए विशिष्ट दृष्टिकोण का उपयोग किया जा सकता है:

ऊपर की ओर पुनरावर्तन में मान लौटाएं
कॉलबैक फ़ंक्शन
निष्पादन स्ट्रीम और संग्रहण स्ट्रीम

प्रत्येक विकल्प पर विस्तार से विचार करें।

वहाँ भालू - भालू वापस

अब तक, हम फ़ंक्शन के शरीर में कुछ उपयोगी काम कर रहे हैं (यदि कंप्यूटर स्क्रीन पर परिणाम प्रदर्शित करना उपयोगी माना जा सकता है), नीचे उतरने वाली पुनरावृत्ति में जा रहा है। रिवर्स मूवमेंट में, फ़ंक्शन द्वारा लौटाया गया परिणाम किसी भी तरह से उपयोग नहीं किया गया था। दूसरे शब्दों में, ऊपर की ओर उठने की गति "खाली" थी। इस दृष्टिकोण के साथ, सभी प्रदर्शित मूल्यों को एक साथ रखना असंभव है, क्योंकि वे किसी भी तरह से जुड़े हुए नहीं हैं। अधिक उत्पादक पुनरावर्तन से बाहर निकलने पर फ़ंक्शन द्वारा लौटाए गए परिणाम का उपयोग होता है। इस स्थिति में, पुनरावर्ती फ़ंक्शन का पहला कॉल संपूर्ण संचयी परिणाम वापस कर सकता है। बुनियादी कार्यों का संशोधन नीचे दिया गया है और इसमें तीन बिंदु शामिल हैं:

मानक स्ट्रीम में आउटपुट के बजाय परिणाम [परिणाम] लौटाएं (पंक्ति 3, 11)
पुनरावृत्ति के तल पर, प्रारंभिक मान लौटाया जाता है - एक खाली सूची [] ठीक परमाणु के बजाय (पंक्ति 4: 12)
अनुक्रमिक कॉल के बजाय "++" सूचियों को जोड़कर परिणाम का संचय (पंक्ति 6, 14)

Permuts_res (सूची, संख्या) और combs_res (सूची, संख्या) फ़ंक्शन क्रमशः सूची की एक सूची लौटाते हैं, क्रमशः, क्रम संख्या के सभी क्रमपरिवर्तन और संयोजन।

 permuts_res(List, Number) -> permuts_res(List, [], Number, List). permuts_res(_Remain, Result, Number, _List) when length(Result) == Number -> [Result]; permuts_res([], _Result, _Number, _List) -> []; permuts_res([RemainH|RemainT], Result, Number, List) -> permuts_res(RemainT, Result, Number, List) ++ permuts_res(List -- [RemainH|Result], [RemainH|Result], Number, List). combs_res(List, Number) -> combs_res(List, [], Number). combs_res(_Remain, Result, Number) when length(Result) == Number -> [Result]; combs_res([], _Result, _Number) -> []; combs_res([RemainH|RemainT], Result, Number) -> combs_res(RemainT, Result, Number) ++ combs_res(RemainT, [RemainH|Result], Number).

और उसके साथ जो अच्छा लगे वो करो!

कभी-कभी यह एक संग्रह चर में परिणाम जमा नहीं करने के लिए सुविधाजनक है, लेकिन इसके निर्माण के तुरंत बाद प्रत्येक तत्व के साथ कुछ उपयोगी करने के लिए। यह दृष्टिकोण आपको उत्पादकता बढ़ाने और स्मृति खपत को कम करने की अनुमति देता है। आप कॉलबैक फ़ंक्शन का उपयोग करके इसे लागू कर सकते हैं, जिसे अतिरिक्त तर्क के रूप में पारित किया गया है। प्रासंगिक विकल्प नीचे सूचीबद्ध हैं।

 permuts_clb(List, Number, Callback) -> permuts_clb(List, [], Number, List, Callback). permuts_clb(_Remain, Result, Number, _List, Callback) when length(Result) == Number -> Callback(Result); permuts_clb([], _Result, _Number, _List, _Callback) -> ok; permuts_clb([RemainH|RemainT], Result, Number, List, Callback) -> permuts_clb(RemainT, Result, Number, List, Callback), permuts_clb(List -- [RemainH|Result], [RemainH|Result], Number, List, Callback). combs_clb(List, Number, Callback) -> combs_clb(List, [], Number, Callback). combs_clb(_Remain, Result, Number, Callback) when length(Result) == Number -> Callback(Result); combs_clb([], _Result, _Number, _Callback) -> ok; combs_clb([RemainH|RemainT], Result, Number, Callback) -> combs_clb(RemainT, Result, Number, Callback), combs_clb(RemainT, [RemainH|Result], Number, Callback).

कॉलबैक चर में, एक तर्क से किसी भी फ़ंक्शन का नाम पारित किया जा सकता है (एरलैंग एक के साथ - एरलंग शब्दावली के अनुसार)। इसलिए, उदाहरण के लिए, आप तत्वों के सभी क्रमपरिवर्तन को प्रिंट करने के लिए कह सकते हैं [1,2,3] 2:

 combinat:permuts_clb([1,2,3], 2, fun(X)->io:format("~w~n",[X]) end).

कॉलबैक फ़ंक्शन के अधिक सार्थक अनुप्रयोग की चर्चा अगले भाग में की गई है।

बिग ब्रदर आपको देख रहा है

एर्लैंग में शाखाओं की पुनरावृत्ति के परिणामस्वरूप संचय को लागू करने का एक और तरीका दो धागे का उपयोग करना है। एक धागा निष्पादक है, इसमें हमारा प्रोग्राम लॉन्च किया गया है। एक और धागा एक पर्यवेक्षक है, एक पुनरावर्ती फ़ंक्शन परिणाम को पास करता है। जब निष्पादित थ्रेड अपना काम पूरा करता है, तो अवलोकन थ्रेड कुल परिणाम प्रदर्शित करता है। महत्वपूर्ण: निष्पादित थ्रेड के रूप में, आप मुख्य थ्रेड (पर्यवेक्षक) का उपयोग नहीं कर सकते हैं, जिसमें एर्ल शेल चल रहा है, क्योंकि कार्यक्रम निष्पादन के बाद यह धागा नष्ट नहीं होता है। यह तब तक मौजूद रहता है जब तक कि erl एप्लिकेशन अनलोड नहीं हो जाता।

नीचे इसी कार्यान्वयन है। पंक्ति 3 "सीढ़ी पर बाहर निकलने" को निर्धारित करती है, जो इसके सामान्य पूर्ण होने की स्थिति में भी संबंधित प्रक्रिया से एक संदेश के प्रसारण को सुनिश्चित करती है। डिफ़ॉल्ट रूप से, trap_exit ध्वज को गलत पर सेट किया जाता है, जिसका अर्थ है असामान्य समाप्ति की स्थिति में केवल संबद्ध प्रक्रिया से एक संदेश प्राप्त करना। पंक्ति 5 में, निष्पादित धागा शुरू होता है (और साथ ही साथ बांधता है)। इस थ्रेड में, permuts_clb (या combs_clb) फ़ंक्शन लॉन्च किया गया है, जो तर्कों की सूची, संख्या, साथ ही कॉलबैक कॉलबैक फ़ंक्शन को प्राप्त करता है, जो पर्यवेक्षक प्रक्रिया के लिए प्रत्येक इकाई परिणाम को पास करता है:

 fun(R)->Supervisor!R end

पंक्ति 6 में, लूप ([]) फ़ंक्शन कुल परिणाम के खाली प्रारंभिक मूल्य के साथ शुरू होता है। यह फ़ंक्शन निष्पादन स्ट्रीम से संदेशों के लिए सुनता है। जब अगला परिणाम प्राप्त होता है, तो एक लूप (टोटल ++ [रिजल्ट]) को पुनरावर्ती स्ट्रीम से नए आये परिणाम द्वारा पूरक तर्क के साथ पुनरावर्ती (लाइन 14) कहा जाता है। निष्पादित थ्रेड के काम के पूरा होने पर, "सीढ़ी से बाहर निकलें" होता है: एक विशेष प्रकार का ट्यूल (लाइन 10) लूप को पास किया जाता है (), जिसके अनुसार, पैटर्न मिलान के परिणामस्वरूप, समग्र परिणाम प्रदर्शित होता है (लाइन 11) और निष्पादन स्ट्रीम के साथ कनेक्शन टूट जाता है (पंक्ति 12) )। पर्यवेक्षक - पर्यवेक्षक धागे की पिड, कार्यकर्ता - निष्पादनकर्ता धागे की पिड।

 %% Function = permuts_clb | combs_clb proc(Function, List, Number) -> process_flag(trap_exit, true), Supervisor = self(), spawn_link(combinat, Function, [List, Number, fun(R)->Supervisor!R end]), loop([]). loop(Total) -> receive {'EXIT', Worker, normal} -> io:format("~w~n", [Total]), unlink(Worker); Result -> loop(Total ++ [Result]) end.

कार्य के हल होने के आधार पर फ़ंक्शन को पहले तर्क के रूप में permuts_clb या combs_clb कहा जाता है। उदाहरण के लिए, 2 से तत्वों द्वारा सभी क्रमपरिवर्तन [1,2,3] का मुद्रण एक कॉल के माध्यम से किया जाता है:

 combinat:proc(permuts_clb, [1,2,3], 2).

एक शुरुआत की विशिष्ट त्रुटियाँ हो सकती हैं। सबसे पहले, आप स्पॉन_लिंक () से पहले लूप () नहीं चला सकते हैं। ऐसा लगता है कि यह अधिक विश्वसनीय होगा, क्योंकि श्रोता फ़ंक्शन, जिसे निष्पादन थ्रेड शुरू होने से पहले लॉन्च किया गया था, संभवतः इस थ्रेड का एक भी संदेश याद नहीं करेगा। लेकिन परिणामस्वरूप, प्रक्रिया लूप () पर लटकाएगी, और अगली पंक्ति को कभी भी नहीं बुलाया जाएगा। दूसरे, पर्यवेक्षक चर का उपयोग करते हुए पर्यवेक्षक को संदेश भेजने के लिए अनिवार्य है: डिजाइन

 self()!R

कार्य नहीं करता है, चूंकि निष्पादन स्ट्रीम में स्वयं () फ़ंक्शन निष्पादित किया जाएगा और, तदनुसार, निष्पादन स्ट्रीम के पीआईडी को स्वीकार करेगा। इन टिप्पणियों की रचनात्मक आलोचना के लिए w495 और EvilBlueBeaver के लिए धन्यवाद (और सिर्फ यह पता लगाने में मदद के लिए)।

और एक और छोटी टिप्पणी: जब खरीद () फ़ंक्शन के साथ प्रयोग किया जाता है, तो विभिन्न विषमताएं हो सकती हैं, उदाहरण के लिए, एक फ़ंक्शन "देरी", अर्थात् के साथ एक परिणाम का उत्पादन शुरू कर सकता है। प्रत्येक कॉल पर, पिछली कॉल का परिणाम लौटाएं। यह इस तथ्य के कारण हो सकता है कि हम मुख्य धागे को एक पर्यवेक्षक धागे के रूप में लॉन्च कर रहे हैं। इसलिए, किसी भी विफलता के बाद, लूप के अगले कॉल () पहले अंतिम कॉल से सभी संदेशों को संसाधित करेगा, यदि कोई हो। इस अर्थ में, श्रोता धारा को स्पॉन () या स्पॉन_लिंक () फ़ंक्शन द्वारा उत्पन्न एक अलग स्ट्रीम में भी लागू करना अधिक विश्वसनीय होगा।

समझने के लिए सक्षम करना है

कुछ प्रोग्रामिंग भाषाओं में एक वाक्य रचना है, जिसे " सूची समझ " कहा जाता है। यह आपको कॉम्पैक्ट और सुरुचिपूर्ण रूप में सूची के पुनरावृत्त ट्रैवर्सल को निर्दिष्ट करने की अनुमति देता है, जिसके परिणामस्वरूप एक नई सूची उत्पन्न होती है, जिनमें से प्रत्येक तत्व मूल सूची के प्रत्येक तत्व को कुछ फ़ंक्शन लागू करके मूल सूची से प्राप्त होता है। डिजाइन गणितीय सेट सिद्धांत की अंकन प्रणाली पर आधारित है। यहाँ, उदाहरण के लिए, सूची बोध निर्माण में, 1 से 9 तक के सभी पूर्णांकों के वर्गों का आउटपुट निम्न प्रकार है:

 [X*X || X <- [1,2,3,4,5,6,7,8,9]].

सूची की समझ में, कई सूचियों को पारित करना और शर्तों को लागू करना भी संभव है। उदाहरण के रूप में, 1 से 9 तक गुणन तालिका के आउटपुट पर विचार करें:

 [io:format("~w * ~w = ~w~n", [I, J, I*J]) || I <- [1,2,3,4,5,6,7,8,9], J <- [1,2,3,4,5,6,7,8,9]].

साथ ही गुणन तालिका, जिसमें कारकों के क्रमचय के साथ बार-बार परिणाम शामिल नहीं हैं:

 [io:format("~w * ~w = ~w~n", [I, J, I*J]) || I <- [1,2,3,4,5,6,7,8,9], J <- [1,2,3,4,5,6,7,8,9], I < J].

रूसी साहित्य में, "सूची समझ" को "सूचियों का समावेश", "सूची निर्माण" के रूप में अनुवादित किया जाता है। अनुवाद "समझ" का मुख्य अर्थ "समझने के लिए", "समझने के लिए" है। तो, अंग्रेजी में समझने के लिए शामिल करना है।

यह ध्यान दिया जाना चाहिए कि समझ का निर्माण न केवल सूचियों के लिए, बल्कि अन्य प्रकारों के संग्रह के लिए भी मौजूद है। एरलैंग में लिस्ट कॉम्प्रिहेंशन और बाइनरी कॉम्प्रिहेंशन है ।

अपनी तरह का सबसे सुरुचिपूर्ण

सूची की समझ के निर्माण में, सूची के पुनरावृत्त ट्रैवर्सल को निर्दिष्ट किया जा सकता है, परिणामस्वरूप, मूल फ़ंक्शन का निर्माण होगा:

 permuts_comp(List, Number) -> permuts_comp(List, [], Number). permuts_comp(_Remain, Result, Number) when length(Result) == Number -> io:format("~w~n", [Result]); permuts_comp(Remain, Result, Number) -> [permuts_comp(Remain -- [R], [R] ++ Result, Number) || R <- Remain].

Permuts_comp फ़ंक्शन सूची बोध से स्वयं को पुनरावर्ती कहता है।
यह संभवतः सबसे सुंदर क्रमपरिवर्तन कार्य संभव है।

यदि आप नहीं कर सकते, लेकिन वास्तव में चाहते हैं ...

संयोजन के कार्य के लिए पिछले परिणाम का सामान्यीकरण, दुर्भाग्य से, इतना स्पष्ट नहीं है। तथ्य यह है कि इस मामले में सूची की समझ में पूरी सूची को स्थानांतरित करना आवश्यक नहीं है, लेकिन केवल पिछली कॉल से संख्या द्वारा निर्धारित शेष है। यदि सूचियों के बजाय एक सरणी थी, तो वांछित सूचकांक की आसानी से गणना करना संभव होगा। लेकिन सरणियाँ मूल एरलंग प्रकारों में नहीं हैं। या तो सरणी लाइब्रेरी का उपयोग करें या मैन्युअल रूप से सरणी व्यवस्थित करें।
यह काफी सरल है, और इसी कार्यान्वयन को नीचे प्रस्तुत किया गया है। मूल सूची से, ListIndexed tuples की सूची बनाएँ, जिनमें से प्रत्येक तत्व में मूल सूची के तत्व और पूर्णांक सूचकांक (पंक्ति 2) शामिल हैं। फ़ंक्शन सूची: मानक सूचियों से ज़िप (सूची 1, सूची 2) ऐसे रूपांतरण के लिए उपयुक्त है। परिणाम को आउटपुट करते समय, हम सूचियों का उपयोग करते हैं: अनज़िप (लिस्टइन्डेक्सड) फ़ंक्शन, जो अनुक्रमित सूची को अपने मूल स्वरूप के बिना अनुक्रमित करता है (पंक्ति 5)। और सबसे महत्वपूर्ण बात - सूची समझ में आप अब आसानी से पुनरावृत्ति (पंक्ति 11) में शामिल सूचकांकों पर आवश्यक प्रतिबंध निर्दिष्ट कर सकते हैं।

 combs_comp(List, Number) -> ListIndexed = lists:zip(List, lists:seq(1, length(List))), combs_comp(ListIndexed, [], Number). combs_comp(_Remain, Result, Number) when length(Result) == Number -> {ResultValue, _I} = lists:unzip(Result), io:format("~w~n", [ResultValue]); combs_comp(Remain, [], Number) -> [combs_comp(Remain -- [R], [R], Number) || R <- Remain]; combs_comp(Remain, [{HValue,HIndex}|T], Number) -> [combs_comp(Remain -- [{R,I}], [{R,I}] ++ [{HValue,HIndex}|T], Number) || {R,I} <- Remain, I > HIndex].

यह कुछ अजीब लग रहा है, और यह हमारे उदाहरणों के बीच एकमात्र कार्यक्रम है जिसमें मुझे पुस्तकालय कार्यों की सूची का सहारा लेना था: ज़िप (सूची 1, सूची 2), सूचियाँ: अनज़िप (लिस्टटल), सूचियाँ: seq (StartTalue, लंबाई)। इस प्रयास को एंटीपैटर्न का एक उदाहरण भी माना जा सकता है, क्योंकि हाथ में कार्य के लिए, यह सरणी मॉड्यूल का उपयोग करने के लिए अधिक सुसंगत होगा, लेकिन यह एक अलग कहानी होगी ...

एर्लांग में सोचना और लिखना सीखना (उदाहरण के रूप में दो संयोजन समस्याओं का उपयोग करके)