Elixir 1.7

Kernel




elixir

Kernel

Kernel एलिक्सिर का डिफ़ॉल्ट वातावरण है।

इसमें मुख्य रूप से शामिल हैं:

  • बुनियादी भाषा आदिम, जैसे अंकगणितीय ऑपरेटर, प्रक्रियाओं की स्पैनिंग, डेटा टाइप हैंडलिंग आदि
  • नियंत्रण-प्रवाह और नई कार्यक्षमता को परिभाषित करने के लिए मैक्रोज़ (मॉड्यूल, फ़ंक्शन, और इसी तरह)
  • पैटर्न मिलान बढ़ाने के लिए guard जाँच

आप Kernel फ़ंक्शंस / मैक्रोज़ का उपयोग एलिक्सिर कोड में कहीं भी Kernel उपसर्ग के बिना कर सकते हैं क्योंकि इसके सभी फ़ंक्शंस और मैक्रोज़ स्वचालित रूप से आयात किए जाते हैं। उदाहरण के लिए, IEx में:

iex> is_number(13)
true

यदि आप Kernel से फ़ंक्शन या मैक्रो आयात नहीं करना चाहते हैं, तो इसका उपयोग करें :except विकल्प :except और फिर फ़ंक्शन / मैक्रो को arity द्वारा सूचीबद्ध करें:

import Kernel, except: [if: 2, unless: 2]

आयात करने के बारे में अधिक जानकारी के लिए Kernel.SpecialForms.import/2 देखें।

अमृत ​​के भी विशेष रूप होते हैं जिन्हें हमेशा आयात किया जाता है और इन्हें छोड़ा नहीं जा सकता। ये Kernel.SpecialForms में वर्णित हैं।

मानक पुस्तकालय

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

अंतर्निहित प्रकार

निम्नलिखित मॉड्यूल निर्मित डेटा प्रकारों में अमृत को संभालते हैं:

  • Atom - एक नाम के साथ शाब्दिक स्थिरांक ( true , false और nil परमाणु हैं)
  • Float - फ्लोटिंग पॉइंट परिशुद्धता के साथ संख्या
  • Function - कोड चंक का एक संदर्भ, जिसे Kernel.SpecialForms.fn/2 के साथ बनाया गया है। Kernel.SpecialForms.fn/2 विशेष रूप
  • Integer - संपूर्ण संख्याएं (भिन्न नहीं)
  • List - तत्वों की एक चर संख्या का संग्रह (लिंक की गई सूची)
  • Map - कुंजी-मूल्य जोड़े का संग्रह
  • Process - निष्पादन के हल्के वजन के धागे
  • Port - बाहरी दुनिया के साथ बातचीत करने के लिए तंत्र
  • Tuple - तत्वों की एक निश्चित संख्या का संग्रह

बिना किसी मॉड्यूल के दो डेटा प्रकार हैं:

  • बिटस्ट्रिंग - बिट्स का एक क्रम, जो Kernel.SpecialForms.<<>>/1 के साथ बनाया गया है Kernel.SpecialForms.<<>>/1 जब बिट्स की संख्या 8 से विभाज्य होती है, तो उन्हें बायनेरिज़ कहा जाता है और एरलांग के :binary मॉड्यूल के साथ हेरफेर किया जा सकता है
  • संदर्भ - रनटाइम सिस्टम में एक अनूठा मूल्य, जिसे make_ref/0 के साथ बनाया गया है

जानकारी का प्रकार

अमृत ​​अन्य डेटा प्रकार भी प्रदान करता है जो ऊपर सूचीबद्ध प्रकारों के शीर्ष पर निर्मित होते हैं। उनमें से कुछ हैं:

  • Date - किसी दिए गए कैलेंडर में year-month-day संरचना
  • DateTime - दिनांक और समय किसी दिए गए कैलेंडर में समय क्षेत्र के साथ
  • Exception - त्रुटियों और अप्रत्याशित परिदृश्यों से उठाया गया डेटा
  • MapSet - अनूठे तत्वों का MapSet संग्रह
  • NaiveDateTime - किसी दिए गए कैलेंडर में समय क्षेत्र के बिना दिनांक और समय
  • Keyword - दो-तत्व ट्यूपल्स की सूची, अक्सर वैकल्पिक मूल्यों का प्रतिनिधित्व करते हैं
  • Range - दो पूर्णांकों के बीच समावेशी रेंज
  • Regex - नियमित अभिव्यक्ति
  • String - UTF-8 वर्णों का प्रतिनिधित्व करने वाले बायनेरिज़
  • Time - hour:minute:second किसी दिए गए कैलेंडर में hour:minute:second संरचना
  • URI - संसाधनों की पहचान करने वाले यूआरआई का प्रतिनिधित्व
  • Version - संस्करणों और आवश्यकताओं का प्रतिनिधित्व

सिस्टम मॉड्यूल

अंतर्निहित सिस्टम के साथ इंटरफ़ेस, जैसे कि:

  • IO - इनपुट और आउटपुट को संभालता है
  • File - अंतर्निहित फ़ाइल सिस्टम के साथ इंटरैक्ट करता है
  • Path - फाइल सिस्टम पथ में हेरफेर करता है
  • System - सिस्टम की जानकारी पढ़ता और लिखता है

प्रोटोकॉल

प्रोटोकॉल एलिक्सीर में बहुरूपी प्रेषण जोड़ते हैं। वे डेटा प्रकारों द्वारा कार्यान्वयन योग्य अनुबंध हैं। प्रोटोकॉल पर अधिक जानकारी के लिए defprotocol/2 देखें। अमृत ​​मानक पुस्तकालय में निम्नलिखित प्रोटोकॉल प्रदान करता है:

  • Collectable - डेटा प्रकार में डेटा एकत्र करता है
  • Enumerable - अमृत में संग्रह संभालती है। Enum मॉड्यूल संग्रह के साथ काम करने के लिए उत्सुक कार्य प्रदान करता है, Stream मॉड्यूल आलसी कार्य प्रदान करता है
  • Inspect - डेटा प्रकारों को उनकी प्रोग्रामिंग भाषा प्रतिनिधित्व में परिवर्तित करता है
  • List.Chars - डेटा प्रकारों को उनके बाहरी विश्व प्रतिनिधित्व के लिए चार सूचियों (गैर-प्रोग्रामिंग आधारित) के रूप में परिवर्तित करता है
  • String.Chars - डेटा प्रकारों को उनके बाहरी दुनिया प्रतिनिधित्व को स्ट्रिंग्स के रूप में परिवर्तित करता है (गैर-प्रोग्रामिंग आधारित)

प्रक्रिया-आधारित और अनुप्रयोग-केंद्रित कार्यक्षमता

निम्नलिखित मॉड्यूल समवर्ती, दोष-सहिष्णुता, और अधिक प्रदान करने के लिए प्रक्रियाओं के शीर्ष पर निर्माण करते हैं।

  • Agent - एक प्रक्रिया जो उत्परिवर्तित अवस्था को एनकैप्सुलेट करती है
  • Application - Application को शुरू करने, रोकने और कॉन्फ़िगर करने के लिए कार्य
  • GenServer - एक सामान्य क्लाइंट-सर्वर API
  • Registry - एक कुंजी-मूल्य प्रक्रिया-आधारित भंडारण
  • Supervisor - एक प्रक्रिया जो अन्य प्रक्रियाओं को शुरू करने, पर्यवेक्षण और बंद करने के लिए जिम्मेदार है
  • Task - एक प्रक्रिया जो संगणना करती है
  • Task.Supervisor - विशेष रूप से कार्यों के प्रबंधन के लिए एक पर्यवेक्षक

सहायक दस्तावेज

अमृत ​​दस्तावेज़ में "पृष्ठ" अनुभाग के तहत सहायक दस्तावेज़ भी शामिल हैं। वो है:

  • संगतता और निक्षेपण - हर अमृत संस्करण और एर्लांग / ओटीपी के बीच संगतता सूचीबद्ध करता है, स्कीमा जारी करता है; सभी पदावनत कार्यों को सूचीबद्ध करता है, जब वे पदावनत और विकल्प होते हैं
  • guard - सभी उपलब्ध गार्ड और एक्सटेंशन को सूचीबद्ध करता है
  • लाइब्रेरी दिशानिर्देश - सामान्य दिशा-निर्देश, विरोधी पैटर्न, और पुस्तकालय लिखने वालों के लिए नियम
  • नामकरण परंपराएँ - अमृत संहिता के लिए नामकरण परंपराएँ
  • Operators - सभी अमृत ऑपरेटरों और उनकी मिसाल को सूचीबद्ध करता है
  • सिंटेक्स रेफरेंस - भाषा सिंटैक्स संदर्भ
  • Typespecs - प्रकारों की सूची सहित प्रकार और फ़ंक्शन विनिर्देश
  • यूनिकोड सिंटेक्स - यूनिकोड के लिए अमृत समर्थन को रेखांकित करता है
  • लेखन प्रलेखन - अमृत में प्रलेखन लिखने के लिए दिशा निर्देश।

इनलाइनिंग

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

फ़ंक्शन को कैप्चर करते समय अधिकांश इनलाइन फ़ंक्शन प्रभाव में देखे जा सकते हैं:

iex> &Kernel.is_atom/1
&:erlang.is_atom/1

उन कार्यों को उनके डॉक्स में स्पष्ट रूप से "संकलक द्वारा उल्लिखित" के रूप में चिह्नित किया जाएगा।

सारांश

कार्य

!value

बूलियन नहीं

बायां! = सही

यदि दो आइटम नहीं के बराबर हैं, तो लौटाता true

बाएँ! == दाएँ

यदि दो आइटम बिल्कुल समान नहीं हैं, तो यह सही है

बाएँ दांए

शॉर्ट-सर्किट ऑपरेटर प्रदान करता है जो मूल्यांकन करता है और दूसरी अभिव्यक्ति को केवल तभी लौटाता है जब पहले वाला true मूल्यांकन करता true (यानी, यह न तो nil और न ही false )। अन्यथा पहले अभिव्यक्ति देता है

बाएँ दांए

अंकगणित गुणा

बाएं ++ दाएं

एक उचित सूची और एक शब्द, एक सूची लौटाता है

+value

अंकगणित एकात्मक प्लस

बाएँ + दाएँ

अंकगणित जोड़

बाएँ दांए

दाईं ओर प्रत्येक आइटम के लिए बाईं सूची में किसी आइटम की पहली घटना को निकालता है

-value

अंकगणित एकात्मक शून्य

बाएँ दांए

अंकगणित घटाव

first..last

निर्दिष्ट first और last पूर्णांक के साथ एक सीमा देता है

बाएँ दांए

अंकगणित विभाजन

बायां <सही

यदि सही से कम true तो रिटर्न सही है

बाएं <= दाएं

अगर true से कम या बराबर है तो रिटर्न सही है

बाएं <> दाएं

दो बायनेरिज़ को समेटता है

बाएँ == दाएँ

यदि दो आइटम बराबर हैं, तो true

बाएँ === सही

यदि दो आइटम बिल्कुल समान हैं, तो सही है

बाएँ = ~ दाएँ

नियमित अभिव्यक्ति या दाईं ओर स्ट्रिंग के खिलाफ बाईं ओर शब्द से मेल खाता है

बाएँ> दाएँ

यदि सही से अधिक true तो रिटर्न सही है

बाएँ> = दाएँ

यदि true से अधिक या बराबर है तो रिटर्न सही है

@expr

वर्तमान मॉड्यूल की विशेषताओं को पढ़ता है और लिखता है

abs(number)

एक पूर्णांक या फ्लोट देता है जो अंक का अंकगणितीय निरपेक्ष मान है

alias!(alias)

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

बाएँ और दाएँ

बूलियन और

लागू करें (मज़ा, आर्ग्स)

दिए गए अनाम फ़ंक्शन fun को तर्क की सूची में शामिल करता है

लागू करें (मॉड्यूल, function_name, args)

तर्कों की सूची के साथ module से दिए गए फ़ंक्शन को आमंत्रित करता है

बाइनरी_पार्ट (बाइनरी, स्टार्ट, लेंथ)

बाइनरी का हिस्सा लंबाई की length साथ शुरू में निकालता है। बायनेरिज़ शून्य-अनुक्रमित हैं

बाइंडिंग (संदर्भ \\ nil)

कीवर्ड सूची के रूप में दिए गए संदर्भ के लिए बाध्यकारी लौटाता है

bit_size(bitstring)

एक पूर्णांक देता है जो bitstring बिट्स में आकार bitstring

byte_size(bitstring)

bitstring को शामिल करने के लिए आवश्यक बाइट्स की संख्या bitstring

def (कॉल, expr \\ nil)

दिए गए नाम और शरीर के साथ एक फ़ंक्शन को परिभाषित करता है

अवहेलना (मज़ाक, ऑप्स)

एक फ़ंक्शन को परिभाषित करता है जो किसी अन्य मॉड्यूल को दर्शाता है

defexception(fields)

एक अपवाद को परिभाषित करता है

defguard(guard)

गार्ड भाव में उपयोग के लिए उपयुक्त मैक्रो बनाता है

defguardp(guard)

गार्ड अभिव्यक्ति में उपयोग के लिए उपयुक्त एक निजी मैक्रो बनाता है

डिफिम्ल (नाम, ऑप्स, do_block \\ [])

दिए गए प्रोटोकॉल के लिए एक कार्यान्वयन को परिभाषित करता है

डिफामाक्रो (कॉल, expr \\ nil)

दिए गए नाम और शरीर के साथ एक मैक्रो को परिभाषित करता है

Defmacrop (कॉल, expr \\ nil)

दिए गए नाम और शरीर के साथ एक निजी मैक्रो को परिभाषित करता है

मानहानि (उपनाम, do_block)

दिए गए सामग्रियों के साथ नाम द्वारा दिए गए मॉड्यूल को परिभाषित करता है

defoverridable(keywords_or_behaviour)

वर्तमान मॉड्यूल में दिए गए कार्यों को अधिक महत्वपूर्ण बनाता है

डीईएमपी (कॉल, एक्सपायर \ एनएल)

दिए गए नाम और शरीर के साथ एक निजी फ़ंक्शन को परिभाषित करता है

defprotocol/2

एक प्रोटोकॉल को परिभाषित करता है

defstruct(fields)

एक संरचना को परिभाषित करता है

विनाश (बाएं, दाएं)

दो सूचियों को नष्ट कर देता है, प्रत्येक शब्द को दाईं ओर एक मेल खाते में बाईं ओर रखता है

div (लाभांश, भाजक)

पूर्णांक विभाजन करता है

एलएम (टपल, इंडेक्स)

tuple में शून्य-आधारित index में तत्व प्राप्त करता है

exit(reason)

दिए गए कारण के साथ कॉलिंग प्रक्रिया के निष्पादन को रोकता है

function_exported? (मॉड्यूल, फ़ंक्शन, एरिटी)

module लोड होने पर true रिटर्न देता true और दिए गए arity साथ एक सार्वजनिक function arity , अन्यथा false

get_and_update_in (पथ, मज़ा)

एक मान हो जाता है और दिए गए path माध्यम से एक नेस्टेड डेटा संरचना को अपडेट करता path

get_and_update_in (डेटा, कुंजियाँ, मज़ा)

एक मान प्राप्त करता है और एक नेस्टेड संरचना को अपडेट करता है

get_in (डेटा, कुंजियाँ)

एक नेस्टेड संरचना से एक मूल्य प्राप्त होता है

hd(list)

किसी सूची का प्रमुख लौटाता है। यदि सूची रिक्त है, तो ArgumentError उठाता है

यदि (स्थिति, खंड)

एक if/2 मैक्रो प्रदान करता है

दाएं में छोड़ दिया

यह जाँचता है कि बाईं ओर का तत्व दाहिने-हाथ की तरफ संग्रह का सदस्य है या नहीं

निरीक्षण (शब्द, opts \\ [])

निरीक्षण प्रोटोकॉल के अनुसार दिए गए तर्क का Inspect है। दूसरा तर्क एक कीवर्ड सूची है जिसमें निरीक्षण को नियंत्रित करने के विकल्प हैं

is_atom(term)

true अगर term एक परमाणु है; अन्यथा false लौट आता false

is_binary(term)

अगर बाइनरी एक term है, तो true है; अन्यथा false लौट आता false

is_bitstring(term)

यदि रिटर्न एक बिटस्ट्रिंग (एक बाइनरी सहित) है तो सही है; अन्यथा false लौट आता false

is_boolean(term)

true अगर term या तो परमाणु true या परमाणु false (यानी, एक बूलियन); अन्यथा false लौट आता false

is_float(term)

अगर रिटर्न एक फ़्लोटिंग-पॉइंट संख्या true तो true है; अन्यथा false लौट आता false

is_function(term)

true अगर term एक समारोह है; अन्यथा false लौट आता false

is_function (शब्द, अर्थ)

true अगर term एक फ़ंक्शन है जिसे तर्क संख्या के तर्क के साथ लागू किया जा सकता है; अन्यथा false लौट आता false

is_integer(term)

यदि रिटर्न पूर्णांक है तो true है; अन्यथा false लौट आता false

is_list(term)

यदि शून्य या अधिक तत्वों वाली सूची है, तो यह true है; अन्यथा false लौट आता false

is_map(term)

true अगर term एक नक्शा है; अन्यथा false लौट आता false

is_nil(term)

true अगर term nil , तो false है

is_number(term)

यदि रिटर्न पूर्णांक या फ्लोटिंग-पॉइंट नंबर है तो true ; अन्यथा false लौट आता false

is_pid(term)

यदि पीआईडी ​​(प्रक्रिया पहचानकर्ता) true तो यह true है; अन्यथा false लौट आता false

is_port(term)

true अगर term एक बंदरगाह पहचानकर्ता है; अन्यथा false लौट आता false

is_reference(term)

यदि रिटर्न एक संदर्भ है तो true है; अन्यथा false लौट आता false

is_tuple(term)

true अगर term एक टपल है; अन्यथा false लौट आता false

length(list)

list की लंबाई लौटाता है

मैक्रो_एक्सपोर्टेड (मॉड्यूल, मैक्रो, एरिटी)

module लोड होने पर true है और दिए गए arity साथ सार्वजनिक macro arity , अन्यथा false

make_ref/0

लगभग एक अद्वितीय संदर्भ देता है

map_size(map)

नक्शे का आकार लौटाता है

मैच। (पैटर्न, एक्सप)

एक सुविधा मैक्रो, जो जाँचता है कि दायाँ पक्ष (एक अभिव्यक्ति) बाईं ओर से मेल खाता है (एक पैटर्न)

अधिकतम (पहला, दूसरा)

एर्लैंग के टर्म ऑर्डर के अनुसार दिए गए दो शब्दों में से सबसे बड़ा रिटर्न

न्यूनतम (पहला, दूसरा)

एर्लैंग के टर्म ऑर्डर के अनुसार दिए गए दो सबसे छोटे शब्दों को लौटाता है

node()

स्थानीय नोड के नाम का प्रतिनिधित्व करने वाला एक परमाणु लौटाता है। यदि नोड जीवित नहीं है, तो इसके बजाय :[email protected] लौटाया जाता है

node(arg)

उस नोड को लौटाता है जहाँ दिया गया तर्क स्थित है। तर्क पीआईडी, संदर्भ या पोर्ट हो सकता है। यदि स्थानीय नोड जीवित नहीं है, तो :[email protected] वापस नहीं किया गया है

not(value)

बूलियन नहीं

बायें या दायें

बूलियन या

pop_in(path)

दिए गए path माध्यम से नेस्टेड संरचना से एक कुंजी लेता है

pop_in (डेटा, कुंजियाँ)

दी गई नेस्टेड संरचना से एक कुंजी लेता है

put_elem (टपल, इंडेक्स, मूल्य)

tuple में दिए गए शून्य-आधारित index में value डालता है

put_in (पथ, मूल्य)

दिए गए path माध्यम से एक नेस्टेड संरचना में एक मूल्य डालता है

put_in (डेटा, कुंजियाँ, मूल्य)

एक नेस्टेड संरचना में एक मूल्य डालता है

raise(message)

एक अपवाद उठाता है

उठाना (अपवाद, गुण)

एक अपवाद उठाता है

रेम (लाभांश, भाजक)

पूर्णांक विभाजन के शेष भाग की गणना करता है

reraise (संदेश, स्टैकट्रेस)

एक पिछले स्टैकट्रेस को संरक्षित करने वाले अपवाद को उठाता है

reraise (अपवाद, विशेषताएँ, स्टैकट्रेस)

एक पिछले स्टैकट्रेस को संरक्षित करने वाले अपवाद को उठाता है

round(number)

किसी नंबर को निकटतम पूर्णांक पर राउंड करता है

self()

कॉलिंग प्रक्रिया का पीआईडी ​​(प्रक्रिया पहचानकर्ता) लौटाता है

भेजें (भाग्य, संदेश)

दिए गए dest को संदेश भेजता है और संदेश लौटाता है

sigil_C (शब्द, संशोधक)

प्रभारियों के लिए सतर्क ~C संभालता है

sigil_D (दिनांक, संशोधक)

तारीखों के लिए सतर्क ~D संभालता है

sigil_N (दिनांक, संशोधक)

भोले तिथि समय के लिए सजग ~N को संभालता है

sigil_R (शब्द, संशोधक)

नियमित अभिव्यक्ति के लिए सजग ~R को संभालता है

sigil_S (शब्द, संशोधक)

स्ट्रिंग्स के लिए sigil ~S संभालता है

sigil_T (दिनांक, संशोधक)

समय के लिए सतर्क ~T संभालता है

sigil_W (शब्द, संशोधक)

शब्दों की सूची के लिए sigil ~W को संभालता है

sigil_c (शब्द, संशोधक)

प्रभारियों के लिए सतर्क ~c संभालता है

sigil_r (शब्द, संशोधक)

नियमित भावों के लिए sigil ~r संभालता है

sigil_s (शब्द, संशोधक)

स्ट्रिंग्स के लिए sigil ~s संभालता है

sigil_w (शब्द, संशोधक)

शब्दों की सूची के लिए sigil ~w को संभालता है

spawn(fun)

दिए गए फ़ंक्शन को खोलता है और उसका PID लौटाता है

स्पॉन (मॉड्यूल, मज़ा, आर्ग्स)

दिए गए module से दिए गए फ़ंक्शन का fun लेता है जो दिए गए args और उसका PID लौटाता है

spawn_link(fun)

दिए गए फ़ंक्शन को खोलता है, इसे वर्तमान प्रक्रिया से जोड़ता है, और उसका PID लौटाता है

स्पॉन_लिंक (मॉड्यूल, मज़ा, आर्ग्स)

दिए गए module से दिए गए फ़ंक्शन का fun लेता है जो दिए गए args , इसे वर्तमान प्रक्रिया से जोड़ता है, और इसका PID लौटाता है

spawn_monitor(fun)

दिए गए फ़ंक्शन को देखता है, इसे मॉनिटर करता है और इसका पीआईडी ​​और मॉनिटरिंग संदर्भ देता है

spawn_monitor (मॉड्यूल, मज़ा, आर्ग्स)

दिए गए मॉड्यूल को कार्य करता है और दिए गए आर्ग को पास करता है, इसकी निगरानी करता है और इसका पीआईडी ​​और निगरानी संदर्भ लौटाता है

संरचना (संरचना, फ़ील्ड \\ [])

struct/2 समान लेकिन मुख्य वैधता के लिए जाँच

struct/2

संरचना और अद्यतन बनाता है

throw(term)

एक समारोह से एक गैर-स्थानीय वापसी

tl(list)

किसी सूची की पूंछ लौटाता है। यदि सूची रिक्त है, तो ArgumentError उठाता है

to_charlist(term)

दी गई पदावलियों को List.Chars प्रोटोकॉल के अनुसार एक सूची में List.Chars है

to_string(term)

स्ट्रिंग के अनुसार तर्क को स्ट्रिंग में String.Chars प्रोटोकॉल प्रोटोकॉल

trunc(number)

number का पूर्णांक भाग लौटाता है

tuple_size(tuple)

टपल का आकार देता है

जब तक (स्थिति, खंड)

एक मैक्रो प्रदान करता है

update_in (पथ, मज़ा)

दिए गए path माध्यम से नेस्टेड संरचना को अद्यतन करता है

update_in (डेटा, कुंजियाँ, मज़ा)

नेस्टेड संरचना में एक कुंजी को अपडेट करता है

उपयोग (मॉड्यूल, opts \\ [])

वर्तमान संदर्भ में दिए गए मॉड्यूल का उपयोग करता है

var! (var, संदर्भ \\ nil)

जब उद्धृत के अंदर उपयोग किया जाता है, तो यह संकेत दिया जाता है कि दिए गए चर को स्वच्छ नहीं किया जाना चाहिए

बायां |> दायां

पाइप ऑपरेटर

छोड़ दिया || सही

एक शॉर्ट-सर्किट ऑपरेटर प्रदान करता है जो केवल दूसरी अभिव्यक्ति का मूल्यांकन करता है और लौटाता है यदि पहला true नहीं true (यानी, यह या तो nil या false )। अन्यथा पहले अभिव्यक्ति देता है

कार्य

मूल्य (मैक्रो)

बूलियन नहीं।

किसी भी तर्क को प्राप्त करता है (सिर्फ बूलियन नहीं) और true अगर तर्क false या nil ; अन्यथा false है।

गार्ड क्लॉस में अनुमति नहीं है।

उदाहरण

iex> !Enum.empty?([])
false

iex> !List.first([])
true

बायां! = सही

term() != term() :: boolean()

यदि दो आइटम नहीं के बराबर हैं, तो लौटाता true

यह ऑपरेटर 1 और 1.0 को समान मानता है। मैच की तुलना के लिए, इसके बजाय !== उपयोग !==

अमृत ​​में सभी शब्दों की एक दूसरे के साथ तुलना की जा सकती है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> 1 != 2
true

iex> 1 != 1.0
false

बाएँ! == दाएँ

term() !== term() :: boolean()

यदि दो आइटम बिल्कुल समान नहीं हैं, तो यह सही है।

अमृत ​​में सभी शब्दों की एक दूसरे के साथ तुलना की जा सकती है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> 1 !== 2
true

iex> 1 !== 1.0
true

बाएँ और दाएँ (मैक्रो)

शॉर्ट-सर्किट ऑपरेटर प्रदान करता है जो मूल्यांकन करता है और दूसरी अभिव्यक्ति को केवल तभी लौटाता है जब पहले वाला true मूल्यांकन करता true (यानी, यह न तो nil और न ही false )। अन्यथा पहले अभिव्यक्ति देता है।

गार्ड क्लॉस में अनुमति नहीं है।

उदाहरण

iex> Enum.empty?([]) && Enum.empty?([])
true

iex> List.first([]) && true
nil

iex> Enum.empty?([]) && List.first([1])
1

iex> false && throw(:bad)
false

ध्यान दें, विपरीत and/2 , यह ऑपरेटर किसी भी अभिव्यक्ति को पहले तर्क के रूप में स्वीकार करता है, न कि केवल बूलियन।

बाएँ दांए

float() * integer() :: float()
integer() * float() :: float()
float() * float() :: float()
integer() * integer() :: integer()

अंकगणित गुणा।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> 1 * 2
2

बाएं ++ दाएं

list() ++ term() :: maybe_improper_list()

एक उचित सूची और एक शब्द, एक सूची लौटाता है।

a ++ b की जटिलता length(a) समानुपाती है, इसलिए बार-बार मनमानी लंबाई की सूचियों के लिए संलग्न करने से बचें, जैसे list ++ [item] । इसके बजाय, [item | rest] [item | rest] और फिर उलटा।

यदि right ऑपरेंड एक उचित सूची नहीं है, तो यह एक अनुचित सूची देता है। यदि left ऑपरेंड एक उचित सूची नहीं है, तो यह ArgumentError उठाता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> [1] ++ [2, 3]
[1, 2, 3]

iex> 'foo' ++ 'bar'
'foobar'

# returns an improper list
iex> [1] ++ 2
[1 | 2]

# returns a proper list
iex> [1] ++ [2]
[1, 2]

# improper list on the right will return an improper list
iex> [1] ++ [2 | 3]
[1, 2 | 3]

+ मूल्य

+value :: value when value: number()

अंकगणित एकात्मक प्लस।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> +1
1

बाएँ + दाएँ

float() + integer() :: float()
integer() + float() :: float()
float() + float() :: float()
integer() + integer() :: integer()

अंकगणित जोड़।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> 1 + 2
3

बाएँ दांए

list() -- list() :: list()

दाईं ओर प्रत्येक आइटम के लिए बाईं सूची में किसी आइटम की पहली घटना को निकालता है।

a -- b की जटिलता length(a) * length(b) आनुपातिक है, जिसका अर्थ है कि यह बहुत धीमी गति से होगा यदि a और b दोनों लंबी सूचियाँ हैं। ऐसे मामलों में, प्रत्येक सूची को MapSet परिवर्तित करने और MapSet.difference/2 का उपयोग करने पर विचार करें।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> [1, 2, 3] -- [1, 2]
[3]

iex> [1, 2, 3, 2, 1] -- [1, 2, 2]
[3, 1]

-value

-float() :: float()
-neg_integer() :: pos_integer()
-pos_integer() :: neg_integer()
-0 :: 0

अंकगणित एकात्मक शून्य।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> -2
-2

बाएँ दांए

float() - integer() :: float()
integer() - float() :: float()
float() - float() :: float()
integer() - integer() :: integer()

अंकगणित घटाव।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> 1 - 2
-1

पहला..आलू (स्थूल)

निर्दिष्ट first और last पूर्णांक के साथ एक सीमा देता है।

यदि अंतिम पहले से बड़ा है, तो सीमा पहले से अंतिम तक बढ़ जाएगी। यदि पहले पिछले से बड़ा है, तो रेंज पहले से आखिरी तक कम हो जाएगी। यदि पहला पिछले के बराबर है, तो सीमा में एक तत्व होगा, जो कि संख्या ही है।

उदाहरण

iex> 0 in 1..3
false

iex> 1 in 1..3
true

iex> 2 in 1..3
true

iex> 3 in 1..3
true

बाएँ दांए

number() / number() :: float()

अंकगणित विभाजन।

परिणाम हमेशा एक नाव है। यदि आप पूर्णांक विभाजन या शेष चाहते हैं तो div/2 और rem/2 उपयोग करें।

अगर 0 या 0.0 right है तो ArithmeticError

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

1 / 2
#=> 0.5

-3.0 / 2.0
#=> -1.5

5 / 1
#=> 5.0

7 / 0
#=> ** (ArithmeticError) bad argument in arithmetic expression

बायां <सही

term() < term() :: boolean()

यदि सही से कम true तो रिटर्न सही है।

अमृत ​​में सभी शब्दों की एक दूसरे के साथ तुलना की जा सकती है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> 1 < 2
true

बाएं <= दाएं

term() <= term() :: boolean()

अगर true से कम या बराबर है तो रिटर्न सही है।

अमृत ​​में सभी शब्दों की एक दूसरे के साथ तुलना की जा सकती है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> 1 <= 2
true

बाएं <> दाएं (मैक्रो)

दो बायनेरिज़ को समेटता है।

उदाहरण

iex> "foo" <> "bar"
"foobar"

<>/2 ऑपरेटर का उपयोग पैटर्न मिलान (और गार्ड क्लॉस) में भी किया जा सकता है जब तक कि बाएं तर्क शाब्दिक चरण है:

iex> "foo" <> x = "foobar"
iex> x
"bar"

x <> "bar" = "foobar" CompileError x <> "bar" = "foobar" परिणामस्वरूप एक CompileError अपवाद होगा।

बाएँ == दाएँ

term() == term() :: boolean()

यदि दो आइटम बराबर हैं, तो true

यह ऑपरेटर 1 और 1.0 को समान मानता है। कड़े शब्दार्थ के लिए, ===/2 उपयोग करें।

अमृत ​​में सभी शब्दों की एक दूसरे के साथ तुलना की जा सकती है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> 1 == 2
false

iex> 1 == 1.0
true

बाएँ === सही

term() === term() :: boolean()

यदि दो आइटम बिल्कुल समान हैं, तो सही है।

आइटम केवल उसी के बराबर माने जाते हैं यदि उनका मूल्य समान हो और समान प्रकार के हों। उदाहरण के लिए, 1 == 1.0 रिटर्न true , लेकिन चूंकि वे विभिन्न प्रकार के हैं, 1 === 1.0 रिटर्न false

अमृत ​​में सभी शब्दों की एक दूसरे के साथ तुलना की जा सकती है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> 1 === 2
false

iex> 1 === 1.0
false

बाएँ = ~ दाएँ

String.t() =~ (String.t() | Regex.t()) :: boolean()

नियमित अभिव्यक्ति या दाईं ओर स्ट्रिंग के खिलाफ बाईं ओर शब्द से मेल खाता है।

यदि right मेल खाता right (यदि यह एक नियमित अभिव्यक्ति है) या right (यदि यह एक स्ट्रिंग है) तो right

उदाहरण

iex> "abcd" =~ ~r/c(d)/
true

iex> "abcd" =~ ~r/e/
false

iex> "abcd" =~ "bc"
true

iex> "abcd" =~ "ad"
false

iex> "abcd" =~ ""
true

बाएँ> दाएँ

term() > term() :: boolean()

यदि सही से अधिक true तो रिटर्न सही है।

अमृत ​​में सभी शब्दों की एक दूसरे के साथ तुलना की जा सकती है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> 1 > 2
false

बाएँ> = दाएँ

term() >= term() :: boolean()

यदि true से अधिक या बराबर है तो रिटर्न सही है।

अमृत ​​में सभी शब्दों की एक दूसरे के साथ तुलना की जा सकती है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> 1 >= 2
false

@expr (मैक्रो)

वर्तमान मॉड्यूल की विशेषताओं को पढ़ता है और लिखता है।

विशेषताओं के लिए विहित उदाहरण GenServer कि एक मॉड्यूल ओटीपी व्यवहार को लागू करता है, जैसे कि GenServer :

defmodule MyServer do
  @behaviour GenServer
  # ... callbacks ...
end

डिफ़ॉल्ट रूप से एलिक्सिर द्वारा समर्थित सभी मॉड्यूल विशेषताओं का समर्थन करता है, लेकिन कस्टम विशेषताओं का भी उपयोग किया जा सकता है:

defmodule MyServer do
  @my_data 13
  IO.inspect @my_data #=> 13
end

एर्लैंग के विपरीत, इस तरह की विशेषताओं को मॉड्यूल में डिफ़ॉल्ट रूप से संग्रहीत नहीं किया जाता है क्योंकि यह एलिमिर में आम है ताकि अस्थायी डेटा को संग्रहीत करने के लिए कस्टम विशेषताओं का उपयोग किया जा सके जो कि संकलन-समय पर उपलब्ध होगा। कस्टम विशेषताएँ Module.register_attribute/3 का उपयोग करके Erlang के करीब व्यवहार करने के लिए कॉन्फ़िगर की जा सकती हैं।

अंत में, ध्यान दें कि विशेषताओं को कार्यों के अंदर भी पढ़ा जा सकता है:

defmodule MyServer do
  @my_data 11
  def first_data, do: @my_data
  @my_data 13
  def second_data, do: @my_data
end

MyServer.first_data #=> 11
MyServer.second_data #=> 13

यह ध्यान रखना महत्वपूर्ण है कि एक विशेषता को पढ़ने से इसके वर्तमान मूल्य का एक स्नैपशॉट लेता है। दूसरे शब्दों में, मूल्य संकलन समय पर पढ़ा जाता है न कि रनटाइम पर। मॉड्यूल विशेषताओं में हेरफेर करने के लिए अन्य कार्यों के लिए Module मॉड्यूल की जांच करें।

पेट (संख्या)

abs(number()) :: number()

एक पूर्णांक या फ्लोट देता है जो अंक का अंकगणितीय निरपेक्ष मान है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> abs(-3.33)
3.33

iex> abs(-3)
3

अन्य (उपनाम) (मैक्रो)

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

अधिक जानकारी के लिए Kernel.SpecialForms.quote/2 जाँच करें।

बाएँ और दाएँ (मैक्रो)

बूलियन और।

अगर left है तो false , false ; नहीं तो right

शॉर्ट सर्किट होने के बाद से बूलियन होने के लिए केवल left ऑपरेंड की आवश्यकता होती है। यदि left ऑपरेंड एक बूलियन नहीं है, तो एक ArgumentError अपवाद उठाया जाता है।

गार्ड परीक्षण में अनुमति है।

उदाहरण

iex> true and false
false
iex> true and "yay!"
"yay!"

लागू करें (मज़ा, आर्ग्स)

apply((... -> any()), [any()]) :: any()

दिए गए अनाम फ़ंक्शन fun को तर्क की सूची में शामिल करता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> apply(fn x -> x * 2 end, [2])
4

लागू करें (मॉड्यूल, function_name, args)

apply(module(), function_name :: atom(), [any()]) :: any()

तर्कों की सूची के साथ module से दिए गए फ़ंक्शन को आमंत्रित करता है।

apply/3 का उपयोग फ़ंक्शन को लागू करने के लिए किया जाता है जहां रनटाइम पर मॉड्यूल, फ़ंक्शन नाम या तर्क गतिशील रूप से परिभाषित किए जाते हैं। इस कारण से, आप केवल फ़ंक्शन apply/3 का उपयोग करके मैक्रोज़ को आमंत्रित नहीं कर सकते।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> apply(Enum, :reverse, [[1, 2, 3]])
[3, 2, 1]

बाइनरी_पार्ट (बाइनरी, स्टार्ट, लेंथ)

binary_part(binary(), non_neg_integer(), integer()) :: binary()

बाइनरी का हिस्सा लंबाई की length साथ शुरू में निकालता है। बायनेरिज़ शून्य-अनुक्रमित हैं।

यदि बाइनरी के बाहर किसी भी तरह से start या length संदर्भ, एक ArgumentError अपवाद उठाया जाता है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> binary_part("foo", 1, 2)
"oo"

start में बाइट से पहले आने वाली बाइट निकालने के लिए एक नकारात्मक length का उपयोग किया जा सकता है:

iex> binary_part("Hello", 5, -3)
"llo"

बाइंडिंग (संदर्भ \\ nil) (मैक्रो)

कीवर्ड सूची के रूप में दिए गए संदर्भ के लिए बाध्यकारी लौटाता है।

लौटे परिणाम में, कुंजी चर नाम हैं और मान संगत चर मान हैं।

यदि दिया गया context nil (डिफ़ॉल्ट रूप से), वर्तमान संदर्भ के लिए बाइंडिंग वापस आ गई है।

उदाहरण

iex> x = 1
iex> binding()
[x: 1]
iex> x = 2
iex> binding()
[x: 2]

iex> binding(:foo)
[]
iex> var!(x, :foo) = 1
1
iex> binding(:foo)
[x: 1]

bit_size (bitstring)

bit_size(bitstring()) :: non_neg_integer()

एक पूर्णांक देता है जो bitstring बिट्स में आकार bitstring

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> bit_size(<<433::16, 3::3>>)
19

iex> bit_size(<<1, 2, 3>>)
24

byte_size (bitstring)

byte_size(bitstring()) :: non_neg_integer()

bitstring को शामिल करने के लिए आवश्यक बाइट्स की संख्या bitstring

यही है, अगर bitstring में बिट्स की संख्या 8 से विभाज्य नहीं है, तो परिणामस्वरूप बाइट्स की संख्या को गोल (अतिरिक्त द्वारा) किया जाएगा। यह ऑपरेशन निरंतर समय में होता है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> byte_size(<<433::16, 3::3>>)
3

iex> byte_size(<<1, 2, 3>>)
3

def (कॉल, expr \\ nil) (मैक्रो)

दिए गए नाम और शरीर के साथ एक फ़ंक्शन को परिभाषित करता है।

उदाहरण

defmodule Foo do
  def bar, do: :baz
end

Foo.bar() #=> :baz

एक फ़ंक्शन जो तर्कों की अपेक्षा करता है, उसे इस प्रकार परिभाषित किया जा सकता है:

defmodule Foo do
  def sum(a, b) do
    a + b
  end
end

उपरोक्त उदाहरण में, एक sum/2 फ़ंक्शन परिभाषित है; यह फ़ंक्शन दो तर्क प्राप्त करता है और उनकी राशि लौटाता है।

डिफ़ॉल्ट तर्क

\\ किसी फ़ंक्शन के पैरामीटर के लिए डिफ़ॉल्ट मान निर्दिष्ट करने के लिए उपयोग किया जाता है। उदाहरण के लिए:

defmodule MyMath do
  def multiply_by(number, factor \\ 2) do
    number * factor
  end
end

MyMath.multiply_by(4, 3) #=> 12
MyMath.multiply_by(4) #=> 8

कंपाइलर इसे विभिन्न फ़ंक्शन के साथ कई कार्यों में अनुवाद करता है, यहां Foo.multiply_by/1 और Foo.multiply_by/2 , जो ऐसे मामलों का प्रतिनिधित्व करते हैं जब डिफ़ॉल्ट मान वाले पैरामीटर के लिए तर्क पारित किए जाते हैं या पारित नहीं होते हैं।

एक फ़ंक्शन को डिफ़ॉल्ट तर्क के साथ-साथ कई स्पष्ट रूप से घोषित खंडों को परिभाषित करते समय, आपको एक फ़ंक्शन हेड लिखना होगा जो डिफॉल्ट्स की घोषणा करता है। उदाहरण के लिए:

defmodule MyString do
  def join(string1, string2 \\ nil, separator \\ " ")

  def join(string1, nil, _separator) do
    string1
  end

  def join(string1, string2, separator) do
    string1 <> separator <> string2
  end
end

ध्यान दें कि \\ उपयोग अनाम फ़ंक्शंस के साथ नहीं किया जा सकता है क्योंकि वे केवल एकमात्र एरिटी हो सकते हैं।

फ़ंक्शन और चर नाम

फ़ंक्शन और चर नामों में निम्न सिंटैक्स होता है: एक लोअरकेस ASCII पत्र या एक अंडरस्कोर , इसके बाद किसी भी संख्या में लोअरकेस या अपरकेस ASCII अक्षर , संख्या या अंडरस्कोर । वैकल्पिक रूप से वे या तो विस्मयादिबोधक चिह्न या प्रश्न चिह्न में समाप्त हो सकते हैं।

चर के लिए, अंडरस्कोर से शुरू होने वाले किसी भी पहचानकर्ता को अप्रयुक्त चर का संकेत देना चाहिए। उदाहरण के लिए:

def foo(bar) do
  []
end
#=> warning: variable bar is unused

def foo(_bar) do
  []
end
#=> no warning

def foo(_bar) do
  _bar
end
#=> warning: the underscored variable "_bar" is used after being set

बचाव / पकड़ / के बाद

समारोह निकाय rescue समर्थन करते हैं, catch और Kernel.SpecialForms.try/1 after । विशेष। निम्नलिखित दो कार्य समतुल्य हैं:

def format(value) do
  try do
    format!(value)
  catch
    :exit, reason -> {:error, reason}
  end
end

def format(value) do
  format!(value)
catch
  :exit, reason -> {:error, reason}
end

अवहेलना (फन, ऑप्स) (मैक्रो)

एक फ़ंक्शन को परिभाषित करता है जो किसी अन्य मॉड्यूल को दर्शाता है।

defdelegate/2 साथ परिभाषित कार्य सार्वजनिक होते हैं और उन्हें जिस मॉड्यूल में परिभाषित किया जाता है उसके बाहर से defdelegate/2 जा सकता है (जैसे कि यदि उन्हें परिभाषित def/2 का उपयोग करके परिभाषित किया गया हो)। जब इच्छा को निजी कार्यों के रूप में सौंपना है, तो Kernel.SpecialForms.import/2 का उपयोग किया जाना चाहिए।

प्रतिनिधि केवल कार्यों के साथ काम करता है; मैक्रोज़ को सौंपना समर्थित नहीं है।

नाम और डिफ़ॉल्ट तर्कों पर नियमों के लिए def/2 जांच करें।

विकल्प

  • :to लिए भेजने के लिए मॉड्यूल।

  • :as - में दिए गए लक्ष्य पर कॉल करने के लिए कार्य:। यह पैरामीटर वैकल्पिक है और नाम के लिए डिफॉल्ट (प्रतिनिधि) किया जा रहा है।

उदाहरण

defmodule MyList do
  defdelegate reverse(list), to: :lists
  defdelegate other_reverse(list), to: :lists, as: :reverse
end

MyList.reverse([1, 2, 3])
#=> [3, 2, 1]

MyList.other_reverse([1, 2, 3])
#=> [3, 2, 1]

डिफेक्ससेप्शन (फ़ील्ड्स) (मैक्रो)

एक अपवाद को परिभाषित करता है।

अपवाद एक मॉड्यूल द्वारा समर्थित संरचनाएं हैं जो Exception व्यवहार को लागू करती हैं। Exception व्यवहार को लागू करने के लिए दो कार्यों की आवश्यकता होती है:

  • exception/1 - raise/2 लिए दिए गए तर्कों को प्राप्त करता है raise/2 और अपवाद संरचना को लौटाता है। डिफ़ॉल्ट कार्यान्वयन कीवर्ड तर्कों के एक सेट को स्वीकार करता है जिसे संरचना में विलय कर दिया जाता है या अपवाद संदेश के रूप में उपयोग किए जाने वाले स्ट्रिंग।

  • message/1 - अपवाद संरचना को प्राप्त करता है और उसे अपना संदेश वापस करना चाहिए। अधिकांश अपवादों में एक संदेश फ़ील्ड है जो डिफ़ॉल्ट रूप से इस फ़ंक्शन द्वारा एक्सेस किया जाता है। हालाँकि, यदि अपवाद में संदेश फ़ील्ड नहीं है, तो यह फ़ंक्शन स्पष्ट रूप से कार्यान्वित किया जाना चाहिए।

चूंकि अपवाद defstruct(fields) हैं, इसलिए defstruct(fields) द्वारा समर्थित एपीआई defstruct(fields) में भी उपलब्ध है।

अपवादों को उठाना

अपवाद बढ़ाने का सबसे आम तरीका है raise/2 :

defmodule MyAppError do
  defexception [:message]
end

value = [:hello]

raise MyAppError,
  message: "did not get what was expected, got: #{inspect value}"

कई मामलों में यह Exception.exception/1 को पार करने के raise/2 2/2 में संदेश उत्पन्न करने के raise/2 अपेक्षित मूल्य को पार करने के लिए अधिक सुविधाजनक है। Exception.exception/1 कॉलगर्ल:

defmodule MyAppError do
  defexception [:message]

  @impl true
  def exception(value) do
    msg = "did not get what was expected, got: #{inspect value}"
    %MyAppError{message: msg}
  end
end

raise MyAppError, value

उपरोक्त उदाहरण अपवाद संदेशों को अनुकूलित करने के लिए पसंदीदा रणनीति दिखाता है।

रक्षक (गार्ड) (मैक्रो) (1.6.0 से)

defguard(Macro.t()) :: Macro.t()

गार्ड भाव में उपयोग के लिए उपयुक्त मैक्रो बनाता है।

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

ध्यान दें कि is_list(term) में is_list(term) prefix के साथ गार्ड्स में अनुमत फ़ंक्शन / मैक्रोज़ का नाम है, जैसे कि is_list(term) । यदि, हालांकि, फ़ंक्शन / मैक्रो एक बूलियन देता है और गार्ड में अनुमति नहीं है, तो इसका कोई उपसर्ग नहीं होना चाहिए और एक प्रश्न चिह्न के साथ समाप्त होना चाहिए, जैसे Keyword.keyword?/1

उदाहरण

defmodule Integer.Guards do
  defguard is_even(value) when is_integer(value) and rem(value, 2) == 0
end

defmodule Collatz do
  @moduledoc "Tools for working with the Collatz sequence."
  import Integer.Guards

  @doc "Determines the number of steps `n` takes to reach `1`."
  # If this function never converges, please let me know what `n` you used.
  def converge(n) when n > 0, do: step(n, 0)

  defp step(1, step_count) do
    step_count
  end

  defp step(n, step_count) when is_even(n) do
    step(div(n, 2), step_count + 1)
  end

  defp step(n, step_count) do
    step(3*n + 1, step_count + 1)
  end
end

डीफगार्ड (गार्ड) (मैक्रो) (1.6.0 से)

defguardp(Macro.t()) :: Macro.t()

गार्ड अभिव्यक्ति में उपयोग के लिए उपयुक्त एक निजी मैक्रो बनाता है।

यह संकलित समय पर उठता है यदि परिभाषा उन अभिव्यक्तियों का उपयोग करती है जिन्हें गार्ड में अनुमति नहीं है, और अन्यथा एक निजी मैक्रो बनाता है जिसे वर्तमान मॉड्यूल में गार्ड के अंदर या बाहर दोनों का उपयोग किया जा सकता है।

defmacrop/2 समान, वर्तमान मॉड्यूल में इसके उपयोग से पहले defguardp(guard) को परिभाषित किया जाना चाहिए।

विक्षेप (नाम, ऑप्स, do_block \\ []) (मैक्रो)

दिए गए प्रोटोकॉल के लिए एक कार्यान्वयन को परिभाषित करता है।

प्रोटोकॉल के बारे में अधिक जानकारी और उदाहरण के लिए defprotocol/2 देखें।

एक कार्यान्वयन के अंदर, प्रोटोकॉल के नाम के माध्यम से @protocol और वर्तमान लक्ष्य तक पहुँचा जा सकता है @for

डिफामाक्रो (कॉल, एक्सप्रैस \\ नील) (मैक्रो)

दिए गए नाम और शरीर के साथ एक मैक्रो को परिभाषित करता है।

def/2 नामकरण और डिफ़ॉल्ट तर्कों पर नियमों की जाँच करें ।

उदाहरण

defmodule MyLogic do
  defmacro unless(expr, opts) do
    quote do
      if !unquote(expr), unquote(opts)
    end
  end
end

require MyLogic
MyLogic.unless false do
  IO.puts "It works"
end

डिफैमेक्रोप (कॉल, एक्सप्रैस \\ नील) (मैक्रो)

दिए गए नाम और शरीर के साथ एक निजी मैक्रो को परिभाषित करता है।

निजी मैक्रोज़ केवल उसी मॉड्यूल से पहुंच योग्य हैं जिसमें वे परिभाषित हैं।

चेक defmacro/2 में अधिक जानकारी के लिए, और जाँच def/2 नामकरण और डिफ़ॉल्ट तर्क पर नियमों के लिए।

डीमोडुले (अन्य, do_block) (मैक्रो)

दिए गए सामग्रियों के साथ नाम द्वारा दिए गए मॉड्यूल को परिभाषित करता है।

यह मैक्रो किसी मॉड्यूल alias को उसके नाम और दिए गए कंटेंट के साथ परिभाषित करता है । यह चार तत्वों के साथ टपल लौटाता है:

  • :module
  • मॉड्यूल का नाम
  • मॉड्यूल की द्विआधारी सामग्री
  • सामग्री ब्लॉक के मूल्यांकन का परिणाम है

उदाहरण

iex> defmodule Foo do
...>   def bar, do: :baz
...> end
iex> Foo.bar()
:baz

घोंसला करने की क्रिया

एक मॉड्यूल को किसी अन्य मॉड्यूल के अंदर घोंसले में डालना नेस्टेड मॉड्यूल के नाम को प्रभावित करता है:

defmodule Foo do
  defmodule Bar do
  end
end

ऊपर दिए गए उदाहरण में, दो मॉड्यूल - Foo और Foo.Bar - बनाए गए हैं। नेस्टिंग करते समय, अमृत स्वचालित रूप से आंतरिक मॉड्यूल के लिए एक उपनाम बनाता है, जिससे दूसरे मॉड्यूल Foo.Bar को Bar उसी लेक्सिकल स्कोप में एक्सेस किया जा सकता है जहां इसे परिभाषित किया गया है ( Foo मॉड्यूल)।

यदि Foo.Bar मॉड्यूल कहीं और ले जाया जाता है, के लिए संदर्भ Bar में Foo मॉड्यूल पूरी तरह से योग्य नाम (करने के लिए अद्यतन करने की आवश्यकता Foo.Bar ) या एक उपनाम स्पष्ट रूप में सेट हो गया है Foo की मदद से मॉड्यूल Kernel.SpecialForms.alias/2

defmodule Foo.Bar do
  # code
end

defmodule Foo do
  alias Foo.Bar
  # code here can refer to "Foo.Bar" as just "Bar"
end

मॉड्यूल के नाम

एक मॉड्यूल नाम कोई भी परमाणु हो सकता है, लेकिन अमृत एक विशेष सिंटैक्स प्रदान करता है जो आमतौर पर मॉड्यूल नामों के लिए उपयोग किया जाता है। क्या कहा जाता है एक मॉड्यूल नाम एक अपरकेस ASCII पत्र है जिसके बाद किसी भी संख्या में लोअरकेस या अपरकेस ASCII अक्षर , संख्या या अंडरस्कोर होते हैं । यह पहचानकर्ता द्वारा उपसर्ग किए गए परमाणु के बराबर है Elixir. । तो defmodule Foo उदाहरण Foo के बराबर है :"Elixir.Foo"

गतिशील नाम

अमृत ​​मॉड्यूल नाम गतिशील रूप से उत्पन्न हो सकते हैं। मैक्रोज़ के साथ काम करते समय यह बहुत उपयोगी है। उदाहरण के लिए, कोई लिख सकता है:

defmodule String.to_atom("Foo#{1}") do
  # contents ...
end

अमृत ​​तब तक किसी भी मॉड्यूल नाम को स्वीकार करेगा जब तक कि defmodule/2 किसी परमाणु के मूल्यांकन के लिए पहला तर्क के रूप में पारित किया गया । ध्यान दें कि, जब एक गतिशील नाम का उपयोग किया जाता है, तो अमृत मौजूदा मॉड्यूल के तहत नाम का घोंसला नहीं करेगा और न ही स्वचालित रूप से एक उपनाम सेट करेगा।

रक्षा करने योग्य (keywords_or_behaviour) (मैक्रो)

वर्तमान मॉड्यूल में दिए गए कार्यों को अधिक महत्वपूर्ण बनाता है।

एक overridable फ़ंक्शन को lazily परिभाषित किया गया है, जो एक डेवलपर को इसे ओवरराइड करने की अनुमति देता है।

उदाहरण

defmodule DefaultMod do
  defmacro __using__(_opts) do
    quote do
      def test(x, y) do
        x + y
      end

      defoverridable [test: 2]
    end
  end
end

defmodule InheritMod do
  use DefaultMod

  def test(x, y) do
    x * y + super(x, y)
  end
end

जैसा कि ऊपर दिए गए उदाहरण में देखा गया है, super का उपयोग डिफ़ॉल्ट कार्यान्वयन को कॉल करने के लिए किया जा सकता है।

यदि @behaviour परिभाषित किया गया है, तो defoverridable एक तर्क के रूप में एक मॉड्यूल के साथ भी बुलाया जा सकता है। कॉल के ऊपर होने वाले व्यवहार से सभी कार्यान्वित कॉलबैक defoverridable को अधिकनीय के रूप में चिह्नित किया जाएगा।

उदाहरण

defmodule Behaviour do
  @callback foo :: any
end

defmodule DefaultMod do
  defmacro __using__(_opts) do
    quote do
      @behaviour Behaviour

      def foo do
        "Override me"
      end

      defoverridable Behaviour
    end
  end
end

defmodule InheritMod do
  use DefaultMod

  def foo do
    "Overridden"
  end
end

डीईएमपी (कॉल, एक्सपायर \ एनएल) (मैक्रो)

दिए गए नाम और शरीर के साथ एक निजी फ़ंक्शन को परिभाषित करता है।

निजी कार्य केवल उस मॉड्यूल के भीतर से सुलभ हैं जिसमें वे परिभाषित हैं। एक UndefinedFunctionError अपवाद के परिणामों में परिभाषित मॉड्यूल के बाहर से एक निजी फ़ंक्शन तक पहुंचने की कोशिश करना ।

def/2 अधिक जानकारी के लिए जाँच करें ।

उदाहरण

defmodule Foo do
  def bar do
    sum(1, 2)
  end

  defp sum(a, b), do: a + b
end

Foo.bar() #=> 3
Foo.sum(1, 2) #=> ** (UndefinedFunctionError) undefined function Foo.sum/2

डिफ्रोटोकॉल (नाम, do_block) (मैक्रो)

एक प्रोटोकॉल को परिभाषित करता है।

एक प्रोटोकॉल एक एपीआई को निर्दिष्ट करता है जिसे इसके कार्यान्वयन द्वारा परिभाषित किया जाना चाहिए।

उदाहरण

अमृत ​​में, हमारे पास यह जांचने के लिए दो क्रियाएं हैं कि डेटा संरचना में कितने आइटम हैं: length और size length मतलब जानकारी की गणना की जानी चाहिए। उदाहरण के लिए, length(list) इसकी लंबाई की गणना करने के लिए पूरी सूची को पार करना होगा। दूसरी ओर, tuple_size(tuple) और byte_size(binary) टपल और बाइनरी आकार पर निर्भर नहीं करते हैं क्योंकि आकार की जानकारी डेटा संरचना में पूर्वनिर्मित है।

यद्यपि अमृत में विशिष्ट कार्य शामिल हैं tuple_size , binary_size और map_size , कभी-कभी हम इसके प्रकार की परवाह किए बिना डेटा संरचना के आकार को पुनः प्राप्त करने में सक्षम होना चाहते हैं। अमृत ​​में हम बहुरूपियों का कोड लिख सकते हैं, अर्थात प्रोटोकॉल का उपयोग करके विभिन्न आकृतियों / प्रकारों के साथ काम करने वाला कोड। एक आकार प्रोटोकॉल निम्नानुसार लागू किया जा सकता है:

defprotocol Size do
  @doc "Calculates the size (and not the length!) of a data structure"
  def size(data)
end

अब जब प्रोटोकॉल हर डेटा संरचना के लिए लागू किया जा सकता है, तो प्रोटोकॉल के लिए एक अनिवार्य कार्यान्वयन हो सकता है:

defimpl Size, for: BitString do
  def size(binary), do: byte_size(binary)
end

defimpl Size, for: Map do
  def size(map), do: map_size(map)
end

defimpl Size, for: Tuple do
  def size(tuple), do: tuple_size(tuple)
end

ध्यान दें कि हमने इसे सूचियों के लिए लागू नहीं किया क्योंकि हमारे पास size सूचियों की जानकारी नहीं है , बल्कि इसके मूल्य की गणना करने की आवश्यकता है length

सभी अमृत प्रकारों के लिए प्रोटोकॉल लागू करना संभव है:

प्रोटोकॉल और संरचना

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

defimpl Size, for: MapSet do
  def size(map_set), do: MapSet.size(map_set)
end

किसी संरचना के लिए प्रोटोकॉल लागू करते :for समय , विकल्प को छोड़ दिया जा सकता है यदि defimpl कॉल मॉड्यूल के अंदर है जो संरचना को परिभाषित करता है:

defmodule User do
  defstruct [:email, :name]

  defimpl Size do
    def size(%User{}), do: 2 # two fields
  end
end

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

किसी को पतन

कुछ मामलों में, सभी प्रकार के लिए एक डिफ़ॉल्ट कार्यान्वयन प्रदान करना सुविधाजनक हो सकता है। यह प्रोटोकॉल परिभाषा में @fallback_to_any विशेषता सेट करके प्राप्त किया जा सकता है true :

defprotocol Size do
  @fallback_to_any true
  def size(data)
end

Size प्रोटोकॉल अब के लिए लागू किया जा सकता Any :

defimpl Size, for: Any do
  def size(_), do: 0
end

हालांकि उपरोक्त कार्यान्वयन यकीनन उचित नहीं है। उदाहरण के लिए, यह कहने का कोई मतलब नहीं है कि पीआईडी ​​या एक इंटीजर का आकार 0. है। यही कारण है कि @fallback_to_any एक ऑप्ट-इन व्यवहार है। प्रोटोकॉल के बहुमत के लिए, प्रोटोकॉल लागू नहीं होने पर त्रुटि उठाना उचित व्यवहार है।

एकाधिक कार्यान्वयन

प्रोटोकॉल को एक साथ कई प्रकारों के लिए लागू किया जा सकता है:

defprotocol Reversible do
  def reverse(term)
end

defimpl Reversible, for: [Map, List] do
  def reverse(term), do: Enum.reverse(term)
end

प्रकार

एक प्रोटोकॉल को परिभाषित करना स्वचालित रूप से नामित एक प्रकार को परिभाषित करता है t , जिसका उपयोग निम्नानुसार किया जा सकता है:

@spec print_size(Size.t) :: :ok
def print_size(data) do
  IO.puts(case Size.size(data) do
    0 -> "data has no items"
    1 -> "data has one item"
    n -> "data has #{n} items"
  end)
end

@spec इसके बाद के संस्करण को व्यक्त करता है कि सभी प्रकार दिया प्रोटोकॉल को लागू करने की अनुमति दी दी समारोह के लिए मान्य तर्क प्रकार हैं।

प्रतिबिंब

किसी भी प्रोटोकॉल मॉड्यूल में तीन अतिरिक्त कार्य होते हैं:

  • __protocol__/1 - प्रोटोकॉल नाम लौटाता है जब :name , प्रोटोकॉल कार्यों और उनके arities के साथ एक कीवर्ड सूची दी गई है जब :functions दिया जाता है, और कार्यान्वयन की एक सूची जब :impls दिया जाता है

  • impl_for/1 - एक संरचना प्राप्त करता है और मॉड्यूल को लौटाता है जो संरचना के लिए प्रोटोकॉल को लागू करता है, nil अन्यथा

  • impl_for!/1 - जैसा कि ऊपर है, लेकिन यदि कोई कार्यान्वयन नहीं मिला है, तो एक त्रुटि उठाता है

    Enumerable.__protocol__(:functions)
    #=> [count: 1, member?: 2, reduce: 3]
    
    Enumerable.impl_for([])
    #=> Enumerable.List
    
    Enumerable.impl_for(42)
    #=> nil

समेकन

विकास में कोड लोडिंग का सामना करने के लिए, एलिक्सिर में प्रोटोकॉल विकास के लिए विशिष्ट प्रेषण प्रोटोकॉल का धीमी कार्यान्वयन प्रदान करते हैं।

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

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

def project do
  ...
  elixirc_paths: elixirc_paths(Mix.env)
  ...
end

defp elixirc_paths(:test), do: ["lib", "test/support"]
defp elixirc_paths(_), do: ["lib"]

और फिर आप अंदर परीक्षण वातावरण के लिए विशिष्ट कार्यान्वयन को परिभाषित कर सकते हैं test/support/some_file.ex

एक अन्य दृष्टिकोण आपके मिश्रण में परीक्षणों के दौरान प्रोटोकॉल समेकन को अक्षम करना है:

def project do
  ...
  consolidate_protocols: Mix.env != :test
  ...
end

हालांकि ऐसा करने की अनुशंसा नहीं की जाती है क्योंकि यह आपके परीक्षण सूट के प्रदर्शन को प्रभावित कर सकता है।

अंत में ध्यान दें कि सभी प्रोटोकॉल संकलक द्वारा निर्धारित विकल्प की परवाह किए बिना, debug_info सेट के साथ संकलित true किए जाते हैं elixirc । डीबग जानकारी का उपयोग समेकन के लिए किया जाता है और इसे समेकन के बाद हटाया जा सकता है।

अवरोध (क्षेत्र) (मैक्रो)

एक संरचना को परिभाषित करता है।

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

एक संरचना को परिभाषित करने के लिए, एक डेवलपर को दोनों कार्यों __struct__/0 और __struct__/1 कार्यों को परिभाषित करना होगा । defstruct(fields) एक सुविधा मैक्रो है जो ऐसे कार्यों को कुछ उपयुक्तताओं के साथ परिभाषित करता है।

संरचना के बारे में अधिक जानकारी के लिए, कृपया देखें Kernel.SpecialForms.%/2

उदाहरण

defmodule User do
  defstruct name: nil, age: nil
end

संरचना क्षेत्रों का संकलन-समय पर मूल्यांकन किया जाता है, जो उन्हें गतिशील होने की अनुमति देता है। नीचे दिए गए उदाहरण में, 10 + 11 संकलन-समय पर मूल्यांकन किया जाता है और आयु क्षेत्र को मूल्य के साथ संग्रहीत किया जाता है 21 :

defmodule User do
  defstruct name: nil, age: 10 + 11
end

fields तर्क आम तौर पर परमाणु कुंजी और संबंधित मानों के रूप में डिफ़ॉल्ट मान के रूप में फ़ील्ड नाम के साथ एक कीवर्ड सूची है। defstruct(fields) अपने तर्क के रूप में परमाणुओं की एक सूची का भी समर्थन करता है: उस स्थिति में, सूची में परमाणुओं को संरचना के क्षेत्र नामों के रूप में उपयोग किया जाएगा और वे सभी डिफ़ॉल्ट होंगे nil

defmodule Post do
  defstruct [:title, :content, :author]
end

पाने

हालांकि संरचनाएं नक्शे हैं, डिफ़ॉल्ट रूप से संरचनाएं नक्शे के लिए लागू किसी भी प्रोटोकॉल को लागू नहीं करती हैं। उदाहरण के लिए, User संरचना के साथ प्रोटोकॉल का उपयोग करने का प्रयास करने से त्रुटि होती है:

john = %User{name: "John"}
MyProtocol.call(john)
** (Protocol.UndefinedError) protocol MyProtocol not implemented for %User{...}

defstruct(fields) हालाँकि, प्रोटोकॉल कार्यान्वयन को व्युत्पन्न करने की अनुमति देता है । यह एक @derive विशेषता को परिभाषित करने से पहले सूची के रूप में परिभाषित करके किया जा सकता है defstruct(fields) :

defmodule User do
  @derive [MyProtocol]
  defstruct name: nil, age: 10 + 11
end

MyProtocol.call(john) #=> works

@derive सूची में प्रत्येक प्रोटोकॉल के लिए, अमृत दावा करेगा कि किसी के लिए भी उस प्रोटोकॉल का कार्यान्वयन है (चाहे कोई भी कमबैक हो true ) और जांचें कि क्या कोई कार्यान्वयन __deriving__/3 कॉलबैक (के माध्यम से Protocol.derive/3 ) को परिभाषित करता है । यदि ऐसा है, तो कॉलबैक लागू किया जाता है, अन्यथा एक कार्यान्वयन जो किसी भी कार्यान्वयन के लिए इंगित करता है, स्वचालित रूप से व्युत्पन्न होता है।

कुंजी लागू करना

एक संरचना का निर्माण करते समय, अमृत स्वचालित रूप से सभी कुंजियों की गारंटी देगा जो कि संरचना से संबंधित है:

%User{name: "john", unknown: :key}
** (KeyError) key :unknown not found in: %User{age: 21, name: nil}

अमृत ​​भी डेवलपर्स को कुछ महत्वपूर्ण लागू करने की अनुमति देता है हमेशा संरचना बनाते समय दिया जाना चाहिए:

defmodule User do
  @enforce_keys [:name]
  defstruct name: nil, age: 10 + 11
end

अब नाम की कुंजी के बिना एक संरचना बनाने की कोशिश विफल हो जाएगी:

%User{age: 21}
** (ArgumentError) the following keys must also be given when building struct User: [:name]

ध्यान रखें कि @enforce_keys ढांचा बनाते समय डेवलपर्स की सहायता के लिए एक सरल संकलन-समय की गारंटी है। इसे अपडेट पर लागू नहीं किया गया है और यह किसी भी प्रकार का मूल्य-सत्यापन प्रदान नहीं करता है।

प्रकार

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

defmodule User do
  defstruct name: "John", age: 25
  @type t :: %User{name: String.t, age: non_neg_integer}
end

यह केवल संरचना के प्रकार को परिभाषित करते समय संरचना सिंटैक्स का उपयोग करने के लिए अनुशंसित है। किसी अन्य संरचना का संदर्भ देते समय User.t इसके बजाय इसका उपयोग करना बेहतर होता है %User{}

%User{} डिफ़ॉल्ट के लिए शामिल नहीं किए गए संरचना फ़ील्ड के प्रकार term

ऐसी संरचनाएं जिनकी आंतरिक संरचना स्थानीय मॉड्यूल के लिए निजी है (पैटर्न उन्हें मेल खाता है या सीधे अपने क्षेत्रों तक पहुंचने की अनुमति नहीं होनी चाहिए) को @opaque विशेषता का उपयोग करना चाहिए । ऐसी संरचनाएं जिनका आंतरिक ढांचा सार्वजनिक है, का उपयोग करना चाहिए @type

विनाश (बाएं, दाएं) (मैक्रो)

दो सूचियों को नष्ट कर देता है, प्रत्येक शब्द को दाईं ओर एक मेल खाते में बाईं ओर रखता है।

पैटर्न मिलान के विपरीत = , यदि बाएं और दाएं सूचियों के आकार मेल नहीं खाते हैं, तो त्रुटि को बढ़ाने के बजाय विनाशकारी बस रुक जाती है।

उदाहरण

iex> destructure([x, y, z], [1, 2, 3, 4, 5])
iex> {x, y, z}
{1, 2, 3}

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

iex> destructure([x, y, z], [1])
iex> {x, y, z}
{1, nil, nil}

बाएं हाथ की ओर किसी भी अभिव्यक्ति का समर्थन करता है जिसे आप एक मैच के बाईं ओर उपयोग करेंगे:

x = 1
destructure([^x, y, z], [1, 2, 3])

उपरोक्त उदाहरण केवल तभी काम करेगा x जब सही सूची में पहले मूल्य से मेल खाता हो। अन्यथा, यह एक MatchError (जैसे = ऑपरेटर करेगा) उठाएगा ।

div (लाभांश, भाजक)

div(integer(), neg_integer() | pos_integer()) :: integer()

पूर्णांक विभाजन करता है।

यदि कोई तर्क पूर्णांक नहीं है, या जब divisor 0 है, तो एक ArithmeticError अपवाद को उठाता है।

div/2 प्रदर्शन करती है छोटा कर दिया पूर्णांक विभाजन। इसका मतलब है कि परिणाम हमेशा शून्य की ओर गोल होता है।

यदि आप फ्लोर्ड पूर्णांक विभाजन (नकारात्मक अनंत की ओर घूमना) करना चाहते हैं, तो Integer.floor_div/2 इसके बजाय उपयोग करें ।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

div(5, 2)
#=> 2

div(6, -4)
#=> -1

div(-99, 2)
#=> -49

div(100, 0)
#=> ** (ArithmeticError) bad argument in arithmetic expression

एलएम (टपल, इंडेक्स)

elem(tuple(), non_neg_integer()) :: term()

शून्य-आधारित index में तत्व प्राप्त करता है tuple

यह ArgumentError तब बढ़ता है जब सूचकांक नकारात्मक होता है या यह टपल तत्वों की सीमा से बाहर होता है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

tuple = {:foo, :bar, 3}
elem(tuple, 1)
#=> :bar

elem({}, 0)
#=> ** (ArgumentError) argument error

elem({:foo, :bar}, 2)
#=> ** (ArgumentError) argument error

बाहर निकलने के (कारण)

exit(term()) :: no_return()

दिए गए कारण के साथ कॉलिंग प्रक्रिया के निष्पादन को रोकता है।

चूंकि इस फ़ंक्शन का मूल्यांकन करने से प्रक्रिया समाप्त हो जाती है, इसका कोई वापसी मूल्य नहीं है।

संकलक द्वारा झुका हुआ।

उदाहरण

जब कोई प्रक्रिया अपने अंत तक पहुँचती है, तो डिफ़ॉल्ट रूप से यह कारण के साथ बाहर निकल जाती है :normalexit(reason) यदि आप किसी प्रक्रिया को समाप्त करना चाहते हैं तो स्पष्ट रूप से कॉल कर सकते हैं, लेकिन किसी भी विफलता का संकेत नहीं दे सकते:

exit(:normal)

यदि कुछ गलत हो जाता है, तो आप exit(reason) एक अलग कारण के साथ भी उपयोग कर सकते हैं :

exit(:seems_bad)

यदि बाहर निकलने का कारण नहीं है :normal , तो बाहर निकलने वाली प्रक्रिया से जुड़ी सभी प्रक्रियाएं दुर्घटनाग्रस्त हो जाएंगी (जब तक कि वे बाहर नहीं जा रहे हैं)।

OTP बाहर निकलता है

यह निर्धारित करने के लिए कि किसी प्रक्रिया से असामान्य रूप से बाहर निकला है या नहीं, OTP द्वारा निकास का उपयोग किया जाता है। निम्नलिखित निकास को "सामान्य" माना जाता है:

  • exit(:normal)
  • exit(:shutdown)
  • exit({:shutdown, term})

किसी अन्य कारण से बाहर निकलना असामान्य माना जाता है और दुर्घटना के रूप में माना जाता है। इसका अर्थ है डिफ़ॉल्ट पर्यवेक्षक व्यवहार में किक करता है, त्रुटि रिपोर्ट उत्सर्जित होती हैं, आदि।

यह व्यवहार कई अलग-अलग जगहों पर निर्भर है। उदाहरण के लिए, लिंक प्रक्रिया, पर्यवेक्षण पेड़ों और इतने पर भी शटडाउन को इंगित करने के लिए परीक्षण प्रक्रिया से बाहर निकलते समय ExUnit उपयोग करता exit(:shutdown) है।

सीएलआई बाहर निकलता है

उपरोक्त उल्लिखित निकास संकेतों के शीर्ष पर बिल्डिंग, यदि कमांड लाइन द्वारा शुरू की गई प्रक्रिया ऊपर दिए गए तीन कारणों में से किसी एक के साथ बाहर निकलती है, तो इसका निकास सामान्य माना जाता है और ऑपरेटिंग सिस्टम प्रक्रिया 0 की स्थिति से बाहर निकल जाएगी।

हालाँकि, यह संभव है कि आप ऑपरेटिंग सिस्टम से बाहर निकलने के संकेत को कस्टमाइज़ कर सकते हैं:

exit({:shutdown, integer})

यह ओएस प्रक्रिया को integer सभी लिंक किए गए एरलांग प्रक्रियाओं को विनम्रतापूर्वक बंद करने के संकेत देते हुए दिए गए स्थिति से बाहर निकलने का कारण बनेगा ।

किसी भी अन्य निकास कारण से ओएस प्रक्रिया को स्थिति से बाहर निकलने का कारण होगा 1 और दुर्घटनाग्रस्त होने से जुड़ी एरलंग प्रक्रियाओं से जुड़ा होगा।

function_exported? (मॉड्यूल, फ़ंक्शन, एरिटी)

function_exported?(module(), atom(), arity()) :: boolean()

रिटर्न true अगर module भरी हुई है और एक सार्वजनिक होता है function दिया साथ arity , नहीं तो false

ध्यान दें कि यह फ़ंक्शन लोड नहीं होने की स्थिति में मॉड्यूल को लोड नहीं करता है। Code.ensure_loaded/1 अधिक जानकारी के लिए जाँच करें ।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> function_exported?(Enum, :member?, 2)
true

get_and_update_in (पथ, मज़ा) (मैक्रो)

एक मान हो जाता है और दिए गए के माध्यम से एक नेस्टेड डेटा संरचना को अपडेट करता है path

यह get_and_update_in/3 एक सूची को पारित करने के बजाय मैक्रो के माध्यम से निकाले जाने के अलावा, समान है । उदाहरण के लिए:

get_and_update_in(opts[:foo][:bar], &{&1, &1 + 1})

के बराबर है:

get_and_update_in(opts, [:foo, :bar], &{&1, &1 + 1})

ध्यान दें कि इस मैक्रो को काम करने के लिए, पूरा रास्ता हमेशा इस मैक्रो द्वारा दिखाई देना चाहिए। नीचे दिए गए पथ अनुभाग देखें।

उदाहरण

iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
iex> get_and_update_in(users["john"].age, &{&1, &1 + 1})
{27, %{"john" => %{age: 28}, "meg" => %{age: 23}}}

पथ

एक पथ एक चर, स्थानीय या दूरस्थ कॉल के साथ शुरू हो सकता है, और एक या एक से अधिक का पालन किया जाना चाहिए:

  • foo[bar] - कुंजी bar में पहुंचता है foo ; यदि मामला foo शून्य है, nil लौटा दिया जाता है

  • foo.bar - एक नक्शा / संरचना क्षेत्र तक पहुँचता है; यदि फ़ील्ड मौजूद नहीं है, तो एक त्रुटि उठाई जाती है

यहाँ कुछ मान्य पथ दिए गए हैं:

users["john"][:age]
users["john"].age
User.all["john"].age
all_users()["john"].age

यहाँ कुछ अमान्य हैं:

# Does a remote call after the initial value
users["john"].do_something(arg1, arg2)

# Does not access any key or field
users

get_and_update_in (डेटा, कुंजियाँ, मज़ा)

get_and_update_in(
  structure :: Access.t(),
  keys,
  (term() -> {get_value, update_value} | :pop)
) :: {get_value, structure :: Access.t()}
when keys: [any(), ...], update_value: term(), get_value: var

एक मान प्राप्त करता है और एक नेस्टेड संरचना को अपडेट करता है।

data एक नेस्टेड संरचना है (जो कि एक नक्शा, कीवर्ड सूची, या संरचना जो Access व्यवहार को लागू करती है)।

fun तर्क का मान प्राप्त करता है key (या nil यदि key मौजूद नहीं है) और निम्न में से एक मान लौटाएगा:

  • एक दो-तत्व ट्यूपल {get_value, new_value} । इस मामले में, get_value पुनः प्राप्त मूल्य है जो संभवत: वापस लौटने से पहले संचालित किया जा सकता है। new_value नया मान के तहत संग्रहीत करने के लिए है key

  • :pop , जिसका तात्पर्य है कि मौजूदा मूल्य key को संरचना से हटाकर वापस कर दिया जाना चाहिए।

यह फ़ंक्शन Access दिए गए अनुसार संरचना को पार करने के लिए मॉड्यूल का उपयोग करता है keys , जब तक कि key फ़ंक्शन न हो।

यदि कोई फ़ंक्शन एक फ़ंक्शन है, तो फ़ंक्शन को तीन तर्क पास करते हुए आमंत्रित किया जाएगा:

  • ऑपरेशन ( :get_and_update )
  • एक्सेस किया जाने वाला डेटा
  • एक फ़ंक्शन अगले के लिए लागू किया जाएगा

यह साधन get_and_update_in/3 कस्टम लुकअप प्रदान करने के लिए बढ़ाया जा सकता है। नकारात्मक पक्ष यह है कि कार्यों को एक्सेस किए गए डेटा संरचनाओं में कुंजियों के रूप में संग्रहीत नहीं किया जा सकता है।

उदाहरण

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

iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
iex> get_and_update_in(users, ["john", :age], &{&1, &1 + 1})
{27, %{"john" => %{age: 28}, "meg" => %{age: 23}}}

जब कोई एक फ़ंक्शन होता है, तो फ़ंक्शन को लागू किया जाता है। नीचे दिए गए उदाहरण में, हम एक सूची के अंदर सभी उम्र पाने और बढ़ाने के लिए एक फ़ंक्शन का उपयोग करते हैं:

iex> users = [%{name: "john", age: 27}, %{name: "meg", age: 23}]
iex> all = fn :get_and_update, data, next ->
...>   data |> Enum.map(next) |> Enum.unzip()
...> end
iex> get_and_update_in(users, [all, :age], &{&1, &1 + 1})
{[27, 23], [%{name: "john", age: 28}, %{name: "meg", age: 24}]}

यदि फ़ंक्शन को लागू करने से पहले पिछला मान है nil , तो फ़ंक्शन को एक मान के रूप में प्राप्त होगा nil और इसे तदनुसार संभालना होगा (यह विफल होने या एक डिफ़ॉल्ट डिफ़ॉल्ट प्रदान करके)।

Access कई सुविधा एक्सेसर काम करता है, की तरह साथ मॉड्यूल जहाजों all गुमनाम समारोह ऊपर परिभाषित। उदाहरण के रूप में देखें Access.all/0 , Access.key/2 और अन्य।

get_in (डेटा, कुंजियाँ)

get_in(Access.t(), [term(), ...]) :: term()

एक नेस्टेड संरचना से एक मूल्य प्राप्त होता है।

जब तक एक फ़ंक्शन नहीं है, तब तक Access दिए गए अनुसार संरचना को पार करने के लिए मॉड्यूल का उपयोग करता है । keys key

यदि कोई फ़ंक्शन एक फ़ंक्शन है, तो फ़ंक्शन को तीन तर्क पास करते हुए आमंत्रित किया जाएगा:

  • ऑपरेशन ( :get )
  • एक्सेस किया जाने वाला डेटा
  • एक फ़ंक्शन अगले के लिए लागू किया जाएगा

यह साधन get_in/2 कस्टम लुकअप प्रदान करने के लिए बढ़ाया जा सकता है। नकारात्मक पक्ष यह है कि कार्यों को एक्सेस किए गए डेटा संरचनाओं में कुंजियों के रूप में संग्रहीत नहीं किया जा सकता है।

उदाहरण

iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
iex> get_in(users, ["john", :age])
27

मध्य रिटर्न में किसी भी प्रविष्टि के मामले में nil , मॉड्यूल के nil अनुसार लौटा दिया जाएगा Access :

iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
iex> get_in(users, ["unknown", :age])
nil

जब चाबियों में से एक ऐसा फ़ंक्शन होता है जिसमें तीन तर्क होते हैं, तो फ़ंक्शन को लागू किया जाता है। नीचे दिए गए उदाहरण में, हम किसी सूची के अंदर सभी मानचित्र प्राप्त करने के लिए एक फ़ंक्शन का उपयोग करते हैं:

iex> users = [%{name: "john", age: 27}, %{name: "meg", age: 23}]
iex> all = fn :get, data, next -> Enum.map(data, next) end
iex> get_in(users, [all, :age])
[27, 23]

यदि फ़ंक्शन को लागू करने से पहले पिछला मान है nil , तो फ़ंक्शन को एक मूल्य के रूप में प्राप्त होगा nil और तदनुसार इसे संभालना होगा।

एचडी (सूची)

hd(nonempty_maybe_improper_list(elem, any())) :: elem when elem: term()

किसी सूची का प्रमुख लौटाता है। ArgumentError यदि सूची खाली है तो उठाता है।

यह अनुचित सूचियों के साथ काम करता है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

hd([1, 2, 3, 4])
#=> 1

hd([])
#=> ** (ArgumentError) argument error

hd([1 | 2])
#=> 1

यदि (स्थिति, खंड) (मैक्रो)

if/2 स्थूल प्रदान करता है ।

यह मैक्रो एक स्थिति होने के लिए पहले तर्क और एक कीवर्ड सूची के लिए दूसरा तर्क होने की उम्मीद करता है।

वन-लाइनर उदाहरण हैं

if(foo, do: bar)

ऊपर दिए गए उदाहरण में, bar यदि foo मूल्यांकन किया जाता है true , तो लौटा दिया जाएगा (यानी, यह न तो है false और न ही nil )। नहीं nil तो वापस कर दिया जाएगा।

else विपरीत को निर्दिष्ट करने के लिए एक विकल्प दिया जा सकता है:

if(foo, do: bar, else: baz)

उदाहरणों को अवरुद्ध करता है

if/2 मैक्रो को ब्लॉक करना भी संभव है । ऊपर दिए गए पहले उदाहरण का अनुवाद इस प्रकार किया जाएगा:

if foo do
  bar
end

ध्यान दें कि do/end सीमांकक हो जाते हैं। दूसरा उदाहरण इसका अनुवाद करेगा:

if foo do
  bar
else
  baz
end

दो से अधिक खंडों की तुलना करने के लिए, cond/1 मैक्रो का उपयोग करना होगा।

दाएं बाएं (मैक्रो)

यह जाँचता है कि बाईं ओर का तत्व दाएँ हाथ की तरफ संग्रह का सदस्य है या नहीं।

उदाहरण

iex> x = 1
iex> x in [1, 2, 3]
true

यह ऑपरेटर (जो एक मैक्रो है) बस एक कॉल के लिए अनुवाद करता है Enum.member?/2 । ऊपर दिए गए उदाहरण में अनुवाद होगा:

Enum.member?([1, 2, 3], x)

अमृत ​​भी समर्थन करता है left not in right , जो इसका मूल्यांकन करता है not(left in right) :

iex> x = 1
iex> x not in [1, 2, 3]
false

गार्ड

in/2 ऑपरेटर (और साथ ही not in ) के रूप में लंबे समय के रूप दाएँ हाथ की ओर एक सीमा या एक सूची है गार्ड खंड में इस्तेमाल किया जा सकता है। ऐसे मामलों में, अमृत एक वैध गार्ड अभिव्यक्ति के लिए ऑपरेटर का विस्तार करेगा। उदाहरण के लिए:

when x in [1, 2, 3]

अनुवाद करने के लिए:

when x === 1 or x === 2 or x === 3

श्रेणियों का उपयोग करते समय:

when x in 1..3

अनुवाद करने के लिए:

when is_integer(x) and x >= 1 and x <= 3

ध्यान दें कि केवल पूर्णांकों को सीमा के अंदर माना जा सकता है in

एएसटी विचार

left not in right संकलक द्वारा एएसटी में पार्स किया गया है:

{:not, _, [{:in, _, [left, right]}]}

यह उसी तरह का एएसटी है not(left in right)

इसके अतिरिक्त, Macro.to_string/2 इस एएसटी की सभी घटनाओं का अनुवाद करेंगे left not in right

निरीक्षण (शब्द, opts \\ [])

inspect(Inspect.t(), keyword()) :: String.t()

Inspect प्रोटोकॉल के अनुसार दिए गए तर्क का निरीक्षण करता है। दूसरा तर्क एक कीवर्ड सूची है जिसमें निरीक्षण को नियंत्रित करने के विकल्प हैं।

विकल्प

inspect/2 उन विकल्पों की एक सूची को स्वीकार करता है जो आंतरिक रूप से एक Inspect.Opts संरचना में अनुवादित हैं । Inspect.Opts समर्थित विकल्पों को देखने के लिए डॉक्स की जाँच करें।

उदाहरण

iex> inspect(:foo)
":foo"

iex> inspect([1, 2, 3, 4, 5], limit: 3)
"[1, 2, 3, ...]"

iex> inspect([1, 2, 3], pretty: true, width: 0)
"[1,\n 2,\n 3]"

iex> inspect("olá" <> <<0>>)
"<<111, 108, 195, 161, 0>>"

iex> inspect("olá" <> <<0>>, binaries: :as_strings)
"\"olá\\0\""

iex> inspect("olá", binaries: :as_binaries)
"<<111, 108, 195, 161>>"

iex> inspect('bar')
"'bar'"

iex> inspect([0 | 'bar'])
"[0, 98, 97, 114]"

iex> inspect(100, base: :octal)
"0o144"

iex> inspect(100, base: :hex)
"0x64"

ध्यान दें कि Inspect प्रोटोकॉल आवश्यक रूप से एक अमृत शब्द के वैध प्रतिनिधित्व को वापस नहीं करता है। ऐसे मामलों में, निरीक्षण परिणाम के साथ शुरू होना चाहिए # । उदाहरण के लिए, एक फ़ंक्शन का निरीक्षण करना वापस आ जाएगा:

inspect fn a, b -> a + b end
#=> #Function<...>

is_atom (शब्द)

is_atom(term()) :: boolean()

रिटर्न true अगर term एक परमाणु है; अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

is_binary (शब्द)

is_binary(term()) :: boolean()

true अगर term एक द्विआधारी है तो लौटाता है; अन्यथा लौटता है false

एक बाइनरी में हमेशा बाइट्स की एक पूरी संख्या होती है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> is_binary("foo")
true
iex> is_binary(<<1::3>>)
false

is_bitstring (शब्द)

is_bitstring(term()) :: boolean()

रिटर्न true अगर term एक बिटस्ट्रिंग (एक बाइनरी सहित) है; अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> is_bitstring("foo")
true
iex> is_bitstring(<<1::3>>)
true

is_boolean (शब्द)

is_boolean(term()) :: boolean()

रिटर्न true अगर term परमाणु true या परमाणु है false (यानी, एक बूलियन); अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

is_float (शब्द)

is_float(term()) :: boolean()

रिटर्न true अगर term एक फ्लोटिंग-पॉइंट नंबर है; अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

is_function (शब्द)

is_function(term()) :: boolean()

true यदि term कोई फ़ंक्शन है तो लौटाता है; अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

is_function (शब्द, अर्थ)

is_function(term(), non_neg_integer()) :: boolean()

रिटर्न true अगर term एक फ़ंक्शन है जिसे arity तर्कों की संख्या के साथ लागू किया जा सकता है ; अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> is_function(fn x -> x * 2 end, 1)
true
iex> is_function(fn x -> x * 2 end, 2)
false

is_integer (शब्द)

is_integer(term()) :: boolean()

रिटर्न true अगर term एक पूर्णांक है; अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

is_list (शब्द)

is_list(term()) :: boolean()

true यदि term शून्य या अधिक तत्वों वाली सूची है, तो वापस लौटाता है; अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

is_map (शब्द)

is_map(term()) :: boolean()

true अगर term नक्शा है तो लौटाता है; अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

is_nil (शब्द) (मैक्रो)

रिटर्न true अगर term है nil , false अन्यथा।

गार्ड क्लॉस में अनुमति है।

उदाहरण

iex> is_nil(1)
false

iex> is_nil(nil)
true

is_number (शब्द)

is_number(term()) :: boolean()

रिटर्न true अगर term एक पूर्णांक या एक फ्लोटिंग-पॉइंट नंबर है; अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

is_pid (शब्द)

is_pid(term()) :: boolean()

रिटर्न true अगर term एक पीआईडी ​​(प्रक्रिया पहचानकर्ता) है; अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

is_port (शब्द)

is_port(term()) :: boolean()

रिटर्न true अगर term एक बंदरगाह पहचानकर्ता होता है अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

is_reference (शब्द)

is_reference(term()) :: boolean()

true अगर term एक संदर्भ है तो लौटाता है; अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

is_tuple (शब्द)

is_tuple(term()) :: boolean()

लौटता है true तो term टपल; अन्यथा लौटता है false

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

लंबाई (सूची)

length(list()) :: non_neg_integer()

की लंबाई लौटाता है list

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> length([1, 2, 3, 4, 5, 6, 7, 8, 9])
9

मैक्रो_एक्सपोर्टेड (मॉड्यूल, मैक्रो, एरिटी)

macro_exported?(module(), atom(), arity()) :: boolean()

रिटर्न true अगर module भरी हुई है और एक सार्वजनिक होता है macro दिया साथ arity , नहीं तो false

ध्यान दें कि यह फ़ंक्शन लोड नहीं होने की स्थिति में मॉड्यूल को लोड नहीं करता है। Code.ensure_loaded/1 अधिक जानकारी के लिए जाँच करें ।

यदि module एक एरलांग मॉड्यूल (एक एलिक्सिर मॉड्यूल के विपरीत) है, तो यह फ़ंक्शन हमेशा लौटता है false

उदाहरण

iex> macro_exported?(Kernel, :use, 2)
true

iex> macro_exported?(:erlang, :abs, 1)
false

make_ref ()

make_ref() :: reference()

लगभग एक अद्वितीय संदर्भ देता है।

लौटा संदर्भ लगभग 2 ^ 82 कॉल के बाद फिर से होगा; इसलिए यह व्यावहारिक उद्देश्यों के लिए अद्वितीय है।

संकलक द्वारा झुका हुआ।

उदाहरण

make_ref() #=> #Reference<0.0.0.135>

map_size (नक्शा)

map_size(map()) :: non_neg_integer()

नक्शे का आकार लौटाता है।

मानचित्र का आकार कुंजी-मूल्य वाले जोड़े की संख्या है जिसमें मानचित्र शामिल होता है।

यह ऑपरेशन निरंतर समय में होता है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> map_size(%{a: "foo", b: "bar"})
2

मैच। (पैटर्न, एक्सप) (मैक्रो)

एक सुविधा मैक्रो जो यह जांचती है कि दाईं ओर (एक अभिव्यक्ति) बाईं ओर (एक पैटर्न) से मेल खाती है या नहीं।

उदाहरण

iex> match?(1, 1)
true

iex> match?(1, 2)
false

iex> match?({1, _}, {1, 2})
true

iex> map = %{a: 1, b: 2}
iex> match?(%{a: _}, map)
true

iex> a = 1
iex> match?(^a, 1)
true

match?/2 बहुत उपयोगी है जब एक मान को खोजने में छानने का काम:

iex> list = [a: 1, b: 2, a: 3]
iex> Enum.filter(list, &match?({:a, _}, &1))
[a: 1, a: 3]

गार्ड क्लॉज मैच के लिए भी दिए जा सकते हैं:

iex> list = [a: 1, b: 2, a: 3]
iex> Enum.filter(list, &match?({:a, x} when x < 2, &1))
[a: 1]

हालांकि, मैच में असाइन किए गए चर फ़ंक्शन कॉल के बाहर उपलब्ध नहीं होंगे ( = ऑपरेटर के साथ नियमित मिलान के विपरीत ):

iex> match?(_x, 1)
true
iex> binding()
[]

अधिकतम (पहला, दूसरा)

max(first, second) :: first | second when first: term(), second: term()

एर्लैंग के टर्म ऑर्डर के अनुसार दिए गए दो शब्दों में से सबसे बड़ा रिटर्न।

यदि शब्द बराबर तुलना करते हैं, तो पहले वाले को वापस लौटा दिया जाता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> max(1, 2)
2
iex> max(:a, :b)
:b

एर्लैंग के शब्द आदेश का उपयोग करने का अर्थ है कि तुलना संरचनात्मक है और शब्दार्थ नहीं है। उदाहरण के लिए, तारीखों की तुलना करते समय:

iex> max(~D[2017-03-31], ~D[2017-04-01])
~D[2017-03-31]

ऊपर दिए गए उदाहरण में, max/1 1 अप्रैल के बजाय 31 मार्च को लौटा क्योंकि संरचनात्मक तुलना वर्ष से पहले दिन की तुलना करती है। ऐसे मामलों में मॉड्यूल के लिए फ़ंक्शन प्रदान करना आम है जैसे Date.compare/1 कि शब्दार्थ तुलना करना।

न्यूनतम (पहला, दूसरा)

min(first, second) :: first | second when first: term(), second: term()

एर्लैंग के टर्म ऑर्डर के अनुसार दिए गए दो सबसे छोटे शब्दों को लौटाता है।

यदि शब्द बराबर तुलना करते हैं, तो पहले वाले को वापस लौटा दिया जाता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> min(1, 2)
1
iex> min("foo", "bar")
"bar"

एर्लैंग के शब्द आदेश का उपयोग करने का अर्थ है कि तुलना संरचनात्मक है और शब्दार्थ नहीं है। उदाहरण के लिए, तारीखों की तुलना करते समय:

iex> min(~D[2017-03-31], ~D[2017-04-01])
~D[2017-04-01]

उपरोक्त उदाहरण में, min/1 31 मार्च के बजाय 1 अप्रैल को लौटा क्योंकि संरचनात्मक तुलना वर्ष से पहले दिन की तुलना में। ऐसे मामलों में मॉड्यूल के लिए फ़ंक्शन प्रदान करना आम है जैसे Date.compare/1 कि शब्दार्थ तुलना करना।

नोड ()

node() :: node()

स्थानीय नोड के नाम का प्रतिनिधित्व करने वाला एक परमाणु लौटाता है। यदि नोड जीवित नहीं है, :[email protected] तो इसके बजाय वापस कर दिया जाता है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

नोड (आर्ग)

node(pid() | reference() | port()) :: node()

उस नोड को लौटाता है जहाँ दिया गया तर्क स्थित है। तर्क पीआईडी, संदर्भ या पोर्ट हो सकता है। यदि स्थानीय नोड जीवित नहीं है, :[email protected] तो वापस कर दिया जाता है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

नहीं (मान)

not false :: true
not true :: false

बूलियन नहीं।

arg एक बूलियन होना चाहिए; यदि यह नहीं है, तो एक ArgumentError अपवाद उठाया जाता है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> not false
true

बाएं या दाएं (मैक्रो)

बूलियन या।

अगर left है true , तो रिटर्न true ; अन्यथा लौटता है right

left शॉर्ट-सर्किट के बाद से केवल ऑपरेंड को बूलियन होना आवश्यक है । यदि left ऑपरेंड बूलियन नहीं है, तो एक ArgumentError अपवाद उठाया जाता है।

गार्ड परीक्षण में अनुमति है।

उदाहरण

iex> true or false
true
iex> false or 42
42

pop_in (पथ) (मैक्रो)

दिए गए के माध्यम से नेस्टेड संरचना से एक कुंजी लेता है path

यह pop_in/2 एक सूची को पारित करने के बजाय मैक्रो के माध्यम से निकाले जाने के अलावा, समान है । उदाहरण के लिए:

pop_in(opts[:foo][:bar])

के बराबर है:

pop_in(opts, [:foo, :bar])

ध्यान दें कि इस मैक्रो को काम करने के लिए, पूरा रास्ता हमेशा इस मैक्रो द्वारा दिखाई देना चाहिए। समर्थित पथ अभिव्यक्तियों के बारे में अधिक जानकारी के लिए, कृपया get_and_update_in/2 डॉक्स जांचें ।

उदाहरण

iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
iex> pop_in(users["john"][:age])
{27, %{"john" => %{}, "meg" => %{age: 23}}}

iex> users = %{john: %{age: 27}, meg: %{age: 23}}
iex> pop_in(users.john[:age])
{27, %{john: %{}, meg: %{age: 23}}}

किसी भी प्रविष्टि रिटर्न के मामले में nil , इसकी कुंजी को हटा दिया जाएगा और विलोपन को एक सफलता माना जाएगा।

pop_in (डेटा, कुंजियाँ)

pop_in(data, [Access.get_and_update_fun(term(), data) | term(), ...]) ::
  {term(), data}
when data: Access.container()

दी गई नेस्टेड संरचना से एक कुंजी लेता है।

जब तक एक फ़ंक्शन नहीं है, तब तक Access दिए गए अनुसार संरचना को पार करने के लिए प्रोटोकॉल का उपयोग करता है । यदि कुंजी एक फ़ंक्शन है, तो इसे निर्दिष्ट रूप में लागू किया जाएगा । keys key get_and_update_in/3

उदाहरण

iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
iex> pop_in(users, ["john", :age])
{27, %{"john" => %{}, "meg" => %{age: 23}}}

किसी भी प्रविष्टि रिटर्न के मामले में nil , इसकी कुंजी को हटा दिया जाएगा और विलोपन को एक सफलता माना जाएगा।

iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
iex> pop_in(users, ["jane", :age])
{nil, %{"john" => %{age: 27}, "meg" => %{age: 23}}}

put_elem (टपल, इंडेक्स, मूल्य)

put_elem(tuple(), non_neg_integer(), term()) :: tuple()

value दिए गए शून्य-आधारित index में डालता है tuple

संकलक द्वारा झुका हुआ।

उदाहरण

iex> tuple = {:foo, :bar, 3}
iex> put_elem(tuple, 0, :baz)
{:baz, :bar, 3}

put_in (पथ, मूल्य) (मैक्रो)

दिए गए के माध्यम से एक नेस्टेड संरचना में एक मूल्य डालता है path

यह put_in/3 एक सूची को पारित करने के बजाय मैक्रो के माध्यम से निकाले जाने के अलावा, समान है । उदाहरण के लिए:

put_in(opts[:foo][:bar], :baz)

के बराबर है:

put_in(opts, [:foo, :bar], :baz)

ध्यान दें कि इस मैक्रो को काम करने के लिए, पूरा रास्ता हमेशा इस मैक्रो द्वारा दिखाई देना चाहिए। समर्थित पथ अभिव्यक्तियों के बारे में अधिक जानकारी के लिए, कृपया get_and_update_in/2 डॉक्स जांचें ।

उदाहरण

iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
iex> put_in(users["john"][:age], 28)
%{"john" => %{age: 28}, "meg" => %{age: 23}}

iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
iex> put_in(users["john"].age, 28)
%{"john" => %{age: 28}, "meg" => %{age: 23}}

put_in (डेटा, कुंजियाँ, मूल्य)

put_in(Access.t(), [term(), ...], term()) :: Access.t()

एक नेस्टेड संरचना में एक मूल्य डालता है।

जब तक एक फ़ंक्शन नहीं है, तब तक Access दिए गए अनुसार संरचना को पार करने के लिए मॉड्यूल का उपयोग करता है । यदि कुंजी एक फ़ंक्शन है, तो इसे निर्दिष्ट रूप में लागू किया जाएगा । keys key get_and_update_in/3

उदाहरण

iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
iex> put_in(users, ["john", :age], 28)
%{"john" => %{age: 28}, "meg" => %{age: 23}}

बीच के रिटर्न में से किसी भी प्रविष्टि के मामले में nil , जब इसे एक्सेस करने की कोशिश की जाएगी, तो एक त्रुटि होगी।

उठाना (संदेश) (मैक्रो)

एक अपवाद उठाता है।

यदि तर्क msg एक द्विआधारी है, तो यह RuntimeError दिए गए तर्क को संदेश के रूप में उपयोग करते हुए एक अपवाद उठाता है ।

यदि msg एक परमाणु है, तो यह raise/2 परमाणु को पहले तर्क के [] रूप में और दूसरे तर्क के रूप में कहता है।

यदि msg एक अपवाद संरचना है, तो इसे उठाया जाता है।

यदि msg कुछ और है, raise तो एक ArgumentError अपवाद के साथ विफल हो जाएगा ।

उदाहरण

iex> raise "oops"
** (RuntimeError) oops

try do
  1 + :foo
rescue
  x in [ArithmeticError] ->
    IO.puts "that was expected"
    raise x
end

उठाना (अपवाद, विशेषताएँ) (मैक्रो)

एक अपवाद उठाता है।

exception/1 दिए गए तर्क पर फ़ंक्शन को कॉल करता है (जिसमें मॉड्यूल नाम होना चाहिए जैसे ArgumentError या RuntimeError ) attrs अपवाद संरचना को पुनः प्राप्त करने के लिए विशेषताओं के रूप में पास करना।

किसी भी मॉड्यूल जिसमें defexception(fields) मैक्रो के लिए एक कॉल होता है, स्वचालित रूप से Exception.exception/1 अपेक्षित कॉलबैक को लागू करता है raise/2 । अधिक जानकारी के लिए, देखें defexception(fields)

उदाहरण

iex> raise(ArgumentError, "Sample")
** (ArgumentError) Sample

रेम (लाभांश, भाजक)

rem(integer(), neg_integer() | pos_integer()) :: integer()

पूर्णांक विभाजन के शेष भाग की गणना करता है।

rem/2 काटे गए विभाजन का उपयोग करता है, जिसका अर्थ है कि परिणाम में हमेशा हस्ताक्षर होंगे dividend

यदि कोई तर्क पूर्णांक नहीं है, या जब divisor 0 है, तो एक ArithmeticError अपवाद को उठाता है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> rem(5, 2)
1
iex> rem(6, -4)
2

reraise (संदेश, स्टैकट्रेस) (मैक्रो)

एक पिछले स्टैकट्रेस को संरक्षित करने वाले अपवाद को उठाता है।

काम करता है, raise(message) लेकिन एक नया स्टैकट्रेस उत्पन्न नहीं करता है।

नोटिस जो __STACKTRACE__ वर्तमान स्टैकट्रेस को पुनः प्राप्त करने के लिए कैच / रेस्क्यू के अंदर उपयोग किया जा सकता है।

उदाहरण

try do
  raise "oops"
rescue
  exception ->
    reraise exception, __STACKTRACE__
end

reraise (अपवाद, विशेषताएँ, स्टैकट्रेस) (मैक्रो)

एक पिछले स्टैकट्रेस को संरक्षित करने वाले अपवाद को उठाता है।

reraise/3 काम करता है reraise/2 , सिवाय इसके कि यह exception/1 फ़ंक्शन के तर्कों को समझाता है raise/2

उदाहरण

try do
  raise "oops"
rescue
  exception ->
    reraise WrapperError, [exception: exception], __STACKTRACE__
end

गोल संख्या)

round(value) :: value when value: integer()
round(float()) :: integer()

किसी नंबर को निकटतम पूर्णांक पर राउंड करता है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> round(5.6)
6

iex> round(5.2)
5

iex> round(-9.9)
-10

iex> round(-9)
-9

स्वयं ()

self() :: pid()

कॉलिंग प्रक्रिया का पीआईडी ​​(प्रक्रिया पहचानकर्ता) लौटाता है।

गार्ड क्लॉस में अनुमति है। संकलक द्वारा झुका हुआ।

भेजें (भाग्य, संदेश)

send(dest :: Process.dest(), message) :: message when message: any()

दिए गए संदेश को भेजता है dest और संदेश लौटाता है।

dest एक दूरस्थ या स्थानीय पीआईडी, एक स्थानीय बंदरगाह, एक स्थानीय रूप से पंजीकृत नाम या {registered_name, node} दूसरे नोड में पंजीकृत नाम के लिए एक टुपल हो सकता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> send(self(), :hello)
:hello

sigil_C (शब्द, संशोधक) (मैक्रो)

~C प्रभारियों के लिए चौकसी संभालती है ।

यह पात्रों से बचने के लिए और प्रक्षेपों के बिना बस एक चार्जलिस्ट देता है।

उदाहरण

iex> ~C(foo)
'foo'

iex> ~C(f#{o}o)
'f\#{o}o'

sigil_D (दिनांक, संशोधक) (मैक्रो)

~D तारीखों के लिए सतर्क को संभालता है।

निचला मामला ~d संस्करण मौजूद नहीं है क्योंकि प्रक्षेप और एस्केप वर्ण डेट सिगिल के लिए उपयोगी नहीं हैं।

तिथियों की अधिक जानकारी Date मॉड्यूल में पाई जा सकती है ।

उदाहरण

iex> ~D[2015-01-13]
~D[2015-01-13]

sigil_N (दिनांक, संशोधक) (मैक्रो)

~N भोली तारीख के समय के लिए सतर्क को संभालती है ।

निचला मामला ~n संस्करण मौजूद नहीं है क्योंकि प्रक्षेप और एस्केप वर्ण डेटाइम सिगिल के लिए उपयोगी नहीं हैं।

NaiveDateTime मॉड्यूल में भोली तारीख के समय के बारे में अधिक जानकारी पाई जा सकती है ।

उदाहरण

iex> ~N[2015-01-13 13:00:07]
~N[2015-01-13 13:00:07]
iex> ~N[2015-01-13T13:00:07.001]
~N[2015-01-13 13:00:07.001]

sigil_R (शब्द, संशोधक) (मैक्रो)

~R नियमित अभिव्यक्ति के लिए सतर्क को संभालता है ।

यह न तो भागने और न ही प्रक्षेप की व्याख्या के बिना एक नियमित अभिव्यक्ति पैटर्न देता है।

Regex मॉड्यूल में regexes के बारे में अधिक जानकारी पाई जा सकती है ।

उदाहरण

iex> Regex.match?(~R(f#{1,3}o), "f#o")
true

sigil_S (शब्द, संशोधक) (मैक्रो)

~S तार के लिए सतर्क को संभालता है ।

यह केवल पात्रों से बचने और प्रक्षेपों के बिना एक स्ट्रिंग लौटाता है।

उदाहरण

iex> ~S(foo)
"foo"

iex> ~S(f#{o}o)
"f\#{o}o"

sigil_T (दिनांक, संशोधक) (मैक्रो)

~T समय के लिए सतर्क को संभालता है ।

निचले मामले का ~t विचलन मौजूद नहीं है क्योंकि प्रक्षेप और एस्केप वर्ण समय सिगिल के लिए उपयोगी नहीं हैं।

Time मॉड्यूल में कई बार अधिक जानकारी मिल सकती है ।

उदाहरण

iex> ~T[13:00:07]
~T[13:00:07]
iex> ~T[13:00:07.001]
~T[13:00:07.001]

sigil_W (शब्द, संशोधक) (मैक्रो)

~W शब्दों की सूची के लिए सतर्क को संभालता है ।

यह व्हाट्सएप द्वारा विभाजित किए गए "शब्दों" की एक सूची देता है जो न तो भागने और न ही प्रक्षेप की व्याख्या करता है।

संशोधक

  • s : सूची में शब्द तार हैं (डिफ़ॉल्ट)
  • a : सूची में शब्द परमाणु हैं
  • c : सूची में शब्द चार्लिस्ट हैं

उदाहरण

iex> ~W(foo #{bar} baz)
["foo", "\#{bar}", "baz"]

sigil_c (शब्द, संशोधक) (मैक्रो)

~c प्रभारियों के लिए चौकसी संभालती है ।

यह एक चारलिस्ट देता है जैसे कि यह एक एकल उद्धृत स्ट्रिंग था, वर्णों को हटाने और प्रक्षेपों की जगह।

उदाहरण

iex> ~c(foo)
'foo'

iex> ~c(f#{:o}o)
'foo'

iex> ~c(f\#{:o}o)
'f\#{:o}o'

sigil_r (शब्द, संशोधक) (मैक्रो)

~r नियमित अभिव्यक्ति के लिए सतर्क को संभालता है ।

यह एक नियमित अभिव्यक्ति पैटर्न देता है, वर्णों को हटाने और प्रक्षेपों को प्रतिस्थापित करता है।

नियमित अभिव्यक्तियों के बारे में अधिक जानकारी Regex मॉड्यूल में पाई जा सकती है ।

उदाहरण

iex> Regex.match?(~r(foo), "foo")
true

iex> Regex.match?(~r/abc/, "abc")
true

sigil_s (शब्द, संशोधक) (मैक्रो)

~s तार के लिए सतर्क को संभालता है ।

यह एक स्ट्रिंग लौटाता है जैसे कि यह एक डबल उद्धृत स्ट्रिंग था, वर्णों को हटाने और प्रक्षेपों की जगह।

उदाहरण

iex> ~s(foo)
"foo"

iex> ~s(f#{:o}o)
"foo"

iex> ~s(f\#{:o}o)
"f\#{:o}o"

sigil_w (शब्द, संशोधक) (मैक्रो)

~w शब्दों की सूची के लिए सतर्क को संभालता है ।

यह व्हाट्सएप द्वारा विभाजित "शब्दों" की सूची देता है। चरित्र का अनावरण और प्रक्षेप प्रत्येक शब्द के लिए होता है।

संशोधक

  • s : सूची में शब्द तार हैं (डिफ़ॉल्ट)
  • a : सूची में शब्द परमाणु हैं
  • c : सूची में शब्द चार्लिस्ट हैं

उदाहरण

iex> ~w(foo #{:bar} baz)
["foo", "bar", "baz"]

iex> ~w(foo #{" bar baz "})
["foo", "bar", "baz"]

iex> ~w(--source test/enum_test.exs)
["--source", "test/enum_test.exs"]

iex> ~w(foo bar baz)a
[:foo, :bar, :baz]

अंडे (मज़ा)

spawn((() -> any())) :: pid()

दिए गए फ़ंक्शन को खोलता है और उसका PID लौटाता है।

आमतौर पर डेवलपर्स spawn कार्यों का उपयोग नहीं करते हैं, इसके बजाय वे अमूर्तता का उपयोग करते हैं Task , GenServer और Agent , शीर्ष पर बनाया गया है spawn , जो आत्मनिरीक्षण और डिबगिंग के संदर्भ में अधिक उपयुक्तता के साथ प्रक्रियाओं को जन्म देता है।

Process अधिक प्रक्रिया से संबंधित कार्यों के लिए मॉड्यूल की जांच करें ।

अनाम फ़ंक्शन को 0 तर्क मिलते हैं, और कोई भी मान लौटा सकता है।

संकलक द्वारा झुका हुआ।

उदाहरण

current = self()
child = spawn(fn -> send current, {self(), 1 + 2} end)

receive do
  {^child, 3} -> IO.puts "Received 3 back"
end

स्पॉन (मॉड्यूल, मज़ा, आर्ग्स)

spawn(module(), atom(), list()) :: pid()

दिए fun गए module पासिंग से दिए गए फंक्शन को args देता है और इसे दिए गए PID को वापस करता है।

आमतौर पर डेवलपर्स spawn कार्यों का उपयोग नहीं करते हैं, इसके बजाय वे अमूर्तता का उपयोग करते हैं Task , GenServer और Agent , शीर्ष पर बनाया गया है spawn , जो आत्मनिरीक्षण और डिबगिंग के संदर्भ में अधिक उपयुक्तता के साथ प्रक्रियाओं को जन्म देता है।

Process अधिक प्रक्रिया से संबंधित कार्यों के लिए मॉड्यूल की जांच करें ।

संकलक द्वारा झुका हुआ।

उदाहरण

spawn(SomeModule, :function, [1, 2, 3])

spawn_link (मज़ा)

spawn_link((() -> any())) :: pid()

दिए गए फ़ंक्शन को खोलता है, इसे वर्तमान प्रक्रिया से जोड़ता है, और उसका PID लौटाता है।

आमतौर पर डेवलपर्स spawn कार्यों का उपयोग नहीं करते हैं, इसके बजाय वे अमूर्तता का उपयोग करते हैं Task , GenServer और Agent , शीर्ष पर बनाया गया है spawn , जो आत्मनिरीक्षण और डिबगिंग के संदर्भ में अधिक उपयुक्तता के साथ प्रक्रियाओं को जन्म देता है।

Process अधिक प्रक्रिया से संबंधित कार्यों के लिए मॉड्यूल की जांच करें । लिंकिंग के बारे में अधिक जानकारी के लिए, जाँच करें Process.link/1

अनाम फ़ंक्शन को 0 तर्क मिलते हैं, और कोई भी मान लौटा सकता है।

संकलक द्वारा झुका हुआ।

उदाहरण

current = self()
child = spawn_link(fn -> send(current, {self(), 1 + 2}) end)

receive do
  {^child, 3} -> IO.puts "Received 3 back"
end

स्पॉन_लिंक (मॉड्यूल, मज़ा, आर्ग्स)

spawn_link(module(), atom(), list()) :: pid()

दिए fun गए module पासिंग से दिए गए फंक्शन को स्पॉन देता है, इसे दिए गए args मौजूदा प्रोसेस से लिंक करता है और उसका PID लौटाता है।

आमतौर पर डेवलपर्स spawn कार्यों का उपयोग नहीं करते हैं, इसके बजाय वे अमूर्तता का उपयोग करते हैं Task , GenServer और Agent , शीर्ष पर बनाया गया है spawn , जो आत्मनिरीक्षण और डिबगिंग के संदर्भ में अधिक उपयुक्तता के साथ प्रक्रियाओं को जन्म देता है।

Process अधिक प्रक्रिया से संबंधित कार्यों के लिए मॉड्यूल की जांच करें । लिंकिंग के बारे में अधिक जानकारी के लिए, जाँच करें Process.link/1

संकलक द्वारा झुका हुआ।

उदाहरण

spawn_link(SomeModule, :function, [1, 2, 3])

spawn_monitor (मज़ा)

spawn_monitor((() -> any())) :: {pid(), reference()}

दिए गए फ़ंक्शन को देखता है, इसे मॉनिटर करता है और इसका पीआईडी ​​और मॉनिटरिंग संदर्भ देता है।

आमतौर पर डेवलपर्स spawn कार्यों का उपयोग नहीं करते हैं, इसके बजाय वे अमूर्तता का उपयोग करते हैं Task , GenServer और Agent , शीर्ष पर बनाया गया है spawn , जो आत्मनिरीक्षण और डिबगिंग के संदर्भ में अधिक उपयुक्तता के साथ प्रक्रियाओं को जन्म देता है।

Process अधिक प्रक्रिया से संबंधित कार्यों के लिए मॉड्यूल की जांच करें ।

अनाम फ़ंक्शन को 0 तर्क मिलते हैं, और कोई भी मान लौटा सकता है।

संकलक द्वारा झुका हुआ।

उदाहरण

current = self()
spawn_monitor(fn -> send current, {self(), 1 + 2} end)

spawn_monitor (मॉड्यूल, मज़ा, आर्ग्स)

spawn_monitor(module(), atom(), list()) :: {pid(), reference()}

दिए गए मॉड्यूल को कार्य करता है और दिए गए आर्ग को पास करता है, इसकी निगरानी करता है और इसका पीआईडी ​​और निगरानी संदर्भ लौटाता है।

आमतौर पर डेवलपर्स spawn कार्यों का उपयोग नहीं करते हैं, इसके बजाय वे अमूर्तता का उपयोग करते हैं Task , GenServer और Agent , शीर्ष पर बनाया गया है spawn , जो आत्मनिरीक्षण और डिबगिंग के संदर्भ में अधिक उपयुक्तता के साथ प्रक्रियाओं को जन्म देता है।

Process अधिक प्रक्रिया से संबंधित कार्यों के लिए मॉड्यूल की जांच करें ।

संकलक द्वारा झुका हुआ।

उदाहरण

spawn_monitor(SomeModule, :function, [1, 2, 3])

संरचना (संरचना, फ़ील्ड \\ [])

struct!(module() | struct(), Enum.t()) :: struct() | no_return()

इसी तरह struct/2 लेकिन कुंजी वैधता के लिए जाँच करता है।

फ़ंक्शन struct!/2 स्ट्रक्चर्स के संकलन समय व्यवहार का अनुकरण करता है। इस का मतलब है कि:

  • जब एक संरचना का निर्माण struct!(SomeStruct, key: :value) होता है, तो यह उसके बराबर होता है %SomeStruct{key: :value} और इसलिए यह फ़ंक्शन यह जांच करेगा कि क्या प्रत्येक दिया गया कुंजी-मूल्य संरचना का है। यदि संरचना किसी भी कुंजी के माध्यम से लागू कर रही है @enforce_keys , तो उन्हें भी लागू किया जाएगा;

  • जब किसी संरचना को अपडेट किया जाता है struct!(%SomeStruct{}, key: :value) , तो यह उसके समतुल्य होता है %SomeStruct{struct | key: :value} और इसलिए यह फ़ंक्शन यह जांच करेगा कि क्या प्रत्येक दिया गया कुंजी-मूल्य संरचना का है। हालाँकि, संरचना को अद्यतन करना कुंजी को लागू नहीं करता है, क्योंकि चाबियाँ केवल निर्माण के समय लागू की जाती हैं;

संरचना (संरचना, फ़ील्ड \\ [])

struct(module() | struct(), Enum.t()) :: struct()

संरचना और अद्यतन बनाता है।

struct तर्क एक परमाणु (जो परिभाषित करता है हो सकता है defstruct ) या एक struct ही। दूसरा तर्क वह है Enumerable जो एन्यूमरेशन के दौरान दो-तत्व ट्यूपल्स (की-वैल्यू पेयर) का उत्सर्जन करता है।

Enumerable उस कुंजी में जो संरचना में मौजूद नहीं है, स्वचालित रूप से छोड़ दी जाती है। ध्यान दें कि चाबियाँ परमाणु होनी चाहिए, क्योंकि किसी संरचना को परिभाषित करते समय केवल परमाणुओं की अनुमति होती है।

यह फ़ंक्शन गतिशील रूप से संरचना बनाने और अद्यतन करने के लिए उपयोगी है, साथ ही साथ मानचित्रों को संरूपण में परिवर्तित करने के लिए; उत्तरार्द्ध मामले :__struct__ में, नक्शे में उपयुक्त क्षेत्र सम्मिलित करने के लिए पर्याप्त नहीं हो सकता है और struct/2 इसके बजाय इसका उपयोग किया जाना चाहिए।

उदाहरण

defmodule User do
  defstruct name: "john"
end

struct(User)
#=> %User{name: "john"}

opts = [name: "meg"]
user = struct(User, opts)
#=> %User{name: "meg"}

struct(user, unknown: "value")
#=> %User{name: "meg"}

struct(User, %{name: "meg"})
#=> %User{name: "meg"}

# String keys are ignored
struct(User, %{"name" => "meg"})
#=> %User{name: "john"}

फेंक (शब्द)

throw(term()) :: no_return()

एक समारोह से एक गैर-स्थानीय वापसी।

Kernel.SpecialForms.try/1 अधिक जानकारी के लिए जाँच करें ।

संकलक द्वारा झुका हुआ।

tl (सूची)

tl(nonempty_maybe_improper_list(elem, tail)) ::
  maybe_improper_list(elem, tail) | tail
when elem: term(), tail: term()

किसी सूची की पूंछ लौटाता है। ArgumentError यदि सूची खाली है तो उठाता है।

यह अनुचित सूचियों के साथ काम करता है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

tl([1, 2, 3, :go])
#=> [2, 3, :go]

tl([])
#=> ** (ArgumentError) argument error

tl([:one])
#=> []

tl([:a, :b | :c])
#=> [:b | :c]

tl([:a | %{b: 1}])
#=> %{b: 1}

to_charlist (शब्द) (मैक्रो)

List.Chars प्रोटोकॉल के अनुसार किसी दिए गए पद को चार्टलिस्ट में परिवर्तित करता है।

उदाहरण

iex> to_charlist(:foo)
'foo'

to_string (शब्द) (मैक्रो)

String.Chars प्रोटोकॉल के अनुसार एक स्ट्रिंग को तर्क देता है।

यह तब होता है जब स्ट्रिंग इंटरपोलेशन होता है।

उदाहरण

iex> to_string(:foo)
"foo"

TRUNC (संख्या)

trunc(float()) :: integer()
trunc(value) :: value when value: integer()

का पूर्णांक भाग लौटाता है number

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> trunc(5.4)
5

iex> trunc(-5.99)
-5

iex> trunc(-5)
-5

tuple_size (टपल)

tuple_size(tuple()) :: non_neg_integer()

टपल का आकार देता है।

यह ऑपरेशन निरंतर समय में होता है।

गार्ड परीक्षण में अनुमति है। संकलक द्वारा झुका हुआ।

उदाहरण

iex> tuple_size({:a, :b, :c})
3

जब तक (स्थिति, खंड) (मैक्रो)

unless स्थूल प्रदान करता है ।

यह मैक्रो मूल्यांकन करता है और do ब्लॉक को दूसरे तर्क के रूप में पारित करता है जब तक कि clause मूल्यांकन नहीं करता true । अन्यथा, यह else वर्तमान या nil नहीं तो ब्लॉक का मूल्य लौटाता है ।

यह भी देखें if/2

उदाहरण

iex> unless(Enum.empty?([]), do: "Hello")
nil

iex> unless(Enum.empty?([1, 2, 3]), do: "Hello")
"Hello"

iex> unless Enum.sum([2, 2]) == 5 do
...>   "Math still works"
...> else
...>   "Math is broken"
...> end
"Math still works"

update_in (पाथ, फन) (मैक्रो)

दिए गए के माध्यम से एक नेस्टेड संरचना को अद्यतन करता है path

यह update_in/3 एक सूची को पारित करने के बजाय मैक्रो के माध्यम से निकाले जाने के अलावा, समान है । उदाहरण के लिए:

update_in(opts[:foo][:bar], &(&1 + 1))

के बराबर है:

update_in(opts, [:foo, :bar], &(&1 + 1))

ध्यान दें कि इस मैक्रो को काम करने के लिए, पूरा रास्ता हमेशा इस मैक्रो द्वारा दिखाई देना चाहिए। समर्थित पथ अभिव्यक्तियों के बारे में अधिक जानकारी के लिए, कृपया get_and_update_in/2 डॉक्स जांचें ।

उदाहरण

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

iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
iex> update_in(users["john"].age, &(&1 + 1))
%{"john" => %{age: 28}, "meg" => %{age: 23}}

update_in (डेटा, कुंजियाँ, मज़ा)

update_in(Access.t(), [term(), ...], (term() -> term())) :: Access.t()

नेस्टेड संरचना में एक कुंजी को अपडेट करता है।

जब तक एक फ़ंक्शन नहीं है, तब तक Access दिए गए अनुसार संरचना को पार करने के लिए मॉड्यूल का उपयोग करता है । यदि कुंजी एक फ़ंक्शन है, तो इसे निर्दिष्ट रूप में लागू किया जाएगा । keys key get_and_update_in/3

उदाहरण

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

बीच के रिटर्न में से किसी भी प्रविष्टि के मामले में nil , जब इसे एक्सेस करने की कोशिश की जाएगी, तो एक त्रुटि होगी।

उपयोग (मॉड्यूल, opts \\ []) (मैक्रो)

वर्तमान संदर्भ में दिए गए मॉड्यूल का उपयोग करता है।

कॉल करते समय:

use MyModule, some: :options

__using__/1 से मैक्रो MyModule मॉड्यूल को पारित कर दिया दूसरा तर्क के साथ शुरू हो जाती है use अपने तर्क के रूप में। चूंकि __using__/1 एक मैक्रो है, सभी सामान्य मैक्रो नियम लागू होते हैं, और इसके रिटर्न मान को उद्धृत किया जाना चाहिए जो तब use/2 कहा जाता है जहां कहा जाता है

उदाहरण

उदाहरण के लिए, क्रम में उपयोग करते हुए परीक्षण मामलों लिखने के ExUnit ढांचे अमृत के साथ प्रदान की, एक डेवलपर चाहिए मॉड्यूल: use ExUnit.Case

defmodule AssertionTest do
  use ExUnit.Case, async: true

  test "always pass" do
    assert true
  end
end

इस उदाहरण में, ExUnit.Case.__using__/1 कीवर्ड सूची [async: true] को इसके तर्क के रूप में कहा जाता है; use/2 अनुवाद करने के लिए:

defmodule AssertionTest do
  require ExUnit.Case
  ExUnit.Case.__using__([async: true])

  test "always pass" do
    assert true
  end
end

ExUnit.Case तब __using__/1 मैक्रो को परिभाषित करेगा :

defmodule ExUnit.Case do
  defmacro __using__(opts) do
    # do something with opts
    quote do
      # return some code to inject in the caller
    end
  end
end

सर्वोत्तम प्रथाएं

__using__/1 आम तौर पर तब उपयोग किया जाता है जब कॉलर में कुछ राज्य (मॉड्यूल विशेषताओं के माध्यम से) या कॉलबैक (जैसे @before_compile , Module अधिक जानकारी के लिए दस्तावेज़ देखें ) सेट करने की आवश्यकता होती है ।

__using__/1 विभिन्न मॉड्यूल से कार्यक्षमता को बदलने, आवश्यकता या आयात करने के लिए भी उपयोग किया जा सकता है:

defmodule MyModule do
  defmacro __using__(_opts) do
    quote do
      import MyModule.Foo
      import MyModule.Bar
      import MyModule.Baz

      alias MyModule.Repo
    end
  end
end

हालांकि, यह प्रदान न करें __using__/1 कि यह सब कुछ आयात करना है, उपनाम या मॉड्यूल की आवश्यकता है। उदाहरण के लिए, इससे बचें:

defmodule MyModule do
  defmacro __using__(_opts) do
    quote do
      import MyModule
    end
  end
end

ऐसे मामलों में, डेवलपर्स को इसके बजाय मॉड्यूल को सीधे आयात या उर्फ ​​करना चाहिए, ताकि वे उन लोगों को अनुकूलित कर सकें जो वे चाहते हैं, बिना अप्रत्यक्ष पीछे use/2

अंत में, डेवलपर्स को __using__/1 कॉलबैक के अंदर फ़ंक्शंस को परिभाषित करने से भी बचना चाहिए , जब तक कि वे फ़ंक्शंस पहले से परिभाषित डिफ़ॉल्ट कार्यान्वयन न हों @callback या फ़ंक्शंस को ओवरराइड करने के लिए हों (देखें defoverridable(keywords_or_behaviour) )। इन मामलों में भी, परिभाषित कार्यों को "अंतिम उपाय" के रूप में देखा जाना चाहिए।

यदि आप उपयोगकर्ता मॉड्यूल को कुछ मौजूदा कार्यक्षमता प्रदान करना चाहते हैं, तो कृपया इसे एक मॉड्यूल में परिभाषित करें जो तदनुसार आयात किया जाएगा; उदाहरण के लिए, कॉल करने वाले मॉड्यूल में मैक्रो ExUnit.Case को परिभाषित नहीं करता है , लेकिन यह परिभाषित करता है और उपयोग किए जाने पर कॉलर में बस आयात करता है। test/3 use ExUnit.Case ExUnit.Case.test/3

var! (var, संदर्भ \\ nil) (मैक्रो)

जब उद्धृत के अंदर उपयोग किया जाता है, तो यह संकेत दिया जाता है कि दिए गए चर को स्वच्छ नहीं किया जाना चाहिए।

तर्क या तो एक चर अयोग्य या मानक टुपल रूप में हो सकता है {name, meta, context}

Kernel.SpecialForms.quote/2 अधिक जानकारी के लिए जाँच करें ।

बाएँ |> दाएँ (मैक्रो)

पाइप ऑपरेटर।

यह ऑपरेटर बाएं हाथ की तरफ अभिव्यक्ति का परिचय दायीं ओर के फंक्शन कॉल के पहले तर्क के रूप में देता है।

उदाहरण

iex> [1, [2], 3] |> List.flatten()
[1, 2, 3]

उपरोक्त उदाहरण कॉलिंग के समान है List.flatten([1, [2], 3])

|> जब वहाँ एक पाइपलाइन जैसी ऑपरेशनों की एक श्रृंखला पर अमल करने की इच्छा है ऑपरेटर ज्यादातर उपयोगी है:

iex> [1, [2], 3] |> List.flatten() |> Enum.map(fn x -> x * 2 end)
[2, 4, 6]

ऊपर के उदाहरण में, सूची [1, [2], 3] को List.flatten/1 फ़ंक्शन के पहले तर्क के रूप में पास किया जाता है , फिर चपटा सूची को Enum.map/2 फ़ंक्शन के पहले तर्क के रूप में पारित किया जाता है जो सूची के प्रत्येक तत्व को दोगुना करता है।

दूसरे शब्दों में, ऊपर की अभिव्यक्ति बस में अनुवाद करती है:

Enum.map(List.flatten([1, [2], 3]), fn x -> x * 2 end)

नुकसान

पाइप ऑपरेटर का उपयोग करते समय दो सामान्य नुकसान होते हैं।

पहले वाला ऑपरेटर पूर्वता से संबंधित है। उदाहरण के लिए, निम्नलिखित अभिव्यक्ति:

String.graphemes "Hello" |> Enum.reverse

इसके लिए अनुवाद:

String.graphemes("Hello" |> Enum.reverse)

जिसके परिणामस्वरूप त्रुटि उत्पन्न होती है क्योंकि Enumerable बायनेरिज़ के लिए प्रोटोकॉल परिभाषित नहीं है। स्पष्ट कोष्ठकों को जोड़ने से अस्पष्टता का समाधान होता है:

String.graphemes("Hello") |> Enum.reverse

या, और भी बेहतर:

"Hello" |> String.graphemes |> Enum.reverse

दूसरा नुकसान यह है कि |> ऑपरेटर कॉल पर काम करता है। उदाहरण के लिए, जब आप लिखते हैं:

"Hello" |> some_function()

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

अनाम फ़ंक्शन को देखते हुए:

fun = fn x -> IO.puts(x) end
fun.("Hello")

यह काम नहीं करेगा क्योंकि यह स्थानीय फ़ंक्शन को लागू करने का प्रयास करेगा fun :

"Hello" |> fun()

यह काम:

"Hello" |> fun.()

जैसा कि आप देख सकते हैं, |> ऑपरेटर उसी शब्दार्थ को बरकरार रखता है जब पाइप का उपयोग नहीं किया जाता है क्योंकि दोनों को fun.(...) संकेतन की आवश्यकता होती है।

छोड़ दिया || सही (मैक्रो)

एक शॉर्ट-सर्किट ऑपरेटर प्रदान करता है जो मूल्यांकन करता है और दूसरी अभिव्यक्ति तभी लौटाता है जब पहले वाला मूल्यांकन नहीं करता है true (यानी, यह nil या तो है false )। अन्यथा पहले अभिव्यक्ति देता है।

गार्ड क्लॉस में अनुमति नहीं है।

उदाहरण

iex> Enum.empty?([1]) || Enum.empty?([1])
false

iex> List.first([]) || true
true

iex> Enum.empty?([1]) || 1
1

iex> Enum.empty?([]) || throw(:bad)
true

ध्यान दें, इसके विपरीत or/2 , यह ऑपरेटर किसी भी अभिव्यक्ति को पहले तर्क के रूप में स्वीकार करता है, न केवल बूलियन।

Original text