Elixir 1.7

Module




elixir

Module

संकलन समय के दौरान मॉड्यूल से निपटने के लिए कार्य प्रदान करता है।

यह डेवलपर को गतिशील रूप से जोड़ने, हटाने और रजिस्टर करने, प्रलेखन संलग्न करने और इसके बाद की अनुमति देता है।

एक मॉड्यूल संकलित किए जाने के बाद, इस मॉड्यूल में कई कार्यों का उपयोग करके त्रुटियों को उठाया जाएगा, क्योंकि यह रनटाइम डेटा का निरीक्षण करने के लिए उनके दायरे से बाहर है। अधिकांश रनटाइम डेटा का निरीक्षण प्रत्येक संकलित मॉड्यूल से जुड़े __info__/1 फ़ंक्शन के माध्यम से किया जा सकता है।

मॉड्यूल विशेषताएँ

प्रत्येक मॉड्यूल को एक या अधिक विशेषताओं से सजाया जा सकता है। वर्तमान में निम्नलिखित अमृत द्वारा परिभाषित किए गए हैं:

@after_compile

एक हुक जो वर्तमान मॉड्यूल के संकलित होने के ठीक बाद दिया जाएगा। एक मॉड्यूल या एक {module, function_name} स्वीकार {module, function_name} । नीचे "संकलन कॉलबैक" अनुभाग देखें।

@before_compile

एक हुक जिसे मॉड्यूल संकलित करने से पहले लागू किया जाएगा। किसी मॉड्यूल या {module, function_or_macro_name} फ़ंक्शन_or_macro_name {module, function_or_macro_name} टपल को स्वीकार {module, function_or_macro_name} । नीचे "संकलन कॉलबैक" अनुभाग देखें।

@behaviour

ब्रिटिश वर्तनी पर ध्यान दें!

व्यवहार को मॉड्यूल द्वारा संदर्भित किया जा सकता है ताकि यह सुनिश्चित हो सके कि वे @callback द्वारा परिभाषित विशिष्ट फ़ंक्शन हस्ताक्षर को लागू @callback

उदाहरण के लिए, आप एक URI.Parser व्यवहार को निम्नानुसार निर्दिष्ट कर सकते हैं:

defmodule URI.Parser do
  @doc "Defines a default port"
  @callback default_port() :: integer

  @doc "Parses the given URL"
  @callback parse(uri_info :: URI.t) :: URI.t
end

और फिर एक मॉड्यूल इसका उपयोग कर सकता है:

defmodule URI.HTTP do
  @behaviour URI.Parser
  def default_port(), do: 80
  def parse(info), do: info
end

यदि व्यवहार बदलता है या URI.HTTP कॉलबैक में से एक को लागू नहीं करता है, तो एक चेतावनी को उठाया जाएगा।

@impl

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

ऊपर दिए गए उदाहरण को @impl के रूप में फिर से लिखा जा सकता है:

defmodule URI.HTTP do
  @behaviour URI.parser

  @impl true
  def default_port(), do: 80

  @impl true
  def parse(info), do: info
end

आप false , true , या @impl लिए एक विशिष्ट व्यवहार पारित कर सकते हैं।

defmodule Foo do
  @behaviour Bar
  @behaviour Baz

  @impl true # will warn if neither Bar nor Baz specify a callback named bar/0
  def bar(), do: :ok

  @impl Baz # will warn if Baz does not specify a callback named baz/0
  def baz(), do: :ok
end

कोड की पठनीयता बढ़ जाती है, क्योंकि अब यह स्पष्ट है कि कौन से कार्य आपके एपीआई का हिस्सा हैं और कौन से कॉलबैक कार्यान्वयन हैं। इस विचार को सुदृढ़ करने के लिए, @impl true स्वचालित रूप से @doc false रूप में फ़ंक्शन को चिह्नित करता है, दस्तावेज़ीकरण को अक्षम करता है जब तक @doc स्पष्ट रूप से सेट नहीं किया जाता है।

@compile

मॉड्यूल संकलन के लिए विकल्प परिभाषित करता है। इसका उपयोग Elixir और Erlang दोनों कंपाइलरों को कॉन्फ़िगर करने के लिए किया जाता है, क्योंकि बाहरी उपकरणों द्वारा जोड़ा गया कोई अन्य संकलन पास। उदाहरण के लिए:

defmodule MyModule do
  @compile {:inline, my_fun: 1}

  def my_fun(arg) do
    to_string(arg)
  end
end

पिछले वाले को ओवरराइड करने के बजाय @compile कई उपयोग जमा होंगे। नीचे "संकलन विकल्प" अनुभाग देखें।

@deprecated

एक समारोह के लिए पदावनत कारण प्रदान करता है। उदाहरण के लिए:

defmodule Keyword do
  @deprecated "Use Kernel.length/1 instead"
  def size(keyword) do
    length(keyword)
  end
end

मिक्स कंपाइलर के माध्यम से गणना के दौरान मिक्स कंपाइलर स्वचालित रूप से हटाए गए मॉड्यूल के लिए कॉल की तलाश करता है और संकलन के दौरान mix xref warnings

@deprecated विशेषता का उपयोग भी दिए गए फ़ंक्शन और मैक्रो के प्रलेखन में परिलक्षित होगा। आप हार्ड-डेप्रिसिएशन (चेतावनियों के साथ) और सॉफ्ट- @deprecated (चेतावनियों के साथ) प्रदान करने के लिए @deprecated विशेषता और प्रलेखन मेटाडेटा के बीच चयन कर सकते हैं:

यह एक सॉफ्ट-डिप्रेसेशन है क्योंकि यह केवल डॉक्यूमेंट को एनक्रिप्टेड के रूप में एनोटेट करता है:

@doc deprecated: "Use Kernel.length/1 instead"
def size(keyword)

यह एक हार्ड-डेप्रिसिएशन है क्योंकि यह चेतावनियों का उत्सर्जन करता है और डॉक्यूमेंट को एनोटेट के रूप में एनोटेट करता है:

@deprecated "Use Kernel.length/1 instead"
def size(keyword)

वर्तमान में @deprecated केवल फ़ंक्शन और मैक्रोज़ का समर्थन करता है। हालाँकि आप उपयोग कर सकते हैं :deprecated मॉड्यूल, प्रकार और कॉलबैक के डॉक्स को एनोटेट करने के लिए एनोटेशन मेटाडेटा में :deprecated कुंजी।

हम इस सुविधा का उपयोग करने की सलाह देते हैं, विशेष रूप से पुस्तकालय लेखकों के साथ। डिप्रेक्टिंग कोड हमेशा लाइब्रेरी उपयोगकर्ताओं की ओर बोझ बढ़ाता है। हम लंबे समय तक लंबे समय तक बनाए रखने के लिए पदावनत कार्यक्षमता की भी सिफारिश करते हैं, यहां तक ​​कि पदावनति के बाद भी, डेवलपर्स को अपडेट करने के लिए बहुत समय देते हैं (ऐसे मामलों को छोड़कर, जहां अपग्रेड किए गए एपीआई को अवांछित रखा जाता है, जैसे कि सुरक्षा मुद्दों की उपस्थिति में)।

@doc और @typedoc

विशेषता का पालन करने वाली इकाई के लिए प्रलेखन प्रदान करता है। @doc का उपयोग किसी फंक्शन, मैक्रो, कॉलबैक या @typedoc साथ किया जाना है, जबकि @typedoc एक प्रकार (सार्वजनिक या अपारदर्शी) के साथ।

एक स्ट्रिंग (अक्सर एक @doc false ) या false को स्वीकार करता है, जहां @doc false इकाई एक्सडॉक जैसे प्रलेखन निष्कर्षण उपकरण के लिए अदृश्य बना देगा। उदाहरण के लिए:

defmodule MyModule do
  @typedoc "This type"
  @typedoc since: "1.1.0"
  @type t :: term

  @doc "Hello world"
  @doc since: "1.1.0"
  def hello do
    "world"
  end

  @doc """
  Sums `a` to `b`.
  """
  def sum(a, b) do
    a + b
  end
end

जैसा कि ऊपर दिए गए उदाहरण में देखा जा सकता है, @doc और @typedoc एक कीवर्ड सूची भी स्वीकार करते हैं जो इकाई के बारे में मनमाना मेटाडेटा प्रदान करने के तरीके के रूप में कार्य करता है। एक्सडॉक और IEx जैसे उपकरण एनोटेशन प्रदर्शित करने के लिए इस जानकारी का उपयोग कर सकते हैं। एक सामान्य उपयोग का मामला है, since इसका उपयोग एनोटेट करने के लिए किया जा सकता है कि फ़ंक्शन किस संस्करण में पेश किया गया था।

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

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

@dialyzer

मॉड्यूल विशेषताओं का समर्थन करने वाले :dialyzer संस्करण का उपयोग करते समय अनुरोध या दबाने की चेतावनी को परिभाषित करता है।

एक परमाणु, एक ट्यूपल या परमाणुओं और टुपल्स की सूची को स्वीकार करता है। उदाहरण के लिए:

defmodule MyModule do
  @dialyzer {:nowarn_function, my_fun: 1}

  def my_fun(arg) do
    M.not_a_function(arg)
  end
end

समर्थित चेतावनियों की सूची के लिए, देखें :dialyzer मॉड्यूल

@dialyzer एकाधिक उपयोग पिछले वाले को ओवरराइड करने के बजाय जमा करेंगे।

@external_resource

वर्तमान मॉड्यूल के लिए एक बाहरी संसाधन निर्दिष्ट करता है।

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

मिक्स जैसे उपकरण इस जानकारी का उपयोग यह सुनिश्चित करने के लिए कर सकते हैं कि किसी बाह्य संसाधन परिवर्तन के मामले में मॉड्यूल को पुन: स्थापित किया जाए।

@file

फ़ंक्शन या मैक्रो के लिए स्टैकट्रैक में उपयोग किए जाने वाले फ़ाइलनाम को बदलता है जो विशेषता का अनुसरण करता है, जैसे:

defmodule MyModule do
  @doc "Hello world"
  @file "hello.ex"
  def hello do
    "world"
  end
end

@moduledoc

वर्तमान मॉड्यूल के लिए प्रलेखन प्रदान करता है।

defmodule MyModule do
  @moduledoc """
  A very useful module.
  """
  @moduledoc authors: ["Alice", "Bob"]
end

एक स्ट्रिंग (अक्सर एक @moduledoc false ) या false को स्वीकार करता है जहां @moduledoc false एक्सडोक जैसे प्रलेखन निष्कर्षण उपकरण के लिए मॉड्यूल को अदृश्य बना देगा।

इसी तरह @doc मॉड्यूल के बारे में मेटाडेटा प्रदान करने के लिए एक कीवर्ड सूची भी स्वीकार करता है। अधिक जानकारी के लिए, ऊपर @doc दस्तावेज़ देखें।

@on_definition

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

एक मॉड्यूल या {module, function_name} फ़ंक्शन_नाम {module, function_name} टपल स्वीकार {module, function_name} । नीचे "संकलन कॉलबैक" अनुभाग देखें।

@on_load

जब भी मॉड्यूल लोड किया जाता है तो एक हुक लगाया जाएगा।

वर्तमान मॉड्यूल में एक फ़ंक्शन के फ़ंक्शन नाम (एक परमाणु के रूप में) को स्वीकार करता है या {function_name, 0} tuple जहां फ़ंक्शन_name वर्तमान मॉड्यूल में एक फ़ंक्शन का नाम है। फ़ंक्शन में एरिटी 0 (कोई तर्क नहीं) होना चाहिए और वापस लौटना होगा :ok , अन्यथा मॉड्यूल के लोडिंग को रोक दिया जाएगा। उदाहरण के लिए:

defmodule MyModule do
  @on_load :load_check

  def load_check do
    if some_condition() do
      :ok
    else
      :abort
    end
  end

  def some_condition do
    false
  end
end

HiPE के साथ संकलित मॉड्यूल इस हुक को नहीं कहेंगे।

@vsn

मॉड्यूल संस्करण निर्दिष्ट करें। उदाहरण के लिए किसी भी मान्य अमृत मूल्य को स्वीकार करता है:

defmodule MyModule do
  @vsn "1.0"
end

टाइपस्पीक विशेषताएँ

निम्नलिखित विशेषताएँ टाइपस्पेस का हिस्सा हैं और यह भी अमृत में निर्मित हैं:

  • @type - @spec में उपयोग किए जाने वाले एक प्रकार को परिभाषित करता है
  • @typep - @spec में इस्तेमाल होने वाले एक निजी प्रकार को परिभाषित करता है
  • @opaque - @spec में प्रयुक्त होने वाले एक अपारदर्शी प्रकार को परिभाषित करता है
  • @spec - एक फ़ंक्शन के लिए एक विनिर्देश प्रदान करता है
  • @callback - एक व्यवहार कॉलबैक के लिए एक विनिर्देश प्रदान करता है
  • @macrocallback - मैक्रो व्यवहार कॉलबैक के लिए एक विनिर्देश प्रदान करता है
  • @optional_callbacks - निर्दिष्ट करता है कि कौन से व्यवहार कॉलबैक और मैक्रो व्यवहार कॉलबैक वैकल्पिक हैं
  • @impl - कॉलबैक फ़ंक्शन या मैक्रो के कार्यान्वयन की घोषणा करता है

कस्टम विशेषताएँ

ऊपर उल्लिखित अंतर्निहित विशेषताओं के अतिरिक्त, कस्टम विशेषताएँ भी जोड़ी जा सकती हैं। एक कस्टम विशेषता किसी भी मान्य पहचानकर्ता @ साथ उपसर्ग है और उसके बाद एक वैध अमृत मूल्य है:

defmodule MyModule do
  @custom_attr [some: "stuff"]
end

कस्टम विशेषताओं को परिभाषित करते समय उपलब्ध अधिक उन्नत विकल्पों के लिए, register_attribute/3

संकलित कॉलबैक

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

@after_compile

एक हुक जो वर्तमान मॉड्यूल के संकलित होने के ठीक बाद दिया जाएगा।

एक मॉड्यूल या {module, function_name} फ़ंक्शन_नाम {module, function_name} टपल स्वीकार {module, function_name} । मॉड्यूल पर्यावरण और इसके बाइटकोड: फ़ंक्शन को दो तर्क लेने चाहिए। जब केवल एक मॉड्यूल प्रदान किया जाता है, तो फ़ंक्शन को __after_compile__/2 माना जाता है।

पहले पंजीकृत कॉलबैक अंतिम चलेगा।

उदाहरण

defmodule MyModule do
  @after_compile __MODULE__

  def __after_compile__(env, _bytecode) do
    IO.inspect env
  end
end

@before_compile

एक हुक जिसे मॉड्यूल संकलित करने से पहले लागू किया जाएगा।

किसी मॉड्यूल या {module, function_or_macro_name} फ़ंक्शन_or_macro_name {module, function_or_macro_name} टपल को स्वीकार {module, function_or_macro_name} । फ़ंक्शन / मैक्रो को एक तर्क लेना चाहिए: मॉड्यूल वातावरण। यदि यह एक मैक्रो है, तो संकलन शुरू होने से पहले इसका रिटर्न वैल्यू मॉड्यूल परिभाषा के अंत में इंजेक्ट किया जाएगा।

जब केवल एक मॉड्यूल प्रदान किया जाता है, तो फ़ंक्शन / मैक्रो को __before_compile__/1 माना जाता है।

पहले पंजीकृत कॉलबैक अंतिम चलेगा। पहले कॉलबैक के चलने से पहले किसी भी प्रकार की ओवरडिजेबल परिभाषा को ठोस बनाया जाएगा। संकलित कॉलबैक से पहले एक परिभाषा को फिर से ओवरएडेबल बनाया जा सकता है और सभी कॉलबैक चलने के बाद इसे अंतिम बार कंक्रीट बनाया जाएगा।

नोट : @after_compile विपरीत, कॉलबैक फ़ंक्शन / मैक्रो को एक अलग मॉड्यूल में रखा जाना चाहिए (क्योंकि कॉलबैक लागू होने पर, वर्तमान मॉड्यूल अभी तक मौजूद नहीं है)।

उदाहरण

defmodule A do
  defmacro __before_compile__(_env) do
    quote do
      def hello, do: "world"
    end
  end
end

defmodule B do
  @before_compile A
end

B.hello()
#=> "world"

@on_definition

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

एक मॉड्यूल या {module, function_name} फ़ंक्शन_नाम {module, function_name} टपल स्वीकार {module, function_name} । फ़ंक्शन को 6 तर्क देने होंगे:

  • मॉड्यूल वातावरण
  • फ़ंक्शन / मैक्रो की तरह :def :defp , या :defmacrop
  • फ़ंक्शन / मैक्रो नाम
  • उद्धृत तर्कों की सूची
  • उद्धृत गार्ड की सूची
  • उद्धृत समारोह शरीर

ध्यान दें कि हुक उद्धृत तर्कों को प्राप्त करता है और फ़ंक्शन मॉड्यूल में संग्रहीत होने से पहले इसे लागू किया जाता है। इसलिए Module.defines?/2 हर फंक्शन के पहले क्लॉज के लिए false होगा।

यदि फ़ंक्शन / मैक्रो को परिभाषित किया जा रहा है तो कई खंड हैं, प्रत्येक खंड के लिए हुक को बुलाया जाएगा।

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

जब केवल एक मॉड्यूल प्रदान किया जाता है, तो फ़ंक्शन को __on_definition__/6 माना जाता है।

उदाहरण

defmodule Hooks do
  def on_def(_env, kind, name, args, guards, body) do
    IO.puts "Defining #{kind} named #{name} with args:"
    IO.inspect args
    IO.puts "and guards"
    IO.inspect guards
    IO.puts "and body"
    IO.puts Macro.to_string(body)
  end
end

defmodule MyModule do
  @on_definition {Hooks, :on_def}

  def hello(arg) when is_binary(arg) or is_list(arg) do
    "Hello" <> to_string(arg)
  end

  def hello(_) do
    :ok
  end
end

संकलन विकल्प

@compile विशेषता विभिन्न विकल्पों को स्वीकार करती है जो कि @compile और @compile कंपाइलर दोनों द्वारा उपयोग किए जाते हैं। कुछ सामान्य उपयोग के मामले नीचे दिए गए हैं:

  • @compile :debug_info - में शामिल हैं :debug_info और Code.compiler_options/1 में संबंधित सेटिंग की परवाह किए बिना Code.compiler_options/1

  • @compile {:debug_info, false} - अक्षम करता है :debug_info Code.compiler_options/1 में संबंधित सेटिंग की परवाह किए बिना।

  • @compile {:inline, some_fun: 2, other_fun: 3} - दिए गए नाम / आरती जोड़े को @compile {:inline, some_fun: 2, other_fun: 3} । इनलाइनिंग को स्थानीय रूप से लागू किया जाता है, दूसरे मॉड्यूल से कॉल इस विकल्प से प्रभावित नहीं होते हैं

  • @compile {:autoload, false} - संकलन के बाद मॉड्यूल के स्वचालित लोडिंग को अक्षम करता है। इसके बजाय, इसे भेजे जाने के बाद मॉड्यूल लोड किया जाएगा

आप :compile मॉड्यूल के लिए दस्तावेज़ में Erlang संकलक द्वारा उपयोग किए जाने वाले मुट्ठी भर अधिक विकल्प देख सकते हैं।

सारांश

कार्य

concat(list)

एलियंस की एक सूची से संबंधित है और एक नया उपनाम देता है

समतल (बाएं, दाएं)

दो उपनामों को सम्‍मिलित करता है और एक नया उपनाम देता है

बनाएँ (मॉड्यूल, उद्धृत, ऑप्स)

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

परिभाषित करता है; (मॉड्यूल, टपल)

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

परिभाषित करता है; (मॉड्यूल, टपल, डिफाइंड)

जाँचता है कि क्या मॉड्यूल दिए गए kind फ़ंक्शन या मैक्रो को परिभाषित करता है

defines_type? (मॉड्यूल, परिभाषा)

जाँच करता है कि क्या वर्तमान मॉड्यूल दिए गए प्रकार को परिभाषित करता है (निजी, अपारदर्शी या नहीं)

definitions_in(module)

module में परिभाषित सभी फ़ंक्शन देता है

परिभाषाएँ_इन (मॉड्यूल, डीफ़ाइकिन्ड)

module में परिभाषित सभी फ़ंक्शंस देता है, अपनी तरह के अनुसार

delete_attribute (मॉड्यूल, कुंजी)

दी गई कुंजी से मेल खाने वाले मॉड्यूल विशेषता को हटाता है

eval_quoted (मॉड्यूल_or_env, उद्धृत, बाइंडिंग \\ [], opts \\ [])

दिए गए मॉड्यूल के संदर्भ में उद्धृत सामग्री का मूल्यांकन करता है

get_attribute (मॉड्यूल, कुंजी)

किसी मॉड्यूल से दी गई विशेषता प्राप्त करता है

make_overridable (मॉड्यूल, ट्यूपल्स)

module में दिए गए कार्यों को अधिक करने योग्य बनाता है

open?(module)

जाँचता है कि क्या कोई मॉड्यूल खुला है

overridable। (मॉड्यूल, टपल)

module में tuple को अतिव्याप्त के रूप में चिह्नित किया गया है तो true है

put_attribute (मॉड्यूल, कुंजी, मूल्य)

दिए गए module में key और value साथ एक मॉड्यूल विशेषता डालता है

register_attribute/3

एक विशेषता पंजीकृत करता है

safe_concat(list)

एलियंस की एक सूची को सम्‍मिलित करता है और एक नया उपनाम लौटाता है यदि उपनाम पहले से संदर्भित था

safe_concat (बाएं, दाएं)

दो उपनामों को सम्‍मिलित करता है और एक नया उपनाम लौटाता है यदि उपनाम पहले से संदर्भित था

spec_to_callback (मॉड्यूल, परिभाषा)

कॉलबैक में दिए गए युक्ति को परिवर्तित करता है

split(module)

बाइनरी भागों में दिए गए मॉड्यूल नाम को विभाजित करता है

कार्य

concat (सूची)

concat([binary() | atom()]) :: atom()

एलियंस की एक सूची से संबंधित है और एक नया उपनाम देता है।

उदाहरण

iex> Module.concat([Foo, Bar])
Foo.Bar

iex> Module.concat([Foo, "Bar"])
Foo.Bar

समतल (बाएं, दाएं)

concat(binary() | atom(), binary() | atom()) :: atom()

दो उपनामों को सम्‍मिलित करता है और एक नया उपनाम देता है।

उदाहरण

iex> Module.concat(Foo, Bar)
Foo.Bar

iex> Module.concat(Foo, "Bar")
Foo.Bar

बनाएँ (मॉड्यूल, उद्धृत, ऑप्स)

create(module(), Macro.t(), Macro.Env.t() | keyword()) ::
  {:module, module(), binary(), term()}

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

मॉड्यूल को परिभाषित करने वाली लाइन और उसकी फाइल को विकल्प के रूप में पारित किया जाना चाहिए।

यह आकार का एक टपल देता है {:module, module, binary, term} जहां module मॉड्यूल का नाम है, binary मॉड्यूल बाइट कोड है और term quoted में अंतिम अभिव्यक्ति का परिणाम है।

Kernel.defmodule/2 समान, बाइनरी केवल एक .beam फ़ाइल के रूप में डिस्क के लिए लिखा जाएगा यदि Module.create/3 को उस फ़ाइल में आमंत्रित किया जाता है जिसे वर्तमान में संकलित किया जा रहा है।

उदाहरण

contents =
  quote do
    def world, do: true
  end

Module.create(Hello, contents, Macro.Env.location(__ENV__))

Hello.world #=> true

defmodule से अंतर

Module.create/3 Kernel.defmodule/2 समान कार्य करता है और समान परिणाम लौटाता है। हालांकि कोई भी मॉड्यूल को गतिशील रूप से परिभाषित करने के लिए defmodule का उपयोग कर सकता है, यह फ़ंक्शन तब पसंद किया जाता है जब मॉड्यूल बॉडी को एक उद्धृत अभिव्यक्ति द्वारा दिया जाता है।

एक अन्य महत्वपूर्ण अंतर यह है कि Module.create/3 आपको मॉड्यूल को परिभाषित करते समय उपयोग किए जाने वाले पर्यावरण वेरिएबल्स को नियंत्रित करने की अनुमति देता है, जबकि Kernel.defmodule/2 स्वचालित रूप से उस वातावरण का उपयोग करता है जिस पर इसे लगाया जाता है।

परिभाषित करता है; (मॉड्यूल, टपल)

defines?(module(), definition()) :: boolean()

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

विशिष्ट प्रकार के लिए मुखर करने के लिए defines?/3 करें defines?/3 का उपयोग करें।

यह फ़ंक्शन केवल उन मॉड्यूल पर उपयोग किया जा सकता है जो अभी तक संकलित नहीं किए गए हैं। संकलित मॉड्यूल की जांच करने के लिए Kernel.function_exported?/3 उपयोग करें।

उदाहरण

defmodule Example do
  Module.defines? __MODULE__, {:version, 0} #=> false
  def version, do: 1
  Module.defines? __MODULE__, {:version, 0} #=> true
end

परिभाषित करता है; (मॉड्यूल, टपल, डिफाइंड)

defines?(module(), definition(), def_kind()) :: boolean()

जाँचता है कि क्या मॉड्यूल दिए गए kind फ़ंक्शन या मैक्रो को परिभाषित करता है।

kind कोई भी हो सकता है :def :defp , या :defmacrop

यह फ़ंक्शन केवल उन मॉड्यूल पर उपयोग किया जा सकता है जो अभी तक संकलित नहीं किए गए हैं। संकलित मॉड्यूल की जांच करने के लिए Kernel.function_exported?/3 उपयोग करें।

उदाहरण

defmodule Example do
  Module.defines? __MODULE__, {:version, 0}, :defp #=> false
  def version, do: 1
  Module.defines? __MODULE__, {:version, 0}, :defp #=> false
end

defines_type? (मॉड्यूल, परिभाषा) (1.7.0 के बाद से)

defines_type?(module(), definition()) :: boolean()

जाँच करता है कि क्या वर्तमान मॉड्यूल दिए गए प्रकार (निजी, अपारदर्शी या नहीं) को परिभाषित करता है।

यह फ़ंक्शन केवल संकलित किए जा रहे मॉड्यूल के लिए उपलब्ध है।

definitions_in (मॉड्यूल)

definitions_in(module()) :: [definition()]

module में परिभाषित सभी फ़ंक्शन देता है।

उदाहरण

defmodule Example do
  def version, do: 1
  Module.definitions_in __MODULE__ #=> [{:version, 0}]
end

परिभाषाएँ_इन (मॉड्यूल, डीफ़ाइकिन्ड)

definitions_in(module(), def_kind()) :: [definition()]

module में परिभाषित सभी फ़ंक्शंस देता है, अपनी तरह के अनुसार।

उदाहरण

defmodule Example do
  def version, do: 1
  Module.definitions_in __MODULE__, :def  #=> [{:version, 0}]
  Module.definitions_in __MODULE__, :defp #=> []
end

delete_attribute (मॉड्यूल, कुंजी)

delete_attribute(module(), atom()) :: term()

दी गई कुंजी से मेल खाने वाले मॉड्यूल विशेषता को हटाता है।

यह हटाए गए विशेषता मान (या यदि कुछ भी सेट नहीं किया गया था तो nil ) लौटाता है।

उदाहरण

defmodule MyModule do
  Module.put_attribute __MODULE__, :custom_threshold_for_lib, 10
  Module.delete_attribute __MODULE__, :custom_threshold_for_lib
end

eval_quoted (मॉड्यूल_or_env, उद्धृत, बाइंडिंग \\ [], opts \\ [])

eval_quoted(
  module() | Macro.Env.t(),
  Macro.t(),
  list(),
  keyword() | Macro.Env.t()
) :: term()

दिए गए मॉड्यूल के संदर्भ में उद्धृत सामग्री का मूल्यांकन करता है।

तर्क के रूप में पर्यावरण विकल्पों की एक सूची भी दी जा सकती है। अधिक जानकारी के लिए Code.eval_string/3 देखें।

मॉड्यूल पहले से ही संकलित किया गया था, तो एक त्रुटि उठाता है।

उदाहरण

defmodule Foo do
  contents = quote do: (def sum(a, b), do: a + b)
  Module.eval_quoted __MODULE__, contents
end

Foo.sum(1, 2) #=> 3

सुविधा के लिए, आप किसी भी Macro.Env संरचना को पारित कर सकते हैं, जैसे कि __ENV__/0 , पहले तर्क के रूप में या विकल्प के रूप में। मॉड्यूल और सभी विकल्प स्वचालित रूप से पर्यावरण से निकाले जाएंगे:

defmodule Foo do
  contents = quote do: (def sum(a, b), do: a + b)
  Module.eval_quoted __ENV__, contents
end

Foo.sum(1, 2) #=> 3

ध्यान दें कि यदि आप एक Macro.Env पास करते हैं। Macro.Env संरचना को पहले तर्क के रूप में भी, जबकि पासिंग Macro.Env पास करते हैं, तो उन्हें पूर्ववर्ती होने वाले Macro.Env साथ विलय कर दिया जाएगा।

get_attribute (मॉड्यूल, कुंजी)

get_attribute(module(), atom()) :: term()

किसी मॉड्यूल से दी गई विशेषता प्राप्त करता है।

यदि Module.register_attribute/3 के साथ accumulate साथ चिह्नित किया गया था, तो एक सूची हमेशा वापस आ जाती है। यदि विशेषता के accumulate के साथ चिह्नित नहीं किया गया है और किसी भी मूल्य पर सेट नहीं किया गया है तो nil वापस कर दिया जाता है।

@ मैक्रो इस फ़ंक्शन को कॉल करने के लिए संकलित करता है। उदाहरण के लिए, निम्न कोड:

@foo

कुछ के समान है:

Module.get_attribute(__MODULE__, :foo)

उदाहरण

defmodule Foo do
  Module.put_attribute __MODULE__, :value, 1
  Module.get_attribute __MODULE__, :value #=> 1

  Module.register_attribute __MODULE__, :value, accumulate: true
  Module.put_attribute __MODULE__, :value, 1
  Module.get_attribute __MODULE__, :value #=> [1]
end

make_overridable (मॉड्यूल, ट्यूपल्स)

make_overridable(module(), module()) :: :ok
make_overridable(module(), [definition()]) :: :ok

module में दिए गए कार्यों को अधिक करने योग्य बनाता है।

एक overridable फ़ंक्शन को lazily परिभाषित किया गया है, जिससे एक डेवलपर इसे अनुकूलित कर सकता है। अधिक जानकारी और दस्तावेज़ीकरण के लिए Kernel.defoverridable/1 देखें।

खोलने? (मॉड्यूल)

open?(module()) :: boolean()

जाँचता है कि क्या कोई मॉड्यूल खुला है।

एक मॉड्यूल "खुला" है अगर यह वर्तमान में परिभाषित किया जा रहा है और इसकी विशेषताओं और कार्यों को संशोधित किया जा सकता है।

overridable। (मॉड्यूल, टपल)

overridable?(module(), definition()) :: boolean()

module में tuple को अतिव्याप्त के रूप में चिह्नित किया गया है तो true है।

put_attribute (मॉड्यूल, कुंजी, मूल्य)

put_attribute(module(), atom(), term()) :: :ok

दिए गए module में key और value साथ एक मॉड्यूल विशेषता डालता है।

उदाहरण

defmodule MyModule do
  Module.put_attribute __MODULE__, :custom_threshold_for_lib, 10
end

register_attribute (मॉड्यूल, विशेषता, विकल्प)

register_attribute(module(), atom(), accumulate: boolean(), persist: boolean()) ::
  :ok

एक विशेषता पंजीकृत करता है।

एक विशेषता को पंजीकृत करके, एक डेवलपर यह अनुकूलित करने में सक्षम है कि कैसे अमृत विशेषता मूल्यों को संग्रहीत और संचित करेगा।

विकल्प

विशेषता दर्ज करते समय, दो विकल्प दिए जा सकते हैं:

  • :accumulate - एक ही विशेषता के कई कॉल पिछले एक को ओवरराइड करने के बजाय जमा हो जाएंगे। नई विशेषताओं को हमेशा संचित सूची के शीर्ष पर जोड़ा जाता है।

  • :persist - विशेषता Erlang Abstract Format में बनी रहेगी। Erlang पुस्तकालयों के साथ इंटरफेस करते समय उपयोगी।

डिफ़ॉल्ट रूप से, दोनों विकल्प false

उदाहरण

defmodule MyModule do
  Module.register_attribute __MODULE__,
    :custom_threshold_for_lib,
    accumulate: true, persist: false

  @custom_threshold_for_lib 10
  @custom_threshold_for_lib 20
  @custom_threshold_for_lib #=> [20, 10]
end

safe_concat (सूची)

safe_concat([binary() | atom()]) :: atom()

एलियंस की एक सूची को सम्‍मिलित करता है और एक नया उपनाम लौटाता है यदि उपनाम पहले से संदर्भित था।

यदि उपनाम अभी तक संदर्भित नहीं किया गया था, तो ArgumentError साथ विफल हो जाता है। यह charlists, binaries और परमाणुओं को संभालता है।

उदाहरण

iex> Module.safe_concat([Module, Unknown])
** (ArgumentError) argument error

iex> Module.safe_concat([List, Chars])
List.Chars

safe_concat (बाएं, दाएं)

safe_concat(binary() | atom(), binary() | atom()) :: atom()

दो उपनामों को सम्‍मिलित करता है और एक नया उपनाम लौटाता है यदि उपनाम पहले से संदर्भित था।

यदि उपनाम अभी तक संदर्भित नहीं किया गया था, तो ArgumentError साथ विफल हो जाता है। यह charlists, binaries और परमाणुओं को संभालता है।

उदाहरण

iex> Module.safe_concat(Module, Unknown)
** (ArgumentError) argument error

iex> Module.safe_concat(List, Chars)
List.Chars

spec_to_callback (मॉड्यूल, परिभाषा) (1.7.0 के बाद से)

spec_to_callback(module(), definition()) :: boolean()

कॉलबैक में दिए गए युक्ति को परिवर्तित करता है।

अगर इस तरह की कल्पना है और यह एक कॉलबैक में परिवर्तित हो गया था, तो true

विभाजन (मॉड्यूल)

split(module() | String.t()) :: [String.t(), ...]

बाइनरी भागों में दिए गए मॉड्यूल नाम को विभाजित करता है।

module में एक एलिक्सिर मॉड्यूल होना चाहिए, क्योंकि split(module) एरलैंग-स्टाइल मॉड्यूल के साथ काम नहीं करेगा (उदाहरण के लिए, split(:lists) एक त्रुटि उठाता है)।

split(module) भी Atom.to_string/1 मॉड्यूल के स्ट्रिंग प्रतिनिधित्व को विभाजित करने का समर्थन करता है (अर्थात, Atom.to_string/1 को मॉड्यूल नाम से कॉल करने का परिणाम है)।

उदाहरण

iex> Module.split(Very.Long.Module.Name.And.Even.Longer)
["Very", "Long", "Module", "Name", "And", "Even", "Longer"]
iex> Module.split("Elixir.String.Chars")
["String", "Chars"]