एर्लांग में मोनाड्स

Habré पर, आप कई प्रकाशनों को खोज सकते हैं जो दोनों साधुओं के सिद्धांत और उनके आवेदन के अभ्यास को प्रकट करते हैं। इनमें से अधिकांश लेख हास्केल के बारे में अपेक्षित हैं। मैं nth समय के लिए सिद्धांत को फिर से नहीं लिखूंगा। आज हम कुछ Erlang समस्याओं के बारे में बात करेंगे, उन्हें साधुओं के साथ हल करने के तरीके, कार्यों के आंशिक उपयोग और erlando से वाक्यगत चीनी - RabbitMQ टीम से एक शांत पुस्तकालय।

परिचय

एर्लैंग में अस्थिरता है, लेकिन कोई सन्यासी नहीं। लेकिन भाषा में parse_transform कार्यक्षमता और erlando कार्यान्वयन के लिए धन्यवाद, अभी भी इरडांग में मठों का उपयोग करने की संभावना है।

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

Erlando

एर्लैंडो एक एरलैंग एक्सटेंशन सेट है जो हमें दे रहा है:

• योजना जैसे कटौती के साथ कार्यों का आंशिक उपयोग / करी
• हास्केल जैसी धारणाएँ
• import-as - अन्य मॉड्यूल से फ़ंक्शंस को आयात करने के लिए सिंटैक्टिक शुगर।

नोट: मैंने मैथ्यू सैकमैन की प्रस्तुति से एरलैंडो की विशेषताओं का वर्णन करने के लिए निम्नलिखित कोड उदाहरणों को लिया, आंशिक रूप से उन्हें मेरे कोड और स्पष्टीकरण के साथ पतला किया।

सार कट

सीधे बिंदु पर जाएं। एक वास्तविक परियोजना से कई कार्यों पर विचार करें:

info_all(VHostPath, Items) -> map(VHostPath, fun (Q) -> info(Q, Items) end). backing_queue_timeout(State = #q{ backing_queue = BQ }) -> run_backing_queue( BQ, fun (M, BQS) -> M:timeout(BQS) end, State). reset_msg_expiry_fun(TTL) -> fun (MsgProps) -> MsgProps #message_properties{ expiry = calculate_msg_expiry(TTL)} end. 

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

मान _

• _ टेम्पलेट्स में इस्तेमाल किया जा सकता है
• कट आपको बाहर के पैटर्न का उपयोग करने देता है
• यदि यह टेम्पलेट के बाहर है, तो यह उस अभिव्यक्ति के लिए एक पैरामीटर बन जाता है जिसमें यह स्थित है
• एक ही अभिव्यक्ति के भीतर _ के कई उपयोग इस अभिव्यक्ति में कई मापदंडों के प्रतिस्थापन की ओर ले जाते हैं
• कट क्लोजर (फन) के लिए प्रतिस्थापन नहीं है
• कट फ़ंक्शन के पहले तर्क का मूल्यांकन किया जाता है।

एब्सट्रैक्शन लागू किया जाना चाहिए, यह इंगित करने के लिए कट इन _ का उपयोग करता है। कट केवल अभिव्यक्ति में निकटतम स्तर को लपेटता है, लेकिन नेस्टेड कट निषिद्ध नहीं है।
उदाहरण के लिए list_to_binary([1, 2, math:pow(2, _)]). list_to_binary([1, 2, fun (X) -> math:pow(2, X) end]). है list_to_binary([1, 2, fun (X) -> math:pow(2, X) end]). लेकिन fun (X) -> list_to_binary([1, 2, math:pow(2, X)]) end. ।

यह थोड़ा भ्रमित करने वाला लगता है, चलो कट का उपयोग करके ऊपर दिए गए उदाहरणों को फिर से लिखें:

 info_all(VHostPath, Items) -> map(VHostPath, fun (Q) -> info(Q, Items) end). info_all(VHostPath, Items) -> map(VHostPath, info(_, Items)). 

 backing_queue_timeout(State = #q{ backing_queue = BQ }) -> run_backing_queue( BQ, fun (M, BQS) -> M:timeout(BQS) end, State). backing_queue_timeout(State = #q{backing_queue = BQ}) -> run_backing_queue(BQ, _:timeout(_), State). 

 reset_msg_expiry_fun(TTL) -> fun (MsgProps) -> MsgProps #message_properties { expiry = calculate_msg_expiry(TTL) } end. reset_msg_expiry_fun(TTL) -> _ #message_properties { expiry = calculate_msg_expiry(TTL) }. 

तर्क गणना आदेश

उस क्रम को समझाने के लिए जिसमें तर्कों की गणना की जाती है, निम्नलिखित उदाहरण पर विचार करें:

 f1(_, _) -> io:format("in f1~n"). test() -> F = f1(io:format("test line 1~n"), _), F(io:format("test line 2~n")). 

चूंकि कट फ़ंक्शन से पहले तर्कों का मूल्यांकन किया जाता है, इसलिए निम्नलिखित प्रदर्शित किए जाएंगे:

 test line 2 test line 1 in f1 

विभिन्न प्रकार और कोड के पैटर्न में अमूर्तता काटें

• tuples
  

   F = {_, 3}, {a, 3} = F(a). 

• सूचियाँ
  

   dbl_cons(List) -> [_, _ | List]. test() -> F = dbl_cons([33]), [7, 8, 33] = F(7, 8). 

• अभिलेख
  

   -record(vector, { x, y, z }). test() -> GetZ = _#vector.z, 7 = GetZ(#vector { z = 7 }), SetX = _#vector{x = _}, V = #vector{ x = 5, y = 4 } = SetX(#vector{ y = 4 }, 5). 

• मामले
  

   F = case _ of N when is_integer(N) -> N + N; N -> N end, 10 = F(5), ok = F(ok). 

• मैप्स
  

   test() -> GetZ = maps:get(z, _), 7 = GetZ(#{ z => 7 }), SetX = _#{x => _}, V = #{ x := 5, y := 4 } = SetX(#{ y => 4 }, 5). 

• मिलान सूची और बाइनरी डेटा का निर्माण
  

   test_cut_comprehensions() -> F = << <<(1 + (X*2))>> || _ <- _, X <- _ >>, %% Note, this'll only be a /2 ! <<"AAA">> = F([a,b,c], [32]), F1 = [ {X, Y, Z} || X <- _, Y <- _, Z <- _, math:pow(X,2) + math:pow(Y,2) == math:pow(Z,2) ], [{3,4,5}, {4,3,5}, {6,8,10}, {8,6,10}] = lists:usort(F1(lists:seq(1,10), lists:seq(1,10), lists:seq(1,10))). 

पेशेवरों

• कोड छोटा हो गया है, इसलिए इसे बनाए रखना आसान है।
• कोड सरल और स्पष्ट हो गया है।
• मस्ती से शोर मच गया।
• Erlang में शुरुआती लोगों के लिए, Get / Set फ़ंक्शन लिखना अधिक सुविधाजनक है।

विपक्ष

• शुरुआती लोगों के लिए प्रवेश सीमा को कम करते हुए, अनुभवी एर्लांग डेवलपर्स के लिए प्रवेश सीमा बढ़ा दी गई है। अब टीम को कटौती को समझने और एक और वाक्य रचना को जानने की आवश्यकता है।

संकेतन

शीतल अल्पविराम एक संगणना बंधन है। Erlang में आलसी गणना मॉडल नहीं है। आइए कल्पना करें कि यदि एर्लैंग हास्केल की तरह आलसी थे तो क्या होगा

 my_function() -> A = foo(), B = bar(A, dog), ok. 

निष्पादन आदेश की गारंटी देने के लिए, हमें अल्पविराम को परिभाषित करके गणनाओं को स्पष्ट रूप से जोड़ना होगा।

 my_function() -> A = foo(), comma(), B = bar(A, dog), comma(), ok. 

रूपांतरण जारी रखें:

 my_function() -> comma(foo(), fun (A) -> comma(bar(A, dog), fun (B) -> ok end)). 

निष्कर्ष के आधार पर, अल्पविराम / 2 एक मुहावरेदार कार्य है >>=/2 । सन्यासी को केवल तीन कार्यों की आवश्यकता होती है: >>=/2 , return/1 और fail/1 ।
सबकुछ ठीक हो जाएगा, लेकिन वाक्यविन्यास सिर्फ भयानक है। हम erlando से सिंटैक्स ट्रांसफार्मर लागू करते हैं।

 do([Monad || A <- foo(), B <- bar(A, dog), ok]). 

मोनाड्स के प्रकार

चूंकि डो-ब्लॉक को मानकीकृत किया गया है, इसलिए हम विभिन्न प्रकार के साधनों का उपयोग कर सकते हैं। डो-ब्लॉक के अंदर, कॉल return/1 और fail/1 को Monad:return/1 और Monad:fail/1 क्रमशः परिनियोजित किया जाता है।

• पहचान-इकाई।
  समान मोनाड सबसे सरल मोनाड है जो मूल्यों के प्रकार को नहीं बदलता है और गणना प्रक्रिया के नियंत्रण में भाग नहीं लेता है। इसे ट्रांसफार्मर के साथ लगाया जाता है। लिंकिंग एक्सप्रेशन करता है - ऊपर चर्चा की गई सॉफ्टवेयर कॉमा।

  
  

• हो सकता है कि-इकाई।
  लापता मूल्यों को संसाधित करने के साथ गणना का मोनाड। एक पैरामीटर को एक परिकलित गणना के साथ जोड़ना एक पैरामीटर की गणना के लिए स्थानांतरण है, एक अनुपस्थित पैरामीटर को एक पैरामीटर की गई गणना से जोड़ना एक अनुपस्थित परिणाम है।
  शायद_म के एक उदाहरण पर विचार करें:

  
  

   if_safe_div_zero(X, Y, Fun) -> do([maybe_m || Result <- case Y == 0 of true -> fail("Cannot divide by zero"); false -> return(X / Y) end, return(Fun(Result))]). 

  
  

  यदि कुछ भी वापस नहीं किया गया तो अभिव्यक्ति का मूल्यांकन रुक जाता है।

  
  

   {just, 6} = if_safe_div_zero(10, 5, _+4) ## 10/5 = 2 -> 2+4 -> 6 nothing = if_safe_div_zero(10, 0, _+4) 

  
  

• त्रुटि-इकाई।
  IF_m के समान, केवल त्रुटि से निपटने के साथ। कभी-कभी इसे दुर्घटना सिद्धांत को लागू नहीं करने देते हैं और उस समय होने वाली त्रुटियों को नियंत्रित करना चाहिए। इस मामले में, केस से सीढ़ियां अक्सर कोड में दिखाई देती हैं, उदाहरण के लिए, ये:

  
  

   write_file(Path, Data, Modes) -> Modes1 = [binary, write | (Modes -- [binary, write])], case make_binary(Data) of Bin when is_binary(Bin) -> case file:open(Path, Modes1) of {ok, Hdl} -> case file:write(Hdl, Bin) of ok -> case file:sync(Hdl) of ok -> file:close(Hdl); {error, _} = E -> file:close(Hdl), E end; {error, _} = E -> file:close(Hdl), E end; {error, _} = E -> E end; {error, _} = E -> E end. 

  
  

   make_binary(Bin) when is_binary(Bin) -> Bin; make_binary(List) -> try iolist_to_binary(List) catch error:Reason -> {error, Reason} end. 

  
  

यह पढ़ना अप्रिय है, जेएस में कॉलबैक नूडल्स जैसा दिखता है। Error_m बचाव के लिए आता है:

 write_file(Path, Data, Modes) -> Modes1 = [binary, write | (Modes -- [binary, write])], do([error_m || Bin <- make_binary(Data), Hdl <- file:open(Path, Modes1), Result <- return(do([error_m || file:write(Hdl, Bin), file:sync(Hdl)])), file:close(Hdl), Result]). make_binary(Bin) when is_binary(Bin) -> error_m:return(Bin); make_binary(List) -> try error_m:return(iolist_to_binary(List)) catch error:Reason -> error_m:fail(Reason) end. 

• सूची-इकाई।
  मान एक सूची की एक संभावित परिणाम के रूप में व्याख्या की जा सकने वाली सूची है। यदि एक गणना दूसरे पर निर्भर करती है, तो दूसरी गणना पहले के प्रत्येक परिणाम के लिए की जाती है, और परिणाम (दूसरी गणना) को एक सूची में एकत्र किया जाता है।
  क्लासिक पायथागॉरियन ट्राइएल्स के साथ उदाहरण पर विचार करें। हम उन्हें बिना मोनाड के गणना करते हैं:
  

   P = [{X, Y, Z} || Z <- lists:seq(1,20), X <- lists:seq(1,Z), Y <- lists:seq(X,Z), math:pow(X,2) + math:pow(Y,2) == math:pow(Z,2)]. 

केवल list_m के साथ एक ही चीज़:

 P = do([list_m || Z <- lists:seq(1,20), X <- lists:seq(1,Z), Y <- lists:seq(X,Z), monad_plus:guard(list_m, math:pow(X,2) + math:pow(Y,2) == math:pow(Z,2)), return({X,Y,Z})]). 

• राज्य इकाई।
  स्टेटफुल कंप्यूटिंग का मोनाड।
  लेख की शुरुआत में, हमने चर राज्य के साथ काम करते समय शुरुआती लोगों की कठिनाइयों के बारे में बात की। अक्सर कोड कुछ इस तरह दिखता है:
  

   State1 = init(Dimensions), State2 = plant_seeds(SeedCount, State1), {DidFlood, State3} = pour_on_water(WaterVolume, State2), State4 = apply_sunlight(Time, State3), {DidFlood2, State5} = pour_on_water(WaterVolume, State4), {Crop, State6} = harvest(State5), ... 

एक ट्रांसफार्मर और कट-नोटेशन का उपयोग करते हुए, इस कोड को अधिक कॉम्पैक्ट और पठनीय रूप में फिर से लिखा जा सकता है:

 StateT = state_t:new(identity_m), SM = StateT:modify(_), SMR = StateT:modify_and_return(_), StateT:exec( do([StateT || StateT:put(init(Dimensions)), SM(plant_seeds(SeedCount, _)), DidFlood <- SMR(pour_on_water(WaterVolume, _)), SM(apply_sunlight(Time, _)), DidFlood2 <- SMR(pour_on_water(WaterVolume, _)), Crop <- SMR(harvest(_)), ... ]), undefined). 

• ओमेगा इकाई।
  List_m monad के समान। हालांकि, मार्ग तिरछे बना है।

छिपी त्रुटि से निपटने

शायद error_m की मेरी पसंदीदा विशेषताओं में से एक। कोई फर्क नहीं पड़ता कि त्रुटि कहां होती है, मोनड हमेशा {ok, Result} या {error, Reason} । व्यवहार को दर्शाने वाला एक उदाहरण:

 do([error_m || Hdl <- file:open(Path, Modes), Data <- file:read(Hdl, BytesToRead), file:write(Hdl, DataToWrite), file:sync(Hdl), file:close(Hdl), file:rename(Path, Path2), file:delete(Path), return(Data)]). 

Import_as

नाश्ते के लिए हमारे पास सिंटैक्स import_as चीनी है। -Import / 2 विशेषता के लिए मानक सिंटैक्स आपको स्थानीय मॉड्यूल में दूसरों से कार्यों को आयात करने की अनुमति देता है। हालाँकि, यह वाक्यविन्यास आपको आयातित फ़ंक्शन के लिए वैकल्पिक नाम निर्दिष्ट करने की अनुमति नहीं देता है। Import_as इस समस्या को हल करता है:

 -import_as({my_mod, [{size/1, m_size}]}) -import_as({my_other_mod, [{size/1, o_size}]}) 

इन अभिव्यक्तियों को क्रमशः वास्तविक स्थानीय कार्यों में विस्तारित किया जाता है:

 m_size(A) -> my_mod:size(A). o_size(A) -> my_other_mod:size(A). 

निष्कर्ष

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

* - वास्तव में, एर्लांग मोनाड में एरलैंडो के बिना मौजूद हैं। एक अल्पविराम को अलग करने वाले भाव रेखांकन और संगणना को जोड़ने का निर्माण है।

पुनश्च हाल ही में, एरलैंडो लाइब्रेरी को लेखकों द्वारा अभिलेखीय के रूप में चिह्नित किया गया था। मैंने यह लेख एक साल पहले लिखा था। फिर, हालांकि, अब के रूप में, Habré पर Erlang में भिक्षुओं पर कोई जानकारी नहीं थी। इस स्थिति को दूर करने के लिए, मैं यह लेख प्रकाशित कर रहा हूँ, भले ही यह लेख कितना भी अच्छा क्यों न हो।
Erlang> = 22 में erlando का उपयोग करने के लिए, आपको अपचित erlang: get_stacktrace / 0 के साथ समस्या को ठीक करना होगा। फिक्स का एक उदाहरण मेरे कांटे में पाया जा सकता है: https://github.com/Vonmo/erlando/commit/52e23ecedd2b8c13707a11c7f0f14496b5a19c2c2

आपके समय के लिए धन्यवाद!