अस्वीकरण: वर्णित टूल में विवादास्पद प्रतिष्ठा है। मैं इसे प्राप्त करने का आग्रह नहीं करता, जहां भी मुझे मिलता है, मैं केवल तकनीक के कुछ रोमांच को कम करने के लिए उपयोग की जाने वाली अवधारणाओं से खुद को परिचित करता हूं।

लिखित स्रोत और साथ ही लेख की एक पाठ प्रति जीथब पर मिल सकती है।

Parse_transform क्या है

parse_transform - संकलन से पहले एएसटी परिवर्तन तंत्र। निर्माण के अर्थ को बदलने के लिए बनाया गया है (शब्दार्थ), बिना एरलैंग के वाक्य रचना से परे।

दुर्भाग्य से, वेब पर इसके बारे में बहुत कम जानकारी है, जो गैर-गुरु युग के लिए प्रवेश सीमा को बहुत अधिक बनाता है।

हम क्या करेंगे

इस लेख में, मैं एएसटी एर्लांग के बारे में थोड़ी बात करता हूं, सरल परिवर्तनों का एक उदाहरण देता हूं, और एक स्टेटलेस gen_server बनाने के लिए parse_transform लिखने की प्रक्रिया भी दिखाता हूं (कार्य बहुत मायने नहीं रखता है, लेकिन यह एक उदाहरण के रूप में काम करेगा), और अंत में मैं एक लिंक दूंगा। शुरुआत ट्रांसफार्मर के एक सेट पर।

एर्लांग में एएसटी

बस मामले में: एएसटी परिभाषा

एएसटी को एक बार देखने के बजाय इसके विवरण को सौ बार पढ़ना बेहतर है। इसलिए, हम यह देखने के लिए एक छोटा मॉड्यूल लिखेंगे कि प्रत्येक पंक्ति कैसे रूपांतरित होती है।

तो, astdemo.erl के लिए स्रोत कोड:

-module(astdemo). -export([hello/0, hello/2]). hello() -> hello("world", 1). hello(_What, 0) -> ok; hello(What, Count) -> io:format("Hello, ~s~n", [What]), hello(What, Count - 1).

एएसटी को देखने के लिए, आपको इस फ़ाइल पर epp मॉड्यूल से parse_file फ़ंक्शन सेट करने की आवश्यकता है:

  Eshell V5.8.5 (^ G के साथ गर्भपात)
 1> {ठीक है, प्रपत्र} = epp: parse_file ("astdemo.erl", [], []], io: प्रारूप ("~ p ~ n", [प्रपत्र])।
 [{विशेषता, 1, फ़ाइल, {"astdemo.erl", 1}},
  {विशेषता, 1, मॉड्यूल, एस्टेमो},
  {विशेषता, 2, निर्यात, [{हैलो, 0}, {हैलो, 2}]},
  {फ़ंक्शन, 4, हैलो, 0,
            [{खंड, ४, [], [],
                     [{कॉल, ५,
                            {परमाणु, ५, नमस्ते},
                            [{स्ट्रिंग, 5, "दुनिया"}, {पूर्णांक, 5.1}]}]}]}}
  {फ़ंक्शन, 7, हैलो, 2,
            [{खंड, 7, [{var, 7, '_ What'}, {पूर्णांक, 7.0}], [], [{atom, 8, ok}]},
             {खंड, ९,
                     [{var, 9, 'What'}, {var, 9, 'Count'}],
                     []
                     [{कॉल, १०,
                            {दूरस्थ, १०, {परमाणु, १०, io}, {परमाणु, १०, प्रारूप}},
                            [{स्ट्रिंग, १०, "हेलो, ~ एस ~ एन"},
                             {विपक्ष, १०, {वर, १०, 'क्या'}, {शून्य, १०}}]},
                      {कॉल, ११,
                            {परमाणु, ११, नमस्ते},
                            [{var, 11, 'क्या'},
                             {op, 11, '-', {var, 11, 'Count'}, {पूर्णांक, 11,1}}}}]]]}},
  {ईओएफ, 12}]
 ठीक

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

Parse_transform / 2 फ़ंक्शन

चलिए अब एक डमी-पारसे_ट्रेनफॉर्म करते हैं, यह देखने के लिए कि हमें आगे क्या करना है। ऐसा करने के लिए, एक मॉड्यूल बनाएं जो परिवर्तन से निपटेगा, और एएसटी में हेरफेर करने के बजाय, बस इसे प्रिंट करें।

तो Demo_pt.erl :

 -module(demo_pt). -export([parse_transform/2]). parse_transform(Forms, _Options) -> io:format("~p~n", [Forms]), Forms.

Astdemo.erl में संबंधित निर्देश डालें:

 -module(astdemo). -compile({parse_transform, demo_pt}). -export([hello/0, hello/2]). ...........

हम संकलन करते हैं:

  Eshell V5.8.5 (^ G के साथ गर्भपात)
 1> c (astdemo)।
 [{विशेषता, 1, फ़ाइल, {"./ astdemo.erl", 1}},
  {विशेषता, 1, मॉड्यूल, एस्टेमो},
  {विशेषता, 3, निर्यात, [{हैलो, 0}, {हैलो, 2}]},
  {फ़ंक्शन, 5, हैलो, 0,
            [{खंड, ५, [], [],
                     [{कॉल, ६,
                            {परमाणु, ६, नमस्ते},
                            [{स्ट्रिंग, 6, "दुनिया"}, {पूर्णांक, 6.1}]}}]]}}
  {फ़ंक्शन, 8, हैलो, 2,
            [{खंड, 8, [{वर, cl, '_ क्या ’}, {पूर्णांक, },०}], [], [{परमाणु, ९, ठीक}]},
             {खंड, १०,
                     [{var, 10, 'What'}, {var, 10, 'Count'}],
                     []
                     [{कॉल, ११,
                            {दूरस्थ, 11, {परमाणु, 11, io}, {परमाणु, 11, प्रारूप}},
                            [{स्ट्रिंग, ११, "हेलो, ~ एस ~ एन"},
                             {cons, ११, {var, ११, 'क्या'}, {nil, ११}}}],
                      {कॉल, १२,
                            {परमाणु, १२, नमस्ते},
                            [{var, 12, 'क्या'},
                             {op, 12, '-', {var, 12, 'Count'}, {पूर्णांक, 12,1}}}}]]]}},
  {ईओएफ, 13}]
 {ठीक है, एस्टडेमो}

जैसा कि आप देख सकते हैं, एएसटी एक ही है (लाइन ब्रेक तक), लेकिन इस बार यह संकलन समय पर मुद्रित किया गया था।
यह ध्यान दिया जाना चाहिए कि संकलक निर्देशन एएसटी में पहले ही हटा दिया गया है जो परिवर्तन के लिए आया था।

विकल्पों में क्या व्यक्त किया गया है, जिज्ञासु पाठक शायद अपने दम पर पता लगाएगा। यह लेख एएसटी के बारे में है।

पहले परिवर्तन

आइए एक ऐसा कार्य करें जो प्रशिक्षण के लिए अभ्यास में बेकार है - फ़ंक्शन को "नमस्ते / 0" "हाय / 0" नाम दें। यह करना आसान होगा, क्योंकि हेलो / 0 को मॉड्यूल के भीतर से नहीं बुलाया जाता है, लेकिन केवल बाहर से बुलाए जाने की क्षमता है। इसलिए, यह निर्यात की सूची और फ़ंक्शन के शीर्षक को बदलने के लिए पर्याप्त है।

एकल रूप ट्रांसफार्मर

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

 % hello_to_hi replaces occurences of hello/0 with hi/0 hello_to_hi({attribute, Line, export, Exports}) -> % export attribute. Replace {hello, 0} with {hi, 0} HiExports = lists:map( fun ({hello, 0}) -> {hi, 0}; (E) -> E end, Exports), {attribute, Line, export, HiExports}; hello_to_hi({function, Line, hello, 0, Clauses}) -> % Header of hello/0. Just replace hello with hi {function, Line, hi, 0, Clauses}; hello_to_hi(Form) -> % Default: do not modify form Form.

अब सब एक साथ

हम इस फ़ंक्शन को parse_transform फ़ंक्शन का कोड बदलकर सक्षम करते हैं:

 parse_transform(Forms, _Options) -> HiForms = lists:map(fun hello_to_hi/1, Forms), io:format("~p~n", [HiForms]), HiForms.

हम Demo_pt को संकलित करते हैं , सुनिश्चित करें कि हम इसे गड़बड़ नहीं करते हैं।

चेक

हम नए ट्रांसफार्मर के साथ astdemo संकलित करने का प्रयास करते हैं:

  Eshell V5.8.5 (^ G के साथ गर्भपात)
 1> c (astdemo)।
 [{विशेषता, 1, फ़ाइल, {"./ astdemo.erl", 1}},
  {विशेषता, 1, मॉड्यूल, एस्टेमो},
  {विशेषता, 3, निर्यात, [{hi, 0}, {हैलो, 2}]},
  {फ़ंक्शन, 5, हाय, 0,
            [{खंड, ५, [], [],
                     [{कॉल, ६,
                            {परमाणु, ६, नमस्ते},
                            [{स्ट्रिंग, 6, "दुनिया"}, {पूर्णांक, 6.1}]}}]]}}
  {फ़ंक्शन, 8, हैलो, 2,
            [{खंड, 8, [{वर, cl, '_ क्या ’}, {पूर्णांक, },०}], [], [{परमाणु, ९, ठीक}]},
             {खंड, १०,
                     [{var, 10, 'What'}, {var, 10, 'Count'}],
                     []
                     [{कॉल, ११,
                            {दूरस्थ, 11, {परमाणु, 11, io}, {परमाणु, 11, प्रारूप}},
                            [{स्ट्रिंग, ११, "हेलो, ~ एस ~ एन"},
                             {cons, ११, {var, ११, 'क्या'}, {nil, ११}}}],
                      {कॉल, १२,
                            {परमाणु, १२, नमस्ते},
                            [{var, 12, 'क्या'},
                             {op, 12, '-', {var, 12, 'Count'}, {पूर्णांक, 12,1}}}}]]]}},
  {ईओएफ, 13}]
 {ठीक है, एस्टडेमो}
 2> अस्टेडेमो: हाय ()।
 नमस्ते दुनिया
 ठीक

वाह! जैसा उन्होंने चाहा, वैसा काम किया। कुछ और उपयोगी करने के लिए समय।

स्टेटलेस जीन_सर्वर parse_transform

कभी-कभी gen_server के व्यवहार के साथ एक मॉड्यूल लिखते समय, इसके साथ-साथ राज्य को खींचने की कोई आवश्यकता नहीं होती है, क्योंकि इसमें स्टोर करने के लिए कुछ भी नहीं होता है, और राज्य से handle_anything को अंतिम अभिव्यक्ति में खींचने से कोड बंद हो जाता है। आइए एक parse_transform करें जो हमें handle_call / 2, handle_cast / 1, handle_info / 1 को परिभाषित करने की अनुमति देता है। या नहीं। लेख को थोड़ा छोटा करने के लिए, मैं केवल परिवर्तन कर दिखाऊंगा हैंडल_call / 2 -> हैंडल_call / 3 , और जो लोग रुचि रखते हैं वे सब कुछ फिर से परिभाषित करेंगे।

संकल्पना

Gen_server के व्यवहार को handle_call (सादगी के लिए) की परिभाषा की आवश्यकता है इस तरह ( प्रलेखन ):

 handle_call(Request, From, State) -> ..... {reply,Reply,NewState}.

चूंकि हमें राज्य पर विचार करने की आवश्यकता से छुटकारा मिल गया है, इसलिए हमारा वाक्यविन्यास इस तरह से होना चाहिए:

 handle_call(Request, From) -> ..... Reply.

परिवर्तन योजना

ढूँढें और निर्यात handle_call / 2 से handle_call / 3 में बदलें
Handle_call / 2 के लिए फ़ंक्शन परिभाषाओं में , राज्य पैरामीटर जोड़ें और प्रत्येक क्लॉज़ में अंतिम उत्तर को {उत्तर, ..., राज्य} में फ़्रेम करें

बिल्ली

हम इस पर प्रशिक्षण देंगे। एक ट्रांसफॉर्मर की तुलना और लिखने के लिए हमारे सिंटैक्स और इसके एनालॉग में विहित रूप में हैंडल_call ।

 -module(sl_gs_demo). -behavior(gen_server). -compile({parse_transform, sl_gs}). -export([handle_call/2, ref_handle_call/3]). -export([handle_cast/2, handle_info/2]). -export([init/1, terminate/2, code_change/3]). % This will be transformed handle_call(Req, From) -> {Req, From}. % That's what handle_call should finally look like ref_handle_call(Req, From, State) -> {reply, {Req, From}, State}. % Dummy functions to make gen_server happy % Exercise: Try to insert them automatically during transformations :) handle_cast(_, State) -> {noreply, State}. handle_info(_, State) -> {noreply, State}. init(_) -> {ok, none}. terminate(_, _) -> ok. code_change(_, State, _) -> {ok, State}.

कोड

सब कुछ जैसा कि पिछली बार लिखा गया था - ईपीपी के आउटपुट को देख रहा था: parse_file और कस्टमाइज़ करना वही है जो आवश्यक है।

 -module(sl_gs). -export([parse_transform/2]). parse_transform(Forms, _Options) -> lists:map(fun add_missing_state/1, Forms). add_missing_state({attribute, Line, export, Exports}) -> % export attribute. Replace {handle_call, 2} with {handle_call, 3} NewExports = lists:map( fun ({handle_call, 2}) -> {handle_call, 3}; % You can add more clauses here for other function mutations (E) -> E end, Exports), {attribute, Line, export, NewExports}; add_missing_state({function, Line, handle_call, 2, Clauses}) -> % Mutate clauses NewClauses = lists:map(fun change_call_clause/1, Clauses), % Finally, change arity in header {function, Line, handle_call, 3, NewClauses}; add_missing_state(Form) -> % Default Form. change_call_clause({clause, Line, Arguments, Guards, Body}) -> % Change arity in clauses. NewArgs = Arguments ++ [{var, Line, 'State'}], % Add State argument % Then replace last statement of each clause with corresponding tuple NewBody = change_call_body(Body), {clause, Line, NewArgs, Guards, NewBody}. change_call_body([Statement | Rest=[_|_] ]) -> % Rest has to be non-empty list for this % Recurse to change only last statement [Statement|change_call_body(Rest)]; change_call_body([LastStatement]) -> % Put it into tuple. Lines are zero to omit parsing LastStatement [{tuple,0, [{atom,0,reply}, LastStatement, {var,0,'State'}] }].

स्वास्थ्य जाँच

  Eshell V5.8.5 (^ G के साथ गर्भपात)
 1> c (sl_gs_demo)।
 {ठीक है, sl_gs_demo}
 2> {ok, D} = gen_server: start_link (sl_gs_demo, [], [])।
 {ठीक है, <0.39.0>}
 3> gen_server: call (D, hello)।
 {हैलो, {<0.32.0>, # रेफ <0.0.0.83>}}

सफलता! यह उल्लू को खत्म करने और गीथूब पर रखने के लिए बनी हुई है।

परिणाम

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

विधि की आलोचना

सबसे पहले, parse_transform का उपयोग करके (यदि यह एक अलग परियोजना में है) आपकी परियोजना पर निर्भरता जोड़ता है। रिबार के मामले में, यह गैर-घातक है।
दूसरे, ऐसे कोड को पढ़ने वाले लोग (और विशेष रूप से संपादन) तुरंत अवधारणा को नहीं समझ सकते हैं। इसलिए, हमें न केवल अच्छे प्रलेखन की आवश्यकता है, बल्कि स्रोत की शुरुआत में इसे ध्यान देने योग्य लिंक भी चाहिए।
तीसरा, आपकी अपनी बोलियों को लिखने की क्षमता बहुत सीमित है। एएसटी आपके स्केलपेल के नीचे होने से पहले, यह एक नियमित पार्सर का काम करता है। इसलिए, पेचीदा कीवर्ड और अपने स्वयं के ऑपरेटरों की शुरूआत पार्सर को तोड़ सकती है, बहुत जटिल कार्य को जटिल कर सकती है।

Parse_trans लाइब्रेरी

parse_transform parse_transforms लिखने के लिए एक उपयोगी चीज है। यह आपको एक पेड़ के लिए एक पुनरावर्ती नक्शा बनाने की अनुमति देता है, जो एक चर गहराई पर अभिव्यक्ति को संशोधित करते समय बेहद उपयोगी है। उदाहरणों में, पुनर्लेखन का एक बहुत ही संक्षिप्त तरीका है "!" ऑपरेटर कॉल पर gproc: भेजें ।

Parse_transform का उपयोग करना