Erlang 21 - 4. Match Specifications in Erlang

एर्लैंग में 4 मैच विनिर्देश




erlang

एर्लैंग में 4 मैच विनिर्देश

एक "मैच स्पेसिफिकेशन" ( match_spec ) एक match_spec शब्द है जो एक छोटे से "प्रोग्राम" का वर्णन करता है जो किसी चीज़ से मेल खाने की कोशिश करता है। इसका उपयोग erlang:trace_pattern/3 साथ ट्रेसिंग को नियंत्रित करने के लिए किया जा सकता है erlang:trace_pattern/3 या उदाहरण के लिए erlang:trace_pattern/3 तालिका में ऑब्जेक्ट्स के लिए खोज करने के लिए ets:select/2 । कई मायनों में मैच विनिर्देश एर्लांग में एक छोटे से कार्य की तरह काम करता है, लेकिन एर्लैंग रनटाइम सिस्टम द्वारा एर्लैंग फ़ंक्शन को कॉल करने की तुलना में कुछ अधिक कुशल के लिए व्याख्या / संकलित किया जाता है। वास्तविक एर्लैंग फ़ंक्शंस की स्पष्टता की तुलना में मैच विनिर्देश भी बहुत सीमित है।

एक मैच विनिर्देश और एक एरलंग मज़ा के बीच सबसे उल्लेखनीय अंतर वाक्यविन्यास है। मिलान विनिर्देशन Erlang शब्द हैं, Erlang कोड नहीं। इसके अलावा, एक मैच विनिर्देश में अपवादों की एक अजीब अवधारणा है:

  • MatchCondition भाग में एक अपवाद (जैसे badarg ), जो एक MatchCondition गार्ड जैसा दिखता है, तत्काल विफलता उत्पन्न करता है।

  • MatchBody भाग में एक अपवाद, जो एक MatchBody फ़ंक्शन के शरीर से मिलता जुलता है, को MatchBody रूप से पकड़ा जाता है और इसके परिणामस्वरूप एकल परमाणु 'EXIT'

4.1 व्याकरण

ट्रेसिंग में उपयोग किया जाने वाला एक मैच विनिर्देश निम्नलिखित अनौपचारिक व्याकरण में वर्णित किया जा सकता है:

  • MatchExpression :: = [MatchFunction, ...]
  • मैचफंक्शन :: = {मैचहेड, मैचकॉन्डिशन, मैचबॉडी}
  • MatchHead :: = MatchVariable | '_' | [मैचहेडपार्ट, ...]
  • मैचहेडपार्ट :: = टर्म () | मिलानयोग्य | '_'
  • मिलानयोग्य :: = '$ <संख्या>'
  • मैचकंडिशन :: = [मैचकंडिशन, ...] | []
  • मैचकंडिशन :: = {GuardFunction} | {GuardFunction, ConditionExpression, ...}
  • बूलफंक्शन :: = is_atom | is_float | is_integer | is_list | is_number | is_pid | is_port | is_reference | is_tuple | is_map | is_map_key | is_binary | is_function | is_record | is_seq_trace | 'and' | 'or' | 'not' | 'xor' | 'andalso' | 'orelse'
  • कंडीशन एक्सप्रेशन :: = ExprMatchVariable | {GuardFunction} | {GuardFunction, ConditionExpression, ...} | TermConstruct
  • ExprMatchVariable :: = MatchVariable (माचिस में बंधे) | '$_' | '$$'
  • टर्मकंस्ट्रक्ट = {{}} | {{ConditionExpression, ...}} | [] | [ConditionExpression, ...] | #{} | {{शब्द () => कंडीशन एक्सप्रेशन, ...} | NonCompositeTerm | स्थिर
  • NonCompositeTerm :: = अवधि () (सूची या टपल या मानचित्र नहीं)
  • लगातार :: = { const , टर्म ()}
  • GuardFunction :: = बूलफंक्शन | abs | element | hd | length | map_get | map_size | node | round | size | tl | trunc | '+' | '-' | '*' | | 'div' | 'rem' | | 'band' | 'bor' | 'bxor' | 'bnot' | 'bsl' | 'bsr' | '>' | '>=' | '<' | '=<' | '=:=' | '==' | '=/=' | '/=' | self | get_tcw
  • मैचबॉडी :: = [एक्शनटर्म]
  • एक्शनटर्म :: = कंडीशनएक्सप्रेशन | ActionCall
  • ActionCall :: = {ActionFunction} | {ActionFunction, ActionTerm, ...}
  • ActionFunction :: = set_seq_token | get_seq_token | message | return_trace | exception_trace | process_dump | enable_trace | disable_trace | trace | display | caller | set_tcw | silent

ets(3) में उपयोग किए जाने वाले एक मैच विनिर्देश का वर्णन निम्नलिखित अनौपचारिक व्याकरण में किया जा सकता है:

  • MatchExpression :: = [MatchFunction, ...]
  • मैचफंक्शन :: = {मैचहेड, मैचकॉन्डिशन, मैचबॉडी}
  • MatchHead :: = MatchVariable | '_' | {मैचहेडपार्ट, ...}
  • मैचहेडपार्ट :: = टर्म () | मिलानयोग्य | '_'
  • मिलानयोग्य :: = '$ <संख्या>'
  • मैचकंडिशन :: = [मैचकंडिशन, ...] | []
  • मैचकंडिशन :: = {GuardFunction} | {GuardFunction, ConditionExpression, ...}
  • बूलफंक्शन :: = is_atom | is_float | is_integer | is_list | is_number | is_pid | is_port | is_reference | is_tuple | is_map | map_is_key | is_binary | is_function | is_record | 'and' | 'or' | 'not' | 'xor' | 'andalso' | 'orelse'
  • कंडीशन एक्सप्रेशन :: = ExprMatchVariable | {GuardFunction} | {GuardFunction, ConditionExpression, ...} | TermConstruct
  • ExprMatchVariable :: = MatchVariable (माचिस में बंधे) | '$_' | '$$'
  • टर्मकंस्ट्रक्ट = {{}} | {{ConditionExpression, ...}} | [] | [ConditionExpression, ...] | # {} | {{शब्द () => कंडीशन एक्सप्रेशन, ...} | NonCompositeTerm | स्थिर
  • NonCompositeTerm :: = अवधि () (सूची या टपल या मानचित्र नहीं)
  • लगातार :: = { const , टर्म ()}
  • GuardFunction :: = बूलफंक्शन | abs | element | hd | length | map_get | map_size | node | round | size | tl | trunc | '+' | '-' | '*' | | 'div' | 'rem' | | 'band' | 'bor' | 'bxor' | 'bnot' | 'bsl' | 'bsr' | '>' | '>=' | '<' | '=<' | '=:=' | '==' | '=/=' | '/=' | self
  • मैचबॉडी :: = [कंडीशन एक्सप्रेशन, ...]

4.2 समारोह विवरण

सभी प्रकार के मिलान विनिर्देशों में अनुमत कार्य

match_spec के रूप में कार्य करने की अनुमति कार्य इस प्रकार हैं:

is_atom , is_atom , is_float , is_integer , is_list , is_number , is_pid , is_port , is_reference , is_tuple , is_map , is_binary

Erlang में संबंधित गार्ड परीक्षणों के रूप में ही, true या false लौटें।

is_record

एक अतिरिक्त पैरामीटर लेता है, जो {is_record, '$1', rectype, record_info(size, rectype)} तरह record_info(size, <record_type>) का परिणाम होना चाहिए।

'not'

अपने एकल तर्क को नकारता है ( false अलावा कुछ भी false देता false )।

'and'

true अगर इसके सभी तर्क (चर लंबाई तर्क सूची) true , अन्यथा false मूल्यांकन false । मूल्यांकन आदेश अपरिभाषित है।

'or'

यदि इसका कोई भी तर्क true मूल्यांकन करता true तो वापस लौटाता true । चर लंबाई तर्क सूची। मूल्यांकन आदेश अपरिभाषित है।

'andalso'

'and' रूप में काम करता है, लेकिन जब कोई तर्क किसी अन्य चीज़ का true से मूल्यांकन करता है, तो उसके तर्कों का मूल्यांकन करता true । तर्क का मूल्यांकन दाएं से बाएं किया जाता है।

'orelse'

'or' रूप में काम करता है, लेकिन जैसे ही इसका एक तर्क true मूल्यांकन करता है, उसका मूल्यांकन करता true । तर्क का मूल्यांकन दाएं से बाएं किया जाता है।

'xor'

केवल दो तर्क, जिनमें से एक true होना चाहिए और दूसरा false true को वापस करने के लिए; अन्यथा 'xor' गलत हो जाता है।

abs , element , hd , length , node , round , size , tl , trunc , '+' , '-' , '*' , 'div' , 'rem' , 'band' , 'bor' , 'bxor' , 'bnot' , 'bsl' , 'bsr' , '>' , '>=' , '<' , '=<' , '=:=' , '==' , '=/=' , '/=' , self

इसी Erlang BIFs (या ऑपरेटर) के रूप में भी। खराब तर्कों के मामले में, परिणाम संदर्भ पर निर्भर करता है। अभिव्यक्ति के MatchConditions भाग में, परीक्षण तुरंत विफल हो जाता है (जैसे एक एरलैंग गार्ड में)। MatchBody भाग में, अपवादों को स्पष्ट रूप से पकड़ा जाता है और परमाणु 'EXIT' में कॉल का परिणाम होता है।

केवल अनुरेखण के लिए अनुमत कार्य

कार्य केवल अनुरेखण कार्य के लिए अनुमति दी गई है:

is_seq_trace

यदि अनुक्रमिक ट्रेस टोकन वर्तमान प्रक्रिया के लिए सेट किया गया है, तो true है, अन्यथा false

set_seq_token

seq_trace:set_token/2 रूप में काम करता है, लेकिन सफलता पर true है, और त्रुटि या बुरे तर्क पर 'EXIT' । केवल MatchBody भाग में अनुमति दी गई है और केवल जब अनुरेखण की अनुमति है

get_seq_token

seq_trace:get_token/0 समान seq_trace:get_token/0 और ट्रेसिंग के MatchBody केवल MatchBody भाग में अनुमति दी।

message

भेजे गए ट्रेस संदेश में संलग्न एक अतिरिक्त संदेश सेट करता है। कोई केवल शरीर में एक अतिरिक्त संदेश सेट कर सकता है। बाद में कॉल किए गए संदेश को बदल देते हैं।

एक विशेष मामले के रूप में, {message, false} function {message, false} इस फ़ंक्शन कॉल के लिए ट्रेस संदेश ('कॉल' और 'रिटर्न_टो') भेजने में अक्षम करता है, ठीक उसी तरह जैसे कि मैच विनिर्देशन मेल नहीं खाता था। यह उपयोगी हो सकता है यदि MatchBody की MatchBody केवल साइड इफेक्ट वांछित हैं।

एक अन्य विशेष मामला {message, true} , जो डिफ़ॉल्ट व्यवहार सेट करता है, जैसे कि फ़ंक्शन का कोई मैच विनिर्देश नहीं था; ट्रेस संदेश बिना किसी अतिरिक्त जानकारी के भेजा जाता है (यदि message लिए कोई अन्य कॉल {message, true} से पहले नहीं रखा जाता है, तो यह वास्तव में एक "नोप" है)।

एक तर्क लेता है: संदेश। true लौटाता true और केवल MatchBody की MatchBody और जब ट्रेसिंग में इस्तेमाल किया जा सकता है।

return_trace

वर्तमान फ़ंक्शन से लौटने पर भेजे जाने वाले return_from ट्रेस संदेश का कारण return_from । कोई तर्क नहीं देता true , true और ट्रेसिंग के दौरान केवल MatchBody भाग में उपयोग किया जा सकता है। यदि प्रक्रिया ट्रेस फ़्लैग return_from सक्रिय है, तो return_from ट्रेस संदेश return_from है।

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

exception_trace

return_trace प्लस के रूप में काम करता है; यदि किसी exception_from ट्रेस किए गए फ़ंक्शन से बाहर निकलता है, तो एक exception_from ट्रेस संदेश उत्पन्न होता है, भले ही अपवाद पकड़ा गया हो या नहीं।

process_dump

बाइनरी के रूप में वर्तमान प्रक्रिया के बारे में कुछ पाठ्य जानकारी लौटाता है। कोई तर्क नहीं लेता है और ट्रेस करते समय केवल MatchBody भाग में अनुमति दी जाती है।

enable_trace

एक पैरामीटर के साथ यह फ़ंक्शन एरलैंग कॉल erlang:trace(self(), true, [P2]) जैसे ट्रेसिंग को चालू करता है, जहां P2 enable_trace का पैरामीटर है।

दो मापदंडों के साथ, पहला पैरामीटर या तो एक प्रक्रिया पहचानकर्ता या किसी प्रक्रिया का पंजीकृत नाम होना है। इस मामले में ट्रेसिंग को निर्दिष्ट प्रक्रिया के लिए उसी तरह से चालू किया जाता है जैसे कि एरलांग कॉल erlang:trace(P1, true, [P2]) , जहां P1 पहला और P2 दूसरा तर्क है। प्रक्रिया P1 अपने ट्रेस संदेशों को उसी अनुरेखक को भेजती है, जिस प्रक्रिया का उपयोग कथन निष्पादित करता है। P1 all से एक परमाणु नहीं हो सकता, new या existing (जब तक वे पंजीकृत नाम नहीं हैं)। P2 cpu_timestamp या tracer नहीं हो सकता।

true और ट्रेसिंग के दौरान केवल MatchBody भाग में उपयोग किया जा सकता है।

disable_trace

एक पैरामीटर के साथ यह फ़ंक्शन एरलैंग कॉल erlang:trace(self(), false, [P2]) तरह ट्रेसिंग को निष्क्रिय कर देता है, जहां P2 को निष्क्रिय करने का पैरामीटर है।

दो मापदंडों के साथ यह फ़ंक्शन Erlang कॉल erlang:trace(P1, false, [P2]) रूप में कार्य करता है erlang:trace(P1, false, [P2]) , जहां P1 एक प्रक्रिया पहचानकर्ता या पंजीकृत नाम हो सकता है और मैच विनिर्देश फ़ंक्शन के पहले तर्क के रूप में निर्दिष्ट किया जाता है। P2 cpu_timestamp या tracer नहीं हो सकता।

true और ट्रेसिंग के दौरान केवल MatchBody भाग में उपयोग किया जा सकता है।

trace

दो मापदंडों के साथ यह फ़ंक्शन पहले पैरामीटर के रूप में अक्षम करने के लिए ट्रेस झंडे की एक सूची लेता है और दूसरे पैरामीटर के रूप में सक्षम करने के लिए ट्रेस झंडे की एक सूची। तार्किक रूप से, अक्षम सूची को पहले लागू किया जाता है, लेकिन प्रभावी रूप से सभी परिवर्तनों को परमाणु रूप से लागू किया जाता है। ट्रेस झंडे erlang:trace/3 लिए समान हैं erlang:trace/3 , cpu_timestamp सहित नहीं, बल्कि tracer सहित।

यदि दोनों सूचियों में एक अनुरेखक निर्दिष्ट किया जाता है, तो सक्षम सूची में अनुरेखक पूर्वता लेता है। यदि कोई अनुरेखक निर्दिष्ट नहीं है, तो मैच विनिर्देश को निष्पादित करने वाली प्रक्रिया के रूप में एक ही अनुरेखक का उपयोग किया जाता है (मेटा ट्रेसर नहीं)। यदि उस प्रक्रिया में या तो अनुरेखक नहीं है, तो झंडे को नजरअंदाज कर दिया जाता है।

tracer module का उपयोग करते समय, माड्यूल को लोड किया जाना चाहिए ताकि मैच विनिर्देश निष्पादित किया जा सके। यदि इसे लोड नहीं किया जाता है, तो मैच विफल हो जाता है।

इस फ़ंक्शन के तीन मापदंडों के साथ, पहला या तो एक प्रक्रिया पहचानकर्ता है या ट्रेस झंडे सेट करने के लिए एक प्रक्रिया का पंजीकृत नाम है, दूसरा अक्षम सूची है, और तीसरा सक्षम सूची है।

यदि ट्रेस टारगेट प्रक्रिया के लिए कोई ट्रेस प्रॉपर्टी बदली गई थी, तो यह true है, अन्यथा false । ट्रेसिंग के दौरान केवल MatchBody की MatchBody में इस्तेमाल किया जा सकता है।

caller

कॉलिंग फ़ंक्शन को टपल के रूप में लौटाता है {Module, Function, Arity} या एटम undefined यदि कॉलिंग फ़ंक्शन निर्धारित नहीं किया जा सकता है। ट्रेसिंग के दौरान केवल MatchBody की MatchBody में इस्तेमाल किया जा सकता है।

ध्यान दें कि यदि "तकनीकी रूप से निर्मित फंक्शन" (जो कि एरलांग में नहीं लिखा गया है) का पता लगाया जाता है, तो caller फ़ंक्शन कभी-कभी परमाणु को undefined । ऐसी कॉल के दौरान कॉलिंग Erlang फ़ंक्शन उपलब्ध नहीं है।

display

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

get_tcw

कोई तर्क नहीं लेता है और नोड के ट्रेस नियंत्रण शब्द का मान लौटाता है। ऐसा ही erlang:system_info(trace_control_word) द्वारा किया जाता है।

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

set_tcw

एक अहस्ताक्षरित पूर्णांक तर्क देता है, नोड के ट्रेस कंट्रोल शब्द के मान को तर्क के मान पर सेट करता है, और पिछले मान को लौटाता है। वही erlang:system_flag(trace_control_word, Value) द्वारा किया जाता है erlang:system_flag(trace_control_word, Value) । ट्रेसिंग के दौरान केवल set_tcw में set_tcw का उपयोग करने की अनुमति है।

silent

एक तर्क देता है। यदि तर्क true , तो वर्तमान प्रक्रिया के लिए कॉल ट्रेस संदेश मोड इस कॉल के लिए चुप करने के लिए सेट है और सभी कॉल, MatchBody , कॉल ट्रेस संदेशों को बाधित किया जाता है, भले ही {message, true} को MatchBody भाग के लिए कहा जाता है समारोह का पता लगाया।

इस मोड को फ्लैग erlang:trace/3 से erlang:trace/3 भी सक्रिय किया जा सकता है।

यदि तर्क false , तो वर्तमान प्रक्रिया के लिए कॉल ट्रेस संदेश मोड इस कॉल के लिए सामान्य (गैर-मूक) और सभी बाद में कॉल करने के लिए सेट है।

यदि तर्क true या false नहीं true , तो कॉल ट्रेस संदेश मोड अप्रभावित है।

ध्यान दें

सभी "फंक्शन कॉल" ट्यूपल्स होने चाहिए, भले ही वे कोई तर्क न लें। self का मूल्य परमाणु () self , लेकिन {self} का मूल्य वर्तमान प्रक्रिया का पीआईडी ​​() है।

4.3 मैच का लक्ष्य

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

प्रसंग प्रकार मैच का लक्ष्य विवरण
ईटीएस {कुंजी, मान 1, मान 2, ...} एक टेबल ऑब्जेक्ट
निशान कॉल [Arg1, Arg2, ...] तर्क वितर्क
निशान भेजना [रिसीवर, संदेश] प्राप्त करने की प्रक्रिया / पोर्ट और संदेश शब्द
निशान 'प्राप्त करना' [नोड, प्रेषक, संदेश] नोड भेजना, प्रक्रिया / पोर्ट और संदेश शब्द

तालिका 4.1: संदर्भ के आधार पर मैच लक्ष्य

4.4 चर और साहित्य

चर '$<number>' का रूप लेते हैं, जहां <number> 0 और 100,000,000 (1e + 8) के बीच पूर्णांक होता है। इन सीमाओं के बाहर की संख्या अपरिभाषित है तो व्यवहार। MatchHead भाग में, विशेष चर MatchHead '_' किसी भी चीज से मेल खाता है, और कभी भी बाध्य नहीं होता है (जैसे MatchHead में _ )।

  • MatchCondition/MatchBody भागों में, कोई भी अनबाउंड वैरिएबल की अनुमति नहीं है, इसलिए '_' की व्याख्या स्वयं (एक परमाणु) के रूप में की जाती है। वैरिएबल केवल MatchHead भाग में बंधे हो सकते हैं।

  • MatchBody और MatchCondition भागों में, पहले से बंधे हुए चर का ही उपयोग किया जा सकता है।

  • एक विशेष मामले के रूप में, MatchCondition/MatchBody भागों में निम्नलिखित लागू होते हैं:

    • चर '$_' पूरे match target अवधि तक फैलता है।

    • चर '$$' क्रम में सभी बाध्य चर के मूल्यों की सूची में फैलता है (अर्थात, ['$1','$2', ...] )।

MatchHead भाग में, सभी शाब्दिक (उपरोक्त चर को छोड़कर) की व्याख्या "जैसा है" है।

MatchCondition/MatchBody भागों में, व्याख्या कुछ मायनों में अलग है। इन भागों में साहित्य या तो "जैसा है" लिखा जा सकता है, जो टुपल्स को छोड़कर या विशेष रूप से {const, T} का उपयोग करके सभी शाब्दिकों के लिए काम करता है, जहां T कोई भी इरलांग शब्द है।

मैच स्पेसिफिकेशन में टुपल लिटरल्स के लिए, डबल टपल कोष्ठक का भी उपयोग किया जा सकता है, अर्थात, उन्हें एक एकल ट्यूपल वाले एक प्रकार के ट्यूल के रूप में निर्माण करें, जिसका निर्माण किया जाना है। "डबल टूपल कोष्ठक" वाक्यविन्यास पहले से बंधे हुए चरों से ट्यूपल्स के निर्माण के लिए उपयोगी है, जैसे {{'$1', [a,b,'$2']}} । उदाहरण:

अभिव्यक्ति वैरिएबल बाइंडिंग परिणाम
{{ '$ 1', '$ 2'}} '$ 1' = ए, '$ 2' = बी {A, b}
{const, {'$ 1', '$ 2'}} असंगत {"$ 1 ',' $ 2 '}
असंगत
'$ 1' '$ 1' = [] []
[ '$ 1'] '$ 1' = [] [[]]
[{{ए}}] असंगत [{ए}]
42 असंगत 42
"नमस्ते" असंगत "नमस्ते"
$ 1 असंगत 49 ('1' अक्षर के लिए ASCII मान)

तालिका 4.2: मैचकांडिशन / मैचबॉडी के लिटरेचर एक मैच स्पेसिफिकेशन के हिस्से

4.5 मैच का निष्पादन

मैच की अभिव्यक्ति का निष्पादन, जब रनटाइम सिस्टम यह तय करता है कि क्या ट्रेस संदेश भेजा जाना है, इस प्रकार है:

MatchExpression सूची में प्रत्येक टपल के लिए और जबकि कोई मैच सफल नहीं हुआ है:

  • मैच लक्ष्य अवधि के विरुद्ध MatchHead भाग का मिलान करें, '$<number>' चर ( MatchHead में बहुत पसंद ets:match/2 ) को बांधकर। यदि MatchHead भाग तर्कों से मेल नहीं खा सकता है, तो मैच विफल हो जाता है।

  • प्रत्येक MatchCondition मूल्यांकन करें (जहां MatchHead भाग में पहले से बंधे केवल '$<number>' चर हो सकते हैं) और यह उम्मीद करते हैं कि यह परमाणु वापस आ जाएगा। जब कोई शर्त true मूल्यांकन नहीं करती true , तो मैच विफल हो जाता है। यदि कोई BIF कॉल अपवाद उत्पन्न करता है, तो मैच विफल भी हो जाता है।

  • दो मामले हो सकते हैं:

    • यदि ट्रेस करते समय मैच विनिर्देश निष्पादित हो रहा है:

      ActionTerm में उसी तरह से प्रत्येक ActionTerm मूल्यांकन करें, लेकिन वापसी मूल्यों को अनदेखा करें। इस हिस्से में चाहे जो भी हो, मैच सफल रहा है।

    • यदि ETS तालिका से वस्तुओं का चयन करते समय मिलान विनिर्देश निष्पादित किया जाता है:

      क्रम में अभिव्यक्तियों का मूल्यांकन करें और अंतिम अभिव्यक्ति का मूल्य लौटाएं (आमतौर पर इस संदर्भ में केवल एक ही अभिव्यक्ति है)।

ईटीएस और ट्रेसिंग में मैच विनिर्देशों के बीच 4.6 अंतर

ईटीएस मैच विनिर्देशों एक वापसी मूल्य का उत्पादन। आमतौर पर MatchBody में एक एकल ConditionExpression MatchBody होता है जो बिना किसी साइड इफेक्ट के रिटर्न वैल्यू को परिभाषित करता है। ETS संदर्भ में साइड इफेक्ट्स वाले कॉल की अनुमति नहीं है।

जब ट्रेसिंग का उत्पादन करने के लिए कोई वापसी मूल्य नहीं है, तो मैच विनिर्देश या तो मेल खाता है या नहीं। प्रभाव जब अभिव्यक्ति मिलान करता है तो लौटे शब्द के बजाय एक ट्रेस संदेश होता है। ActionTerm एस को एक अनिवार्य भाषा के रूप में निष्पादित किया जाता है, अर्थात उनके दुष्प्रभावों के लिए। ट्रेसिंग के दौरान साइड इफेक्ट्स वाले कार्यों की भी अनुमति है।

4.7 अनुरेखण उदाहरण

तीन की तर्क सूची से मिलान करें, जहां पहले और तीसरे तर्क बराबर हैं:

[{['$1', '_', '$1'],
  [],
  []}]

एक तर्क सूची को तीन से मिलाएं, जहां दूसरा तर्क संख्या> 3 है:

[{['_', '$1', '_'],
  [{ '>', '$1', 3}],
  []}]

एक तर्क सूची को तीन से मिलाएं, जहां तीसरा तर्क या तो एक तर्क और दो से युक्त एक ट्यूपल है, या एक तर्क और दो से शुरू होने वाली सूची (जो है, [a,b,[a,b,c]] या [a,b,{a,b}] ):

[{['$1', '$2', '$3'],
  [{'orelse', 
      {'=:=', '$3', {{'$1','$2'}}},
      {'and', 
        {'=:=', '$1', {hd, '$3'}},
        {'=:=', '$2', {hd, {tl, '$3'}}}}}],
  []}]

उपरोक्त समस्या को निम्नानुसार भी हल किया जा सकता है:

[{['$1', '$2', {'$1', '$2}], [], []},
 {['$1', '$2', ['$1', '$2' | '_']], [], []}]

दो तर्कों का मिलान करें, जहां पहली बार एक सूची के साथ एक शुरुआत है जो बदले में दूसरे तर्क समय के साथ शुरू होती है दो (यानी, [{[4,x],y},2] या [{[8], y, z},4]) :

[{['$1', '$2'],[{'=:=', {'*', 2, '$2'}, {hd, {element, 1, '$1'}}}],
  []}]

मैच तीन तर्क। जब तीनों समान हों और संख्याएँ हों, तो प्रक्रिया को ट्रेस संदेश में डंप करें, अन्यथा ट्रेस संदेश "जैसा है" होने दें, लेकिन क्रमिक ट्रेस टोकन लेबल को 4711 पर सेट करें:

[{['$1', '$1', '$1'],
  [{is_number, '$1'}],
  [{message, {process_dump}}]},
 {'_', [], [{set_seq_token, label, 4711}]}]

जैसा कि ऊपर उल्लेख किया गया है, पैरामीटर सूची को एक एकल MatchVariable या '_' विरुद्ध मिलान किया जा सकता है। एक एकल चर के साथ पूरे पैरामीटर सूची को बदलने के लिए एक विशेष मामला है। अन्य सभी मामलों में MatchHead एक उचित सूची होनी चाहिए।

ट्रेस संदेश उत्पन्न करें यदि ट्रेस नियंत्रण शब्द 1 पर सेट है:

[{'_',
  [{'==',{get_tcw},{const, 1}}],
  []}]

ट्रेस संदेश तभी उत्पन्न करें जब seq_trace टोकन हो:

[{'_',
  [{'==',{is_seq_trace},{const, 1}}],
  []}]

पहला तर्क 'verbose' होने पर 'silent' ट्रेस फ्लैग को हटा दें, और 'silent': होने पर इसे जोड़ें 'silent':

[{'$1',
  [{'==',{hd, '$1'},verbose}],
  [{trace, [silent],[]}]},
 {'$1',
  [{'==',{hd, '$1'},silent}],
  [{trace, [],[silent]}]}]

यदि फ़ंक्शन arity 3 का है, तो एक return_trace संदेश जोड़ें:

[{'$1',
  [{'==',{length, '$1'},3}],
  [{return_trace}]},
 {'_',[],[]}]

यदि फ़ंक्शन arity 3 का है, तो केवल एक ट्रेस संदेश उत्पन्न करें और पहला तर्क 'trace' :

[{['trace','$2','$3'],
  [],
  []},
 {'_',[],[]}]

4.8 ईटीएस उदाहरण

ईटीएस तालिका में सभी वस्तुओं का मिलान करें, जहां पहला तत्व परमाणु 'strider' और ट्यूल एरीटी 3 है, और पूरी वस्तु लौटाएं:

[{{strider,'_','_'},
  [],
  ['$_']}]

ETS तालिका में सभी वस्तुओं को>> 1 के साथ मिलाएं और पहला तत्व 'गैंडलफ' है, और वापसी तत्व 2:

[{'$1',
  [{'==', gandalf, {element, 1, '$1'}},{'>=',{size, '$1'},2}],
  [{element,2,'$1'}]}]

इस उदाहरण में, यदि पहला तत्व कुंजी था, तो MatchHead भाग की तुलना में MatchHead भाग में उस कुंजी का मिलान करना अधिक कुशल है। तालिकाओं के खोज स्थान को MatchHead संबंध में प्रतिबंधित किया MatchHead ताकि मिलान कुंजी के साथ केवल वस्तुओं को खोजा जा सके।

तीन तत्वों के मिलानों का मिलान करें, जहाँ दूसरा तत्व 'merry' या 'pippin' , और पूरी वस्तुओं को 'pippin' :

[{{'_',merry,'_'},
  [],
  ['$_']},
 {{'_',pippin,'_'},
  [],
  ['$_']}]

समारोह ets:test_ms/2> जटिल ईटीएस मैचों के परीक्षण के लिए उपयोगी हो सकता है।