Elixir 1.7

Protocol




elixir

Protocol

प्रोटोकॉल के साथ काम करने के लिए कार्य।

सारांश

कार्य

assert_impl! (प्रोटोकॉल, आधार)

यदि दिया गया मॉड्यूल लोड किया गया है और दिए गए प्रोटोकॉल का कार्यान्वयन है, तो यह जांचता है

assert_protocol!(module)

यदि दिया गया मॉड्यूल लोड किया गया है और प्रोटोकॉल है, तो चेक करता है

समेकित करें (प्रोटोकॉल, प्रकार)

एक प्रोटोकॉल और कार्यान्वयन की एक सूची प्राप्त करता है और दिए गए प्रोटोकॉल को समेकित करता है

consolidated?(protocol)

यदि प्रोटोकॉल को समेकित किया गया true तो यह true

def(signature)

एक नया प्रोटोकॉल फ़ंक्शन परिभाषित करता है

व्युत्पन्न (प्रोटोकॉल, मॉड्यूल, विकल्प \\ [])

दिए गए विकल्पों के साथ module लिए protocol देता है

extract_impls (प्रोटोकॉल, पथ)

दिए गए रास्तों से दिए गए प्रोटोकॉल के लिए लागू किए गए सभी प्रकार के अर्क

extract_protocols(paths)

दिए गए रास्तों से सभी प्रोटोकॉल निकालता है

कार्य

assert_impl! (प्रोटोकॉल, आधार)

assert_impl!(module(), module()) :: :ok | no_return()

यदि दिया गया मॉड्यूल लोड किया गया है और दिए गए प्रोटोकॉल का कार्यान्वयन है, तो यह जांचता है।

रिटर्न :ok अगर ऐसा है, तो अन्यथा ArgumentError उठाता है।

assert_protocol! (मॉड्यूल)

assert_protocol!(module()) :: :ok | no_return()

यदि दिया गया मॉड्यूल लोड किया गया है और प्रोटोकॉल है, तो चेक करता है।

रिटर्न :ok अगर ऐसा है, तो अन्यथा ArgumentError उठाता है।

समेकित करें (प्रोटोकॉल, प्रकार)

consolidate(module(), [module()]) ::
  {:ok, binary()} | {:error, :not_a_protocol} | {:error, :no_beam_info}

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

समेकन प्रोटोकॉल में बदलकर होता है। impl_for स्वरूप देखने के लिए सार स्वरूप में impl_for को बदलते हैं। आमतौर पर समेकन के दौरान उपयोग करने के लिए कार्यान्वयन की सूची extract_impls/2 की सहायता से प्राप्त की extract_impls/2

यह प्रोटोकॉल बाइटकोड के अपडेटेड वर्जन को लौटाता है। प्रोटोकॉल विशेषता का विश्लेषण करके किसी दिए गए बायोटेक या प्रोटोकॉल कार्यान्वयन को समेकित किया जा सकता है या नहीं जाँच की जा सकती है:

Protocol.consolidated?(Enumerable)

यदि टपल का पहला तत्व true , तो इसका मतलब है कि प्रोटोकॉल समेकित था।

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

समेकित? (प्रोटोकॉल)

consolidated?(module()) :: boolean()

यदि प्रोटोकॉल को समेकित किया गया true तो यह true

डीईएफ़ (हस्ताक्षर) (मैक्रो)

एक नया प्रोटोकॉल फ़ंक्शन परिभाषित करता है।

प्रोटोकॉल कार्यों को सीधे परिभाषित करने की अनुमति नहीं देते हैं, इसके बजाय, नियमित Kernel.def/* मैक्रोज़ को इस मैक्रो द्वारा प्रतिस्थापित किया जाता है जो उपयुक्त कॉलबैक के साथ प्रोटोकॉल फ़ंक्शन को परिभाषित करता है।

व्युत्पन्न (प्रोटोकॉल, मॉड्यूल, विकल्प \\ []) (मैक्रो)

दिए गए विकल्पों के साथ module लिए protocol देता है।

यदि आपका कार्यान्वयन विकल्प पास करता है या यदि आप संरचना के आधार पर कस्टम कोड उत्पन्न कर रहे हैं, तो आपको उन __deriving__(module, struct, options) को प्राप्त करने के लिए __deriving__(module, struct, options) रूप में परिभाषित मैक्रो लागू करना होगा।

उदाहरण

defprotocol Derivable do
  def ok(a)
end

defimpl Derivable, for: Any do
  defmacro __deriving__(module, struct, options) do
    quote do
      defimpl Derivable, for: unquote(module) do
        def ok(arg) do
          {:ok, arg, unquote(Macro.escape(struct)), unquote(options)}
        end
      end
    end
  end

  def ok(arg) do
    {:ok, arg}
  end
end

defmodule ImplStruct do
  @derive [Derivable]
  defstruct a: 0, b: 0

  defimpl Sample do
    def ok(struct) do
      Unknown.undefined(struct)
    end
  end
end

स्पष्ट व्युत्पत्ति अब __deriving__ माध्यम से __deriving__ जा सकती है:

# Explicitly derived via `__deriving__`
Derivable.ok(%ImplStruct{a: 1, b: 1})

# Explicitly derived by API via `__deriving__`
require Protocol
Protocol.derive(Derivable, ImplStruct, :oops)
Derivable.ok(%ImplStruct{a: 1, b: 1})

extract_impls (प्रोटोकॉल, पथ)

extract_impls(module(), [charlist() | String.t()]) :: [atom()]

दिए गए रास्तों से दिए गए प्रोटोकॉल के लिए लागू किए गए सभी प्रकार के अर्क।

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

किसी भी कार्यान्वयन को लोड नहीं करता है।

उदाहरण

# Get Elixir's ebin and retrieve all protocols
iex> path = :code.lib_dir(:elixir, :ebin)
iex> mods = Protocol.extract_impls(Enumerable, [path])
iex> List in mods
true

extract_protocols (पथ)

extract_protocols([charlist() | String.t()]) :: [atom()]

दिए गए रास्तों से सभी प्रोटोकॉल निकालता है।

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

किसी भी प्रोटोकॉल को लोड नहीं करता है।

उदाहरण

# Get Elixir's ebin and retrieve all protocols
iex> path = :code.lib_dir(:elixir, :ebin)
iex> mods = Protocol.extract_protocols([path])
iex> Enumerable in mods
true