Erlang 21 - 8. The Abstract Format

8 सार स्वरूप




erlang

8 सार स्वरूप

यह खंड एर्लांग कार्यक्रमों के लिए पार्सल पेड़ों के मानक प्रतिनिधित्व का वर्णन करता है, जैसा कि एरलैंग के शब्दों में। यह प्रतिनिधित्व सार स्वरूप के रूप में जाना जाता है। इस तरह के पार्स पेड़ों से निपटने के कार्य compile:forms/1,2 और निम्नलिखित मॉड्यूल में कार्य:

  • epp(3)
  • erl_eval(3)
  • erl_lint(3)
  • erl_parse(3)
  • erl_pp(3)
  • io(3)

फ़ंक्शन का उपयोग पार्स ट्रांसफ़ॉर्म के लिए इनपुट और आउटपुट के रूप में भी किया जाता है, compile(3) मॉड्यूल देखें।

हम फ़ंक्शन Rep का उपयोग करते हैं, एरलंग स्रोत निर्माण C से मैपिंग को उसके अमूर्त प्रारूप प्रतिनिधित्व R , और R = Rep(C) लिखें।

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

जब ऑपरेटर अपने आप में नियम नहीं होते हैं, जब ऑपरेटरों का उल्लेख नीचे किया जाता है, तो ऑपरेटर के प्रतिनिधित्व को एक प्रिंटनाम के साथ परमाणु के रूप में लिया जाता है जिसमें ऑपरेटर के समान अक्षर होते हैं।

8.1 मॉड्यूल घोषणा और प्रपत्र

एक मॉड्यूल घोषणा में रूपों का एक क्रम होता है, जो या तो फ़ंक्शन घोषणाएं या विशेषताएं होती हैं।

  • यदि D एक मॉड्यूल घोषणा है जिसमें F_1 , ..., F_k , तो Rep (D) = [Rep(F_1), ..., Rep(F_k)]

  • यदि F एक विशेषता -export([Fun_1/A_1, ..., Fun_k/A_k]) , तो Rep (F) = {attribute,LINE,export,[{Fun_1,A_1}, ..., {Fun_k,A_k}]}

  • यदि F एक विशेषता -import(Mod,[Fun_1/A_1, ..., Fun_k/A_k]) , तो Rep (F) = {attribute,LINE,import,{Mod,[{Fun_1,A_1}, ..., {Fun_k,A_k}]}}

  • यदि F एक विशेषता -module(Mod) , तो Rep (F) = {attribute,LINE,module,Mod}

  • यदि F एक विशेषता -file(File,Line) , तो Rep (F) = {attribute,LINE,file,{File,Line}}

  • यदि F एक फ़ंक्शन घोषणा Name Fc_1 ; ... ; Name Fc_k Name Fc_1 ; ... ; Name Fc_k Name Fc_1 ; ... ; Name Fc_k , जहां प्रत्येक Fc_i समान लंबाई वाले पैटर्न के अनुक्रम के साथ एक फ़ंक्शन क्लॉज है, फिर Rep (F) = {function,LINE,Name,Arity,[Rep(Fc_1), ...,Rep(Fc_k)]}

  • यदि F एक फंक्शन स्पेसिफिकेशन है -Spec Name Ft_1; ...; Ft_k -Spec Name Ft_1; ...; Ft_k -Spec Name Ft_1; ...; Ft_k , जहां Spec या तो -Spec Name Ft_1; ...; Ft_k spec या परमाणु callback , और प्रत्येक Ft_i एक समान लंबाई Arity तर्क अनुक्रम के साथ एक संभवतः विवश फ़ंक्शन प्रकार है, फिर Rep (F) = {attribute,Line,Spec,{{Name,Arity},[Rep(Ft_1), ..., Rep(Ft_k)]}}

  • यदि F एक फंक्शन स्पेसिफिकेशन -spec Mod:Name Ft_1; ...; Ft_k -spec Mod:Name Ft_1; ...; Ft_k -spec Mod:Name Ft_1; ...; Ft_k , जहां प्रत्येक Ft_i एक समान लंबाई Arity तर्क अनुक्रम के साथ एक संभवतः विवश फ़ंक्शन प्रकार है, फिर Rep (F) = {attribute,Line,spec,{{Mod,Name,Arity},[Rep(Ft_1), ..., Rep(Ft_k)]}}

  • यदि F एक रिकॉर्ड घोषणापत्र है -record(Name,{V_1, ..., V_k}) , जहां प्रत्येक V_i एक रिकॉर्ड फ़ील्ड है, तो Rep (F) = {attribute,LINE,record,{Name,[Rep(V_1), ..., Rep(V_k)]}} । रेप (V) के लिए, नीचे देखें।

  • यदि F एक प्रकार की घोषणा है- -Type Name(V_1, ..., V_k) :: T , जहां Type या तो परमाणु type या परमाणु opaque , प्रत्येक V_i एक चर है, और T एक प्रकार है, तो Rep (F) ) = {attribute,LINE,Type,{Name,Rep(T),[Rep(V_1), ..., Rep(V_k)]}}

  • यदि F एक जंगली विशेषता -A(T) , तो Rep (F) = {attribute,LINE,A,T}

रिकॉर्ड फील्ड्स

रिकॉर्ड घोषणा में प्रत्येक क्षेत्र में एक वैकल्पिक, स्पष्ट, डिफ़ॉल्ट प्रारंभिक अभिव्यक्ति और एक वैकल्पिक प्रकार हो सकता है।

  • यदि V A , तो Rep (V) = {record_field,LINE,Rep(A)}

  • यदि V A = E , जहाँ E एक अभिव्यक्ति है, तो Rep (V) = {record_field,LINE,Rep(A),Rep(E)}

  • यदि V A :: T , जहाँ T एक प्रकार है, तो Rep (V) = {typed_record_field,{record_field,LINE,Rep(A)},Rep(T)}

  • यदि V A = E :: T , जहाँ E एक अभिव्यक्ति है और T एक प्रकार है, तो Rep (V) = {typed_record_field,{record_field,LINE,Rep(A),Rep(E)},Rep(T)}

पार्स एरर्स और एंड-ऑफ-फाइल का प्रतिनिधित्व

रूपों के निरूपण के अलावा, सूची जो एक मॉड्यूल घोषणा का प्रतिनिधित्व करती है (जैसा कि erl_parse(3) और erl_parse(3) में फ़ंक्शन द्वारा लौटाया जा सकता है) में निम्नलिखित शामिल हैं:

  • टुपल्स {error,E} और {warning,W} , वाक्यविन्यास गलत रूपों और चेतावनियों को दर्शाता है।

  • {eof,LOCATION} , एक पूर्ण प्रपत्र को पार्स किए जाने से पहले अंत-स्ट्रीम का सामना करते हुए। LOCATION शब्द एक पूर्णांक का प्रतिनिधित्व करता है, और स्रोत फ़ाइल में अंतिम पंक्ति की संख्या को दर्शाता है।

.२ परमाणु साहित्य

पांच प्रकार के परमाणु शाब्दिक हैं, जिन्हें पैटर्न, भाव और गार्ड में समान रूप से दर्शाया गया है:

  • यदि L एक परमाणु शाब्दिक है, तो Rep (L) = {atom,LINE,L}

  • यदि L एक अक्षर शाब्दिक है, तो Rep (L) = {char,LINE,L}

  • यदि L एक फ्लोट शाब्दिक है, तो Rep (L) = {float,LINE,L}

  • यदि L एक पूर्णांक शाब्दिक है, तो Rep (L) = {integer,LINE,L}

  • यदि L एक स्ट्रिंग शाब्दिक है जिसमें C_1 , ..., C_k , तो Rep (L) = {string,LINE,[C_1, ..., C_k]}

ध्यान दें कि नकारात्मक पूर्णांक और फ्लोट शाब्दिक रूप में ऐसा नहीं होता है; उन्हें अनार्य नकार ऑपरेटर के एक आवेदन के रूप में रखा गया है।

8.3 पैटर्न

यदि Ps पैटर्न P_1, ..., P_k का अनुक्रम है, तो Rep (Ps) = [Rep(P_1), ..., Rep(P_k)] । इस तरह के सीक्वेंस किसी फंक्शन या मस्ती के तर्कों की सूची के रूप में होते हैं।

व्यक्तिगत पैटर्न निम्नानुसार दर्शाए गए हैं:

  • यदि P एक परमाणु शाब्दिक L , तो Rep (P) = Rep (L) है।

  • यदि P एक बिटस्ट्रिंग पैटर्न है <<P_1:Size_1/TSL_1, ..., P_k:Size_k/TSL_k>> , जहाँ प्रत्येक Size_i एक अभिव्यक्ति है जिसका मूल्यांकन पूर्णांक में किया जा सकता है, और प्रत्येक TSL_i एक प्रकार की विशिष्ट सूची है, तब रेप (P) = {bin,LINE,[{bin_element,LINE,Rep(P_1),Rep(Size_1),Rep(TSL_1)}, ..., {bin_element,LINE,Rep(P_k),Rep(Size_k),Rep(TSL_k)}]} । रेप (TSL) के लिए, नीचे देखें। एक छोड़ा हुआ Size_i default से दर्शाया गया default । एक छोड़ा हुआ TSL_i default से दर्शाया गया default

  • यदि P एक यौगिक पैटर्न P_1 = P_2 , तो Rep (P) = {match,LINE,Rep(P_1),Rep(P_2)}

  • यदि P एक सामान्य पैटर्न है [P_h | P_t] [P_h | P_t] , फिर Rep (P) = {cons,LINE,Rep(P_h),Rep(P_t)}

  • यदि P एक मानचित्र पैटर्न #{A_1, ..., A_k} , जहां प्रत्येक A_i एक संघ P_i_1 := P_i_2 , तो Rep (P) = {map,LINE,[Rep(A_1), ..., Rep(A_k)]} । रेप (ए) के लिए, नीचे देखें।

  • यदि P एक नील प्रतिरूप है [] , तो Rep (P) = {nil,LINE}

  • यदि P एक ऑपरेटर पैटर्न है P_1 Op P_2 , जहां Op एक बाइनरी ऑपरेटर है (यह या तो ++ की एक घटना है जो शाब्दिक स्ट्रिंग या वर्ण सूची पर लागू होता है, या एक अभिव्यक्ति की घटना है जिसका संकलन समय पर एक संख्या के लिए किया जा सकता है। ), फिर रेप (P) = {op,LINE,Op,Rep(P_1),Rep(P_2)}

  • यदि P एक ऑपरेटर पैटर्न है Op P_0 , जहाँ Op एक unary ऑपरेटर है (यह एक अभिव्यक्ति की घटना है जिसका संकलन समय पर किसी संख्या पर किया जा सकता है), तो Rep (P) = {op,LINE,Op,Rep(P_0)}

  • यदि P एक कोष्ठक पैटर्न ( P_0 ) , तो Rep (P) = Rep(P_0) , यानी कोष्ठक प्रतिरूप उनके शरीर से अलग नहीं किया जा सकता है।

  • यदि P एक रिकॉर्ड फ़ील्ड इंडेक्स पैटर्न है #Name.Field , जहाँ Field एक परमाणु है, तो Rep (P) = {record_index,LINE,Name,Rep(Field)}

  • यदि P एक रिकॉर्ड पैटर्न है तो #Name{Field_1=P_1, ..., Field_k=P_k} , जहां प्रत्येक Field_i एक परमाणु या _ , फिर Rep (P) = {record,LINE,Name,[{record_field,LINE,Rep(Field_1),Rep(P_1)}, ..., {record_field,LINE,Rep(Field_k),Rep(P_k)}]}

  • यदि P एक tuple पैटर्न है {P_1, ..., P_k} , तो Rep (P) = {tuple,LINE,[Rep(P_1), ..., Rep(P_k)]}

  • यदि P एक सार्वभौमिक पैटर्न है _ , तो Rep (P) = {var,LINE,'_'}

  • यदि P एक वैरिएबल पैटर्न V , तो रेप (P) = {var,LINE,A} , जहां A एक ऐसा एटम है, जिसमें प्रिंटनाम है, जिसमें V के समान अक्षर हैं।

ध्यान दें कि प्रत्येक पैटर्न में कुछ अभिव्यक्ति के समान स्रोत होता है, और उसी अभिव्यक्ति के रूप में उसी तरह से दर्शाया जाता है।

8.4 अभिव्यक्तियाँ

A बॉडी B E_1, ..., E_k , और Rep (B) = [Rep(E_1), ..., Rep(E_k)] गैर-रिक्त अनुक्रम है।

एक अभिव्यक्ति E निम्नलिखित में से एक है:

  • यदि E एक परमाणु शाब्दिक L , तो Rep (E) = Rep (L) है।

  • यदि ई एक बिटस्ट्रिंग कॉम्प्रिहेंशन है <<E_0 || Q_1, ..., Q_k>> <<E_0 || Q_1, ..., Q_k>> , जहां प्रत्येक Q_i एक क्वालीफायर है, फिर Rep (E) = {bc,LINE,Rep(E_0),[Rep(Q_1), ..., Rep(Q_k)]} । रेप (Q) के लिए, नीचे देखें।

  • यदि E एक बिटस्ट्रिंग कंस्ट्रक्टर है <<E_1:Size_1/TSL_1, ..., E_k:Size_k/TSL_k>> , जहां प्रत्येक Size_i एक अभिव्यक्ति है और प्रत्येक TSL_i एक प्रकार की विशिष्ट सूची है, फिर Rep (E) = {bin,LINE,[{bin_element,LINE,Rep(E_1),Rep(Size_1),Rep(TSL_1)}, ..., {bin_element,LINE,Rep(E_k),Rep(Size_k),Rep(TSL_k)}]} । रेप (TSL) के लिए, नीचे देखें। एक छोड़ा हुआ Size_i default से दर्शाया गया default । एक छोड़ा हुआ TSL_i default से दर्शाया गया default

  • यदि E एक ब्लॉक एक्सप्रेशन है, जिसका begin B end B है, जहां B एक बॉडी है, तो Rep (E) = {block,LINE,Rep(B)}

  • यदि E एक केस एक्सप्रेशन case E_0 of Cc_1 ; ... ; Cc_k end case E_0 of Cc_1 ; ... ; Cc_k end case E_0 of Cc_1 ; ... ; Cc_k end , जहां E_0 एक अभिव्यक्ति है और प्रत्येक Cc_i एक केस क्लॉज है, फिर Rep (E) = {'case',LINE,Rep(E_0),[Rep(Cc_1), ..., Rep(Cc_k)]}

  • यदि E एक पकड़ने वाला अभिव्यक्ति catch E_0 , तो Rep (E) = {'catch',LINE,Rep(E_0)}

  • यदि E एक कंकाल कंकाल है [E_h | E_t] [E_h | E_t] , फिर Rep (E) = {cons,LINE,Rep(E_h),Rep(E_t)}

  • यदि E एक मजेदार अभिव्यक्ति fun Name/Arity , तो Rep (E) = {'fun',LINE,{function,Name,Arity}}

  • यदि ई एक मजेदार अभिव्यक्ति fun Module:Name/Arity , तो रेप (ई) = {'fun',LINE,{function,Rep(Module),Rep(Name),Rep(Arity)}} । (एर्लैंग / ओटीपी आर 15 से पहले: रेप (ई) = {'fun',LINE,{function,Module,Name,Arity}} ।)

  • यदि ई एक मजेदार अभिव्यक्ति fun Fc_1 ; ... ; Fc_k end fun Fc_1 ; ... ; Fc_k end fun Fc_1 ; ... ; Fc_k end , जहां प्रत्येक Fc_i एक फ़ंक्शन क्लॉज है, तब Rep (E) = {'fun',LINE,{clauses,[Rep(Fc_1), ..., Rep(Fc_k)]}}

  • यदि ई एक मजेदार अभिव्यक्ति fun Name Fc_1 ; ... ; Name Fc_k end fun Name Fc_1 ; ... ; Name Fc_k end fun Name Fc_1 ; ... ; Name Fc_k end , जहां Name एक चर है और प्रत्येक Fc_i एक फ़ंक्शन क्लॉज है, फिर Rep (E) = {named_fun,LINE,Name,[Rep(Fc_1), ..., Rep(Fc_k)]}

  • यदि E एक फ़ंक्शन कॉल E_0(E_1, ..., E_k) , तो Rep (E) = {call,LINE,Rep(E_0),[Rep(E_1), ..., Rep(E_k)]}

  • यदि E एक फ़ंक्शन कॉल है E_m:E_0(E_1, ..., E_k) , तो Rep (E) = {call,LINE,{remote,LINE,Rep(E_m),Rep(E_0)},[Rep(E_1), ..., Rep(E_k)]}

  • यदि E एक है if Ic_1 ; ... ; Ic_k end if Ic_1 ; ... ; Ic_k end if Ic_1 ; ... ; Ic_k end , जहां प्रत्येक Ic_i एक if खंड है, तो Rep (E) = {'if',LINE,[Rep(Ic_1), ..., Rep(Ic_k)]}

  • यदि E एक सूची [E_0 || Q_1, ..., Q_k] [E_0 || Q_1, ..., Q_k] , जहां प्रत्येक Q_i एक क्वालीफायर है, फिर Rep (E) = {lc,LINE,Rep(E_0),[Rep(Q_1), ..., Rep(Q_k)]} । रेप (Q) के लिए, नीचे देखें।

  • यदि E एक मानचित्र निर्माण #{A_1, ..., A_k} , जहाँ प्रत्येक A_i एक संगति E_i_1 => E_i_2 , तो Rep (E) = {map,LINE,[Rep(A_1), ..., Rep(A_k)]} । रेप (ए) के लिए, नीचे देखें।

  • यदि E एक मानचित्र अद्यतन E_0#{A_1, ..., A_k} , जहां प्रत्येक A_i एक संगति E_i_1 => E_i_2 या E_i_1 := E_i_2 , तो Rep (E) {map,LINE,Rep(E_0),[Rep(A_1), ..., Rep(A_k)]} । रेप (ए) के लिए, नीचे देखें।

  • यदि E एक मैच ऑपरेटर अभिव्यक्ति P = E_0 , जहां P एक पैटर्न है, तो Rep (E) = {match,LINE,Rep(P),Rep(E_0)}

  • यदि E nil है, [] , तो Rep (E) = {nil,LINE}

  • यदि E एक ऑपरेटर अभिव्यक्ति E_1 Op E_2 , जहां Op , मैच ऑपरेटर = अलावा एक बाइनरी ऑपरेटर है, तो Rep (E) = {op,LINE,Op,Rep(E_1),Rep(E_2)}

  • यदि E एक ऑपरेटर अभिव्यक्ति Op E_0 , जहाँ Op एक अपरेटिव ऑपरेटर है, तो Rep (E) = {op,LINE,Op,Rep(E_0)}

  • यदि E एक कोष्ठबद्ध अभिव्यक्ति ( E_0 ) , तो Rep (E) = Rep(E_0) , यानी कोष्ठक अभिव्यक्तियों को उनके शरीर से अलग नहीं किया जा सकता है।

  • यदि E एक प्राप्त अभिव्यक्ति receive Cc_1 ; ... ; Cc_k end receive Cc_1 ; ... ; Cc_k end receive Cc_1 ; ... ; Cc_k end , जहां प्रत्येक Cc_i एक केस क्लॉज है, फिर Rep (E) = {'receive',LINE,[Rep(Cc_1), ..., Rep(Cc_k)]}

  • यदि E एक प्राप्त अभिव्यक्ति receive Cc_1 ; ... ; Cc_k after E_0 -> B_t end receive Cc_1 ; ... ; Cc_k after E_0 -> B_t end receive Cc_1 ; ... ; Cc_k after E_0 -> B_t end , जहां प्रत्येक Cc_i एक केस क्लॉज है, E_0 एक अभिव्यक्ति है, और B_t एक शरीर है, फिर रेप (E) = {'receive',LINE,[Rep(Cc_1), ..., Rep(Cc_k)],Rep(E_0),Rep(B_t)}

  • यदि E एक रिकॉर्ड निर्माण है तो #Name{Field_1=E_1, ..., Field_k=E_k} , जहां प्रत्येक Field_i एक परमाणु या _ , फिर Rep (E) = {record,LINE,Name,[{record_field,LINE,Rep(Field_1),Rep(E_1)}, ..., {record_field,LINE,Rep(Field_k),Rep(E_k)}]}

  • यदि E एक रिकॉर्ड फ़ील्ड एक्सेस है E_0#Name.Field , जहाँ Field एक परमाणु है, तो Rep (E) = {record_field,LINE,Rep(E_0),Name,Rep(Field)}

  • यदि E एक रिकॉर्ड फ़ील्ड इंडेक्स है #Name.Field , जहाँ Field एक परमाणु है, तो Rep (E) = {record_index,LINE,Name,Rep(Field)}

  • यदि E एक रिकॉर्ड अपडेट है E_0#Name{Field_1=E_1, ..., Field_k=E_k} , जहां प्रत्येक Field_i एक परमाणु है, तो Rep (E) = {record,LINE,Rep(E_0),Name,[{record_field,LINE,Rep(Field_1),Rep(E_1)}, ..., {record_field,LINE,Rep(Field_k),Rep(E_k)}]}

  • यदि ई एक टपल कंकाल {E_1, ..., E_k} , तो रेप (E) = {tuple,LINE,[Rep(E_1), ..., Rep(E_k)]}

  • अगर ई एक कोशिश अभिव्यक्ति है try B catch Tc_1 ; ... ; Tc_k end try B catch Tc_1 ; ... ; Tc_k end try B catch Tc_1 ; ... ; Tc_k end , जहां B एक शरीर है और प्रत्येक Tc_i एक पकड़ क्लॉज़ है, तब Rep (E) = {'try',LINE,Rep(B),[],[Rep(Tc_1), ..., Rep(Tc_k)],[]}

  • यदि E try B of Cc_1 ; ... ; Cc_k catch Tc_1 ; ... ; Tc_n end एक कोशिश अभिव्यक्ति है try B of Cc_1 ; ... ; Cc_k catch Tc_1 ; ... ; Tc_n end try B of Cc_1 ; ... ; Cc_k catch Tc_1 ; ... ; Tc_n end try B of Cc_1 ; ... ; Cc_k catch Tc_1 ; ... ; Tc_n end , जहां B एक शरीर है, प्रत्येक Cc_i एक केस क्लॉज है, और प्रत्येक Tc_j एक कैच क्लॉज है, फिर Rep (E) = {'try',LINE,Rep(B),[Rep(Cc_1), ..., Rep(Cc_k)],[Rep(Tc_1), ..., Rep(Tc_n)],[]}

  • यदि E try B after A end करने वाला एक्सप्रेशन है, जहाँ B और A बॉडी हैं, तो Rep (E) = {'try',LINE,Rep(B),[],[],Rep(A)}

  • यदि E try B of Cc_1 ; ... ; Cc_k after A end एक कोशिश अभिव्यक्ति है try B of Cc_1 ; ... ; Cc_k after A end try B of Cc_1 ; ... ; Cc_k after A end try B of Cc_1 ; ... ; Cc_k after A end , जहां B और A एक निकाय हैं, और प्रत्येक Cc_i एक केस क्लॉज है, तब Rep (E) = {'try',LINE,Rep(B),[Rep(Cc_1), ..., Rep(Cc_k)],[],Rep(A)}

  • अगर ई एक कोशिश अभिव्यक्ति है try B catch Tc_1 ; ... ; Tc_k after A end try B catch Tc_1 ; ... ; Tc_k after A end try B catch Tc_1 ; ... ; Tc_k after A end , जहां B और A निकाय हैं, और प्रत्येक Tc_i एक पकड़ क्लॉज है, फिर Rep (E) = {'try',LINE,Rep(B),[],[Rep(Tc_1), ..., Rep(Tc_k)],Rep(A)}

  • यदि E try B of Cc_1 ; ... ; Cc_k catch Tc_1 ; ... ; Tc_n after A end एक कोशिश अभिव्यक्ति है try B of Cc_1 ; ... ; Cc_k catch Tc_1 ; ... ; Tc_n after A end try B of Cc_1 ; ... ; Cc_k catch Tc_1 ; ... ; Tc_n after A end try B of Cc_1 ; ... ; Cc_k catch Tc_1 ; ... ; Tc_n after A end , जहां B और A एक निकाय हैं, प्रत्येक Cc_i एक केस क्लॉज है, और प्रत्येक Tc_j एक कैच क्लॉज है, फिर Rep (E) = {'try',LINE,Rep(B),[Rep(Cc_1), ..., Rep(Cc_k)],[Rep(Tc_1), ..., Rep(Tc_n)],Rep(A)}

  • यदि E एक वैरिएबल V , तो रेप (E) = {var,LINE,A} , जहां A एक एटम है, जिसमें प्रिंटनाम है, जिसमें V के समान वर्ण हैं।

क्वालिफायर

एक क्वालिफायर Q निम्नलिखित में से एक है:

  • यदि Q एक फ़िल्टर E , जहाँ E एक अभिव्यक्ति है, तो Rep (Q) = Rep(E)

  • यदि Q एक जनरेटर है P <- E , जहां P एक पैटर्न है और E एक अभिव्यक्ति है, तो Rep (Q) = {generate,LINE,Rep(P),Rep(E)}

  • यदि Q एक बिटस्ट्रिंग जनरेटर है P <= E , जहां P एक पैटर्न है और E एक अभिव्यक्ति है, तो Rep (Q) = {b_generate,LINE,Rep(P),Rep(E)}

बिटस्ट्रिंग तत्व प्रकार विनिर्देशक

बिटस्ट्रिंग तत्व के लिए एक टाइप स्पेसिफ़ायर सूची TSL टाइप TS_1 - ... - TS_k , और Rep (TSL) = [Rep(TS_1), ..., Rep(TS_k)]

  • यदि TS एक प्रकार निर्दिष्ट करने वाला A , जहाँ A एक परमाणु है, तो Rep (TS) = A।

  • यदि TS एक प्रकार निर्दिष्ट करता है A:Value , जहां A एक परमाणु है और Value एक पूर्णांक है, तो Rep (TS) = {A,Value}

संघों

एसोसिएशन ए निम्नलिखित में से एक है:

  • यदि A एक संघ K => V , तो Rep (A) = {map_field_assoc,LINE,Rep(K),Rep(V)}

  • यदि A एक संघ K := V , तो Rep (A) = {map_field_exact,LINE,Rep(K),Rep(V)}

8.5 खंड

फ़ंक्शन क्लॉज़ हैं, यदि क्लॉज़, केस क्लॉज़ और क्लॉस पकड़ते हैं।

एक खंड C निम्नलिखित में से एक है:

  • यदि C एक केस क्लॉज है P -> B , जहां P एक पैटर्न है और B एक बॉडी है, तो Rep (C) = {clause,LINE,[Rep(P)],[],Rep(B)}

  • यदि C एक केस क्लॉज P when Gs -> B , जहां P एक पैटर्न है, Gs एक गार्ड अनुक्रम है, और B एक बॉडी है, तो Rep (C) = {clause,LINE,[Rep(P)],Rep(Gs),Rep(B)}

  • यदि C एक पकड़ क्लॉज है P -> B , जहाँ P एक पैटर्न है और B एक बॉडी है, तो Rep (C) = {clause,LINE,[Rep({throw,P,_})],[],Rep(B)} , {clause,LINE,[Rep({throw,P,_})],[],Rep(B)} , एक स्पष्ट अपवाद वर्ग throw साथ या एक स्पष्ट स्टैकट्रेस चर _ साथ या बिना एक स्पष्ट खंड के साथ एक पकड़ क्लॉज को एक स्पष्ट अपवाद वर्ग के बिना और एक स्पष्ट स्टैकट्रेस चर के बिना एक पकड़ क्लॉज से अलग नहीं किया जा सकता है।

  • यदि C एक पकड़ क्लॉज है X : P -> B , जहां X एक परमाणु शाब्दिक या एक वैरिएबल पैटर्न है, P एक पैटर्न है, और B एक बॉडी है, तो Rep (C) = {clause,LINE,[Rep({X,P,_})],[],Rep(B)} , यानी, एक स्पष्ट अपवाद वर्ग के साथ एक पकड़ खंड और एक स्पष्ट स्टैकट्रेस चर _ साथ एक स्पष्ट अपवाद वर्ग के साथ और बिना एक पकड़ खंड से अलग नहीं किया जा सकता है एक स्पष्ट स्टैकट्रेस चर।

  • यदि C एक पकड़ क्लॉज है X : P : S -> B , जहां X एक परमाणु शाब्दिक या एक वैरिएबल पैटर्न है, P एक पैटर्न है, S एक वैरिएबल है, और B एक बॉडी है, तो Rep (C) = {clause,LINE,[Rep({X,P,S})],[],Rep(B)}

  • यदि P when Gs -> B , जहां P एक पैटर्न है, तो C एक पकड़ क्लॉज P when Gs -> B , Gs एक गार्ड अनुक्रम है, और B एक बॉडी है, तो Rep (C) = {clause,LINE,[Rep({throw,P,_})],Rep(Gs),Rep(B)} , यानी, एक स्पष्ट अपवाद वर्ग throw साथ और एक स्पष्ट स्टैकट्रेस चर के साथ या बिना एक स्पष्ट पकड़ है। एक स्पष्ट अपवाद वर्ग के बिना एक पकड़ खंड से अलग नहीं किया जा सकता है और एक स्पष्ट स्टैकट्रेस चर के बिना।

  • यदि C एक पकड़ खंड X : P when Gs -> B , जहां X एक परमाणु शाब्दिक या एक चर पैटर्न है, P एक पैटर्न है, Gs एक गार्ड अनुक्रम है, और B एक शरीर है, तो Rep (C) = {clause,LINE,[Rep({X,P,_})],Rep(Gs),Rep(B)} , {clause,LINE,[Rep({X,P,_})],Rep(Gs),Rep(B)} , एक स्पष्ट अपवाद वर्ग के साथ एक पकड़ खंड और एक स्पष्ट स्टेक्ट्रेस वेरिएंट _ से अलग नहीं किया जा सकता है एक स्पष्ट अपवाद वर्ग और एक स्पष्ट स्टैकट्रेस चर के साथ एक पकड़ क्लॉज।

  • यदि C एक पकड़ क्लॉज है X : P : S when Gs -> B , जहां X एक परमाणु शाब्दिक या एक वैरिएबल पैटर्न है, P एक पैटर्न है, Gs एक गार्ड अनुक्रम है, S एक वेरिएबल है, और B एक बॉडी है, फिर रेप (C) = {clause,LINE,[Rep({X,P,S})],Rep(Gs),Rep(B)}

  • यदि C एक फ़ंक्शन क्लॉज़ ( Ps ) -> B , जहां Ps एक पैटर्न अनुक्रम है और B एक बॉडी है, तो Rep (C) = {clause,LINE,Rep(Ps),[],Rep(B)}

  • यदि C एक फ़ंक्शन क्लॉज ( Ps ) when Gs -> B , जहां Ps एक पैटर्न अनुक्रम है, Gs एक गार्ड अनुक्रम है और B एक शरीर है, तो Rep (C) = {clause,LINE,Rep(Ps),Rep(Gs),Rep(B)}

  • यदि C एक क्लॉज Gs -> B , जहां Gs एक गार्ड अनुक्रम है और B एक बॉडी है, तो Rep (C) = {clause,LINE,[],Rep(Gs),Rep(B)}

8.6 गार्ड

एक गार्ड अनुक्रम Gs गार्ड G_1; ...; G_k का एक अनुक्रम है G_1; ...; G_k G_1; ...; G_k G_1; ...; G_k , और Rep (Gs) = [Rep(G_1), ..., Rep(G_k)] । यदि गार्ड अनुक्रम खाली है, तो रेप (Gs) = []

एक गार्ड G Gt_1, ..., Gt_k , और Rep (G) = [Rep(Gt_1), ..., Rep(Gt_k)] गैर-खाली अनुक्रम है।

एक गार्ड परीक्षण Gt निम्नलिखित में से एक है:

  • यदि Gt एक परमाणु शाब्दिक L , तो Rep (Gt) = Rep (L) है।

  • यदि Gt एक बिटस्ट्रिंग कंस्ट्रक्टर है <<Gt_1:Size_1/TSL_1, ..., Gt_k:Size_k/TSL_k>> , जहां प्रत्येक Size_i एक गार्ड परीक्षण है और प्रत्येक TSL_i एक विशिष्ट प्रकार की सूची है, फिर Rep (Gt) = {bin,LINE,[{bin_element,LINE,Rep(Gt_1),Rep(Size_1),Rep(TSL_1)}, ..., {bin_element,LINE,Rep(Gt_k),Rep(Size_k),Rep(TSL_k)}]} । रेप (TSL) के लिए, ऊपर देखें। एक छोड़ा हुआ Size_i default से दर्शाया गया default । एक छोड़ा हुआ TSL_i default से दर्शाया गया default

  • यदि Gt एक कंकाल कंकाल है [Gt_h | Gt_t] [Gt_h | Gt_t] , फिर रेप (Gt) = {cons,LINE,Rep(Gt_h),Rep(Gt_t)}

  • यदि Gt एक फ़ंक्शन कॉल A(Gt_1, ..., Gt_k) , जहाँ A एक परमाणु है, तो Rep (Gt) = {call,LINE,Rep(A),[Rep(Gt_1), ..., Rep(Gt_k)]}

  • यदि Gt एक फ़ंक्शन कॉल है A_m:A(Gt_1, ..., Gt_k) , जहां A_m परमाणु का A_m है और A एक परमाणु या ऑपरेटर है, तो Rep (Gt) = {call,LINE,{remote,LINE,Rep(A_m),Rep(A)},[Rep(Gt_1), ..., Rep(Gt_k)]}

  • यदि Gt एक मानचित्र निर्माण #{A_1, ..., A_k} , जहां प्रत्येक A_i एक संघ Gt_i_1 => Gt_i_2 , तो Rep (Gt) = {map,LINE,[Rep(A_1), ..., Rep(A_k)]} । रेप (ए) के लिए, ऊपर देखें।

  • यदि Gt एक मैप अपडेट है, तो Gt_0#{A_1, ..., A_k} , जहां प्रत्येक A_i एक एसोसिएशन है Gt_i_1 => Gt_i_2 या Gt_i_1 := Gt_i_2 , फिर Rep (Gt) = {map,LINE,Rep(Gt_0),[Rep(A_1), ..., Rep(A_k)]} । रेप (ए) के लिए, ऊपर देखें।

  • यदि Gt nil है, [] , तो Rep (Gt) = {nil,LINE}

  • यदि Gt एक ऑपरेटर गार्ड टेस्ट है Gt_1 Op Gt_2 , जहाँ Op एक द्विआधारी ऑपरेटर है जो मैच ऑपरेटर = , तो Rep (Gt) = {op,LINE,Op,Rep(Gt_1),Rep(Gt_2)}

  • यदि Gt एक ऑपरेटर गार्ड परीक्षण Op Gt_0 , जहां Op एक Op Gt_0 ऑपरेटर है, तो Rep (Gt) = {op,LINE,Op,Rep(Gt_0)}

  • यदि Gt एक ( Gt_0 ) परीक्षण ( Gt_0 ) , तो Rep (Gt) = Rep(Gt_0) , यानी कोष्ठक Rep(Gt_0) परीक्षण को उनके शरीर से अलग नहीं किया जा सकता है।

  • यदि Gt एक रिकॉर्ड निर्माण है #Name{Field_1=Gt_1, ..., Field_k=Gt_k} , जहां प्रत्येक Field_i एक परमाणु या _ , तो Rep (Gt) = {record,LINE,Name,[{record_field,LINE,Rep(Field_1),Rep(Gt_1)}, ..., {record_field,LINE,Rep(Field_k),Rep(Gt_k)}]}

  • यदि Gt एक रिकॉर्ड फ़ील्ड एक्सेस Gt_0#Name.Field , जहाँ Field एक परमाणु है, तो Rep (Gt) = {record_field,LINE,Rep(Gt_0),Name,Rep(Field)}

  • यदि Gt एक रिकॉर्ड फ़ील्ड इंडेक्स #Name.Field , जहाँ Field एक परमाणु है, तो Rep (Gt) = {record_index,LINE,Name,Rep(Field)}

  • अगर Gt एक टपल कंकाल {Gt_1, ..., Gt_k} , तो Rep (Gt) = {tuple,LINE,[Rep(Gt_1), ..., Rep(Gt_k)]}

  • यदि Gt एक वैरिएबल पैटर्न V , तो Rep (Gt) = {var,LINE,A} , जहां A एक ऐसा प्रिंटनाम है, जिसमें V के समान अक्षर वाले प्रिंटनाम होते हैं।

ध्यान दें कि प्रत्येक गार्ड परीक्षण में कुछ अभिव्यक्ति के समान स्रोत होता है, और इसी अभिव्यक्ति के रूप में उसी तरह का प्रतिनिधित्व किया जाता है।

8.7 प्रकार

  • यदि T एक एनोटेट टाइप A :: T_0 , जहां A एक वेरिएबल है, तो Rep (T) = {ann_type,LINE,[Rep(A),Rep(T_0)]}

  • यदि T एक परमाणु या पूर्णांक शाब्दिक L है, तो Rep (T) = Rep (L) है।

  • यदि T एक बिटस्ट्रिंग प्रकार है <<_:M,_:_*N>> , जहां M और N एक सिंगलटन पूर्णांक प्रकार हैं, तो Rep (T) = {type,LINE,binary,[Rep(M),Rep(N)]}

  • यदि T खाली सूची प्रकार है [] , तो Rep (T) = {type,Line,nil,[]}

  • यदि टी एक मजेदार प्रकार का fun() , तो रेप (टी) = {type,LINE,'fun',[]}

  • यदि T एक मजेदार प्रकार का fun((...) -> T_0) , तो Rep (T) = {type,LINE,'fun',[{type,LINE,any},Rep(T_0)]}

  • यदि T एक फन टाइप fun(Ft) , जहां Ft एक फंक्शन टाइप है, तो रेप (T) = Rep(Ft) । रेप (फीट) के लिए, नीचे देखें।

  • यदि T एक पूर्णांक श्रेणी प्रकार L .. H , जहाँ L और H सिंगलटन पूर्णांक प्रकार हैं, तो Rep (T) = {type,LINE,range,[Rep(L),Rep(H)]}

  • यदि T एक मानचित्र प्रकार का map() , तो Rep (T) = {type,LINE,map,any}

  • यदि T एक मानचित्र प्रकार #{A_1, ..., A_k} , जहां प्रत्येक A_i एक संघ प्रकार है, तो Rep (T) = {type,LINE,map,[Rep(A_1), ..., Rep(A_k)]} । रेप (ए) के लिए, नीचे देखें।

  • यदि T एक ऑपरेटर प्रकार T_1 Op T_2 , जहां Op एक बाइनरी ऑपरेटर है (यह एक अभिव्यक्ति की घटना है जिसका संकलन समय पर एक पूर्णांक में मूल्यांकन किया जा सकता है), तो Rep (T) = {op,LINE,Op,Rep(T_1),Rep(T_2)}

  • यदि T एक ऑपरेटर प्रकार है Op T_0 , जहाँ Op एक unary ऑपरेटर है (यह एक अभिव्यक्ति की घटना है जिसका संकलन समय पर पूर्णांक में मूल्यांकन किया जा सकता है), तो Rep (T) = {op,LINE,Op,Rep(T_0)}

  • यदि T ( T_0 ) , तो Rep (T) = Rep(T_0) , यानी कोष्ठक प्रकार उनके शरीर से अलग नहीं किए जा सकते।

  • यदि T एक पूर्वनिर्धारित (या अंतर्निहित) प्रकार N(T_1, ..., T_k) , तो Rep (T) = {type,LINE,N,[Rep(T_1), ..., Rep(T_k)]}

  • यदि T एक रिकॉर्ड प्रकार है #Name{F_1, ..., F_k} , जहां प्रत्येक F_i एक रिकॉर्ड फ़ील्ड प्रकार है, तो Rep (T) = {type,LINE,record,[Rep(Name),Rep(F_1), ..., Rep(F_k)]} । रेप (एफ) के लिए, नीचे देखें।

  • यदि T एक दूरस्थ प्रकार M:N(T_1, ..., T_k) , तो Rep (T) = {remote_type,LINE,[Rep(M),Rep(N),[Rep(T_1), ..., Rep(T_k)]]}

  • यदि T एक टुपल टाइप tuple() , तो Rep (T) = {type,LINE,tuple,any}

  • यदि T एक {T_1, ..., T_k} टाइप {T_1, ..., T_k} , तो रेप (T) = {type,LINE,tuple,[Rep(T_1), ..., Rep(T_k)]}

  • यदि T एक प्रकार है तो संघ T_1 | ... | T_k T_1 | ... | T_k T_1 | ... | T_k , फिर Rep (T) = {type,LINE,union,[Rep(T_1), ..., Rep(T_k)]}

  • यदि T एक प्रकार का चर V , तो Rep (T) = {var,LINE,A} , जहां A एक ऐसा परमाणु है, जिसमें प्रिंटनाम V के समान अक्षर होते हैं। एक प्रकार का चर अंडरस्कोर ( _ ) को छोड़कर कोई भी चर है।

  • यदि T एक यूज़र-डिफ़ाइंड टाइप N(T_1, ..., T_k) , तो Rep (T) = {user_type,LINE,N,[Rep(T_1), ..., Rep(T_k)]}

समारोह के प्रकार

एक फ़ंक्शन प्रकार फीट निम्न में से एक है:

  • यदि Ft_1 when Fc कारण Ft एक Ft_1 when Fc फ़ंक्शन प्रकार है, तो Ft_1 when Fc , जहाँ फ़ंक्शन फ़ंक्शन एक फ़ंक्शन प्रकार है और Fc एक फ़ंक्शन बाधा है, तो Rep (T) = {type,LINE,bounded_fun,[Rep(Ft_1),Rep(Fc)]} । रेप (एफसी) के लिए, नीचे देखें।

  • यदि Ft एक फ़ंक्शन प्रकार (T_1, ..., T_n) -> T_0 , जहां प्रत्येक T_i एक प्रकार है, तो प्रतिनिधि (फीट) = {type,LINE,'fun',[{type,LINE,product,[Rep(T_1), ..., Rep(T_n)]},Rep(T_0)]}

कार्य बाधा

एक फ़ंक्शन बाधा Fc C_1, ..., C_k , और Rep (Fc) = [Rep(C_1), ..., Rep(C_k)] की कमी का एक गैर-रिक्त अनुक्रम है।

  • यदि C एक बाधा V :: T , जहां V एक प्रकार का चर है और T एक प्रकार है, तो Rep (C) = {type,LINE,constraint,[{atom,LINE,is_subtype},[Rep(V),Rep(T)]]}

एसोसिएशन के प्रकार

  • यदि A एक संघ प्रकार K => V , जहाँ K और V प्रकार हैं, तो Rep (A) = {type,LINE,map_field_assoc,[Rep(K),Rep(V)]}

  • यदि A एक एसोसिएशन प्रकार K := V , जहां K और V टाइप हैं, तो Rep (A) = {type,LINE,map_field_exact,[Rep(K),Rep(V)]}

रिकॉर्ड फ़ील्ड प्रकार

  • यदि F एक रिकॉर्ड फ़ील्ड प्रकार है Name :: Type , जहाँ Type एक प्रकार है, तो Rep (F) = {type,LINE,field_type,[Rep(Name),Rep(Type)]}

8.8 प्रीप्रोसेसिंग के बाद सार स्वरूप

संकलन विकल्प debug_info को कंपाइलर के लिए निर्दिष्ट किया जा सकता है जिसमें अमूर्त कोड को Beam फ़ाइल (डिबगिंग उद्देश्यों के लिए) में abstract_code chunk में संग्रहीत किया गया है।

एर्लैंग / ओटीपी आर 9 सी के रूप में, abstract_code चंक में {raw_abstract_v1,AbstractCode} , जहां AbstractCode सार कोड है जैसा कि इस खंड में वर्णित है।

R9C से पहले OTP रिलीज़ में, कुछ और प्रोसेसिंग के बाद अमूर्त कोड बीम फ़ाइल में संग्रहीत किया गया था। टपल का पहला तत्व या तो abstract_v1 (OTP R7B में) या abstract_v2 (OTP R8B में) होगा।