Iteraptor: गहन पारदर्शी मानचित्र रेडस के लिए पुस्तकालय

अमृत डेटा संरचनाएं अपरिवर्तनीय हैं। यह विश्वास के दृष्टिकोण से महान है कि हमारे डेटा को कोड के कुछ अन्य अप्रासंगिक टुकड़े में मान्यता से परे भ्रष्ट नहीं किया जाएगा, लेकिन जब हम एक गहरी नेस्टेड संरचना को बदलने की आवश्यकता होती है तो यह थोड़ा कष्टप्रद होता है।

हमारे पास एक शानदार Access एब्सट्रैक्शन है, जो Kernel से डिफ़ॉल्ट फ़ंक्शन द्वारा निर्यात की गई गहरी नेस्टेड वस्तुओं पर चार बुनियादी संचालन को सरल करता है:

• Kernel.get_in/2
• Kernel.put_in/{2,3}
• Kernel.update_in/{2,3}
• Kernel.pop_in/{1,2}

ये चार Kernel.get_and_update_in/{2,3} (और Kernel.get_and_update_in/{2,3} आमतौर पर कुछ इस तरह से उपयोग किए जाते हैं:

 iex> users = %{"john" => %{age: 27, mood: ""}, "meg" => %{age: 23}} #   iex> get_in(users, ["john", :age]) #⇒ 27 #   iex> put_in(users, ["john", :age], 28) #⇒ %{"john" => %{age: 28, mood: ""}, "meg" => %{age: 23}} #   iex> update_in(users, ["john", :mood], & &1 + 1) #⇒ %{"john" => %{age: 28, mood: ""}, "meg" => %{age: 23}} #   iex> pop_in(users, ["john", :mood]) #⇒ {"", %{"john" => %{age: 27}, "meg" => %{age: 23}}} 

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

नेस्टेड संरचनाओं के साथ काम करने पर थोक छूट प्रदान करने के लिए, Iteraptor पुस्तकालय बनाया गया था।

TL; DR:

• स्रोत कोड ;
• प्रलेखन ।

सब कुछ Iterating आप Elixir पर जादुई रूप से प्रसारित कर सकते हैं। पुनरावृत्ति करने के लिए, बस इस विशेष प्रकार के लिए Enumerable प्रोटोकॉल को लागू करें। आप पाइपलाइनों में समूह पारित कर सकते हैं, नक्शा, कम कर सकते हैं, फ़िल्टर कर सकते हैं, पतले हो सकते हैं ... मेरे फ्रांसीसी को क्षमा करें, हाँ। हर कोई जो अमृत ​​के साथ कम से कम आठ घंटे बिताता है, उसने निश्चित रूप से देखा (और संभवतः लिखा भी) कुछ इस तरह है:

 ~w|   | |> Enum.map(&String.capitalize/1) |> Enum.each(fn capitalized_name -> IO.puts "Hello, #{capitalized_name}!" end) # Hello, ! # Hello, ! # Hello, ! # Hello, ! 

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

स्टैक ओवरफ्लो पर प्रश्नों की संख्या प्रश्न के साथ "मैं नेस्टेड संरचना को कैसे बदल सकता हूं?" मुझे अंततः इस लाइब्रेरी को बनाने के लिए मजबूर किया। एलिक्ज़िर में कार्यान्वयन थोड़ा भ्रमित करने वाला लगता है, क्योंकि चारों ओर सब कुछ अपरिवर्तनीय है, और आप संरचना की शाखाओं को केवल पत्तियों तक नीचे नहीं जा सकते हैं, जो आपके लिए आवश्यक सब कुछ बदलते हैं। आपको एक कार्यात्मक कोड के किसी भी हुड के तहत, बैटरी की आवश्यकता होगी। नेस्टेड संरचनाओं को बदलना शायद एकमात्र उदाहरण है जिसे मैंने अपने जीवन में देखा है जब परिवर्तनशीलता आसान हो जाती है।

नियमित मानचित्र अग्रदूतों के लिए एक बोनस के रूप में, मैंने संरचना के अंदर मूल्य को गहराई से संग्रहीत करने के लिए एक कार्यान्वयन जोड़ा, जो आवश्यकतानुसार मध्यवर्ती कुंजी बनाता है। यह प्रस्तावित के रूप में व्यवहार करता है, लेकिन रूबी कोर Hash#bury में खारिज कर दिया गया। यह लाइब्रेरी यह भी जानती है कि "जस्सोनाइज" नेस्टेड स्ट्रक्चर वाले कीवर्ड्स जिन्हें केवल जोंस में क्रमबद्ध नहीं किया जा सकता है, क्योंकि अंदर उन्हें दो-तत्व ट्यूपल्स की सूची के रूप में प्रस्तुत किया जाता है ( [foo: :bar] == [{:foo, :bar}] ), और टुपल्स बॉक्स से बाहर क्रमिक नहीं हैं।

तो, चलिए लाइब्रेरी का अभिवादन करते हैं, जो पूंछ और माने में किसी भी मैप / कीवर्ड / सूची पर आधारित है और मानक Enum.each/2 और Enum.map/2 लगभग सरल है।

संभावनाएं

• Iteraptor.each/3 साधारण पुनरावृत्ति, संरचना को स्वयं लौटाता है;
• Iteraptor.map/3 मैपिंग, एक मैप की गई संरचना लौटाता है;
• Iteraptor.reduce/4 reduus, बैटरी लौटाता है;
• Iteraptor.map_reduce/4 मैप और रिड्यूस, मैपिंग और बैटरी के परिणाम के साथ एक टपल लौटाता है;
• Iteraptor.filter/3 अंतिम पैरामीटर द्वारा प्राप्त फ़ंक्शन का उपयोग करके संरचना को फ़िल्टर करता है;
• Iteraptor.jsonify/2 , json में क्रमांकन के लिए संरचना तैयार करता है: सभी खोजशब्दों को मानचित्रों से बदल दिया जाता है , कुंजियों को तारों में बदल दिया जाता है;
• Iteraptor.Extras.bury/4 संरचना में मूल्य को गहराई से लिखता है, आवश्यकतानुसार मध्यवर्ती कुंजी Iteraptor.Extras.bury/4 ;
• Iteraptor.to_flatmap/2 में संरचना को एक फ्लैट में बदल देता है, ध्यान से सूचियों के लिए अनुक्रमणिका Iteraptor.to_flatmap/2 ; मूल संरचना का उपयोग करके वापस प्राप्त किया जा सकता है
• Iteraptor.from_flatmap/3 एक गहरी नेस्टेड में अवतल कुंजियों के साथ एक प्लैटंक संरचना को बदल देता है;
• use Iteraptor.Iteraptable और Collectable प्रोटोकॉल के साथ use Iteraptor.Iteraptable स्वचालित कार्यान्वयन, साथ ही संरचना के लिए Access व्यवहार का उपयोग करें। हुड के नीचे क्या है, इसका अधिक विस्तृत विवरण है।

शब्दों की कीमत कुछ भी नहीं, कोड दिखाएं!

Iteration, मैपिंग, रिडक्शन

 # each iex> %{a: %{b: %{c: 42}}} |> Iteraptor.each(&IO.inspect(&1, label: "each"), yield: :all) # each: {[:a], %{b: %{c: 42}}} # each: {[:a, :b], %{c: 42}} # each: {[:a, :b, :c], 42} %{a: %{b: %{c: 42}}} # map iex> %{a: %{b: %{c: 42}}} |> Iteraptor.map(fn {k, _} -> Enum.join(k) end) %{a: %{b: %{c: "abc"}}} iex> %{a: %{b: %{c: 42}, d: "some"}} ...> |> Iteraptor.map(fn ...> {[_], _} = self -> self ...> {[_, _], _} -> "********" ...> end, yield: :all) %{a: %{b: "********", d: "some"}} # reduce iex> %{a: %{b: %{c: 42}}} ...> |> Iteraptor.reduce([], fn {k, _}, acc -> ...> [Enum.join(k, "_") | acc] ...> end, yield: :all) ...> |> :lists.reverse() ["a", "a_b", "a_b_c"] # map-reduce iex> %{a: %{b: %{c: 42}}} ...> |> Iteraptor.map_reduce([], fn ...> {k, %{} = v}, acc -> {​{k, v}, [Enum.join(k, ".") | acc]} ...> {k, v}, acc -> {​{k, v * 2}, [Enum.join(k, ".") <> "=" | acc]} ...> end, yield: :all) {​%{a: %{b: %{c: 42}}}, ["abc=", "ab", "a"]} # filter iex> %{a: %{b: 42, e: %{f: 3.14, c: 42}, d: %{c: 42}}, c: 42, d: 3.14} ...> |> Iteraptor.filter(fn {key, _} -> :c in key end, yield: :none) %{a: %{e: %{c: 42}, d: %{c: 42}}, c: 42} 

गहरा घोंसला → सपाट संरचना और इसके विपरीत

 iex> %{a: %{b: %{c: 42, d: [nil, 42]}, e: [:f, 42]}} ...> |> Iteraptor.to_flatmap(delimiter: "_") #⇒ %{"a_b_c" => 42, "a_b_d_0" => nil, "a_b_d_1" => 42, "a_e_0" => :f, "a_e_1" => 42} iex> %{"abc": 42, "abd0": nil, "abd1": 42, "ae0": :f, "ae1": 42} ...> |> Iteraptor.from_flatmap #⇒ %{a: %{b: %{c: 42, d: [nil, 42]}, e: [:f, 42]}} 

बन

 iex> Iteraptor.jsonify([foo: [bar: [baz: :zoo], boo: 42]], values: true) %{"foo" => %{"bar" => %{"baz" => "zoo"}, "boo" => 42}} iex> Iteraptor.Extras.bury([foo: :bar], ~w|abcd|a, 42) [a: [b: [c: [d: 42]]], foo: :bar] 

स्रोत खुले हैं , प्रलेखन काफी विस्तृत है , हम लगभग दो वर्षों से उत्पादन में हैं।

एक अच्छा चलना है!