Elixir 1.7

Macro




elixir

Macro

मैक्रों के साथ काम करने की सुविधा।

कस्टम सिगिल

एक कस्टम sigil_{identifier} बनाने के लिए, sigil_{identifier} नाम के साथ एक फ़ंक्शन को परिभाषित करें जो दो तर्क लेता है। पहला तर्क स्ट्रिंग होगा, दूसरा एक चार्जलिस्ट होगा जिसमें कोई भी संशोधक होगा। यदि निचली स्थिति कम है (जैसे कि sigil_x ) तो स्ट्रिंग तर्क प्रक्षेप की अनुमति देगा। यदि sigil_X ऊपरी मामला है (जैसे कि sigil_X ) तो स्ट्रिंग को प्रक्षेपित नहीं किया जाएगा।

वैध संशोधक में केवल निचले और ऊपरी मामले के अक्षर शामिल हैं। अन्य वर्ण एक सिंटैक्स त्रुटि का कारण बनेंगे।

कस्टम सिगनल युक्त मॉड्यूल को सिगनल सिंटैक्स का उपयोग करने से पहले आयात किया जाना चाहिए।

उदाहरण

defmodule MySigils do
  defmacro sigil_x(term, [?r]) do
    quote do
      unquote(term) |> String.reverse()
    end
  end
  defmacro sigil_x(term, _modifiers) do
    term
  end
  defmacro sigil_X(term, [?r]) do
    quote do
      unquote(term) |> String.reverse()
    end
  end
  defmacro sigil_X(term, _modifiers) do
    term
  end
end

import MySigils

~x(with #{"inter" <> "polation"})
#=>"with interpolation"

~x(with #{"inter" <> "polation"})r
#=>"noitalopretni htiw"

~X(without #{"interpolation"})
#=>"without \#{"interpolation"}"

~X(without #{"interpolation"})r
#=>"}\"noitalopretni\"{# tuohtiw"

सारांश

प्रकार

expr()

एएसटी में अभिव्यक्तियों का प्रतिनिधित्व करता है

literal()

एएसटी में शाब्दिक का प्रतिनिधित्व करता है

t()

सार सिंटेक्स ट्री (एएसटी)

कार्य

camelize(string)

दिए गए स्ट्रिंग को CamelCase प्रारूप में परिवर्तित करता है

decompose_call(ast)

अपने दूरस्थ भाग (जब प्रदान किया जाता है), फ़ंक्शन नाम और तर्क सूची में स्थानीय या दूरस्थ कॉल का विरोध करता है

बच (expr, opts \\ [])

पुनरावर्ती मान से बच जाता है, इसलिए इसे एक सिंटैक्स ट्री में डाला जा सकता है

विस्तार (पेड़, एनवी)

एएसटी नोड प्राप्त करता है और इसका विस्तार करता है जब तक कि इसे अब विस्तारित नहीं किया जा सकता है

Expand_once (ast, env)

एएसटी नोड प्राप्त करता है और एक बार इसका विस्तार करता है

उत्पन्न_गुण (राशि, संदर्भ)

Macro.var/2 का उपयोग करके दिए गए आवश्यक तर्क चर की संख्या के लिए एएसटी नोड उत्पन्न करता है

संचालक। (नाम, आरती)

यदि दिया गया नाम और अर्थ एक ऑपरेटर है, तो सही है

पाइप (expr, call_args, स्थिति)

पाइप दिए गए position पर call_args में call_args जाते हैं

पोस्टवॉक (आश्चर्यजनक, मजेदार)

उद्धृत भावों की गहराई-प्रथम, उत्तर-क्रम अनुरेखण करता है

पोस्टवॉक (खगोल, एसीसी, मस्ती)

एक संचायक का उपयोग करते हुए उद्धृत अभिव्यक्तियों की गहराई-प्रथम, पोस्ट-ऑर्डर ट्रैवर्सल करता है

प्रीवॉक (खगोल, मजेदार)

उद्धृत भावों की गहराई-प्रथम, पूर्व-क्रम अनुरेखण करता है

प्रीवॉक (एस्ट्रो, एसीसी, फन)

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

quoted_literal?(term)

true अगर दिए गए उद्धरण अभिव्यक्ति एक एएसटी शाब्दिक है

special_form? (नाम, arity)

यदि दिया गया नाम और अर्थ एक विशेष रूप है, तो सही है

to_string (पेड़, मज़ेदार \\ fn _ast, string -> string end)

दिए गए अभिव्यक्ति AST को एक स्ट्रिंग में परिवर्तित करता है

ट्रैवर्स (एस्ट, एसीसी, प्री, पोस्ट)

एक संचायक का उपयोग करते हुए उद्धृत भावों की गहराई-पहला ट्रावेल करता है

underscore(atom)

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

unescape_string(chars)

दिए गए वर्णों को मिटा देता है

unescape_string (वर्ण, मानचित्र)

दिए गए नक्शे के अनुसार दिए गए वर्णों को हटा देता है

unpipe(expr)

एक सूची में एक पाइपलाइन अभिव्यक्ति को तोड़ता है

update_meta (उद्धृत, मजेदार)

दिए गए फ़ंक्शन को नोड मेटाडेटा पर लागू करता है यदि इसमें एक होता है

validate(expr)

दिए गए भाव मान्य उद्धरण भाव मान्य हैं

var (var, संदर्भ)

एक एएसटी नोड उत्पन्न करता है जो परमाणुओं के var और context द्वारा दिए गए चर का प्रतिनिधित्व करता context

प्रकार

expr ()

expr() :: {expr() | atom(), keyword(), atom() | [t()]}

एएसटी में अभिव्यक्तियों का प्रतिनिधित्व करता है

शाब्दिक ()

literal() ::
  atom() | number() | binary() | (... -> any()) | {t(), t()} | [t()]

एएसटी में शाब्दिक का प्रतिनिधित्व करता है

टी ()

t() :: expr() | literal()

सार सिंटेक्स ट्री (एएसटी)

कार्य

camelize (स्ट्रिंग)

camelize(String.t()) :: String.t()

दिए गए स्ट्रिंग को CamelCase प्रारूप में परिवर्तित करता है।

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

उदाहरण

iex> Macro.camelize("foo_bar")
"FooBar"

यदि अपरकेस वर्ण मौजूद हैं, तो वे किसी भी तरह से संशोधित नहीं हैं एक तंत्र के रूप में सुरक्षित रखने के लिए:

iex> Macro.camelize("API.V1")
"API.V1"
iex> Macro.camelize("API_SPEC")
"API_SPEC"

decompose_call (एएसटी)

decompose_call(Macro.t()) ::
  {atom(), [Macro.t()]} | {Macro.t(), atom(), [Macro.t()]} | :error

अपने दूरस्थ भाग (जब प्रदान किया जाता है), फ़ंक्शन नाम और तर्क सूची में स्थानीय या दूरस्थ कॉल का विरोध करता है।

रिटर्न :error जब एक अवैध कॉल सिंटैक्स प्रदान किया जाता है।

उदाहरण

iex> Macro.decompose_call(quote(do: foo))
{:foo, []}

iex> Macro.decompose_call(quote(do: foo()))
{:foo, []}

iex> Macro.decompose_call(quote(do: foo(1, 2, 3)))
{:foo, [1, 2, 3]}

iex> Macro.decompose_call(quote(do: Elixir.M.foo(1, 2, 3)))
{{:__aliases__, [], [:Elixir, :M]}, :foo, [1, 2, 3]}

iex> Macro.decompose_call(quote(do: 42))
:error

बच (expr, opts \\ [])

escape(term(), keyword()) :: Macro.t()

पुनरावर्ती मान से बच जाता है, इसलिए इसे एक सिंटैक्स ट्री में डाला जा सकता है।

उदाहरण

iex> Macro.escape(:foo)
:foo

iex> Macro.escape({:a, :b, :c})
{:{}, [], [:a, :b, :c]}

iex> Macro.escape({:unquote, [], [1]}, unquote: true)
1

विकल्प

  • :unquote - जब सत्य होता है, तो यह फ़ंक्शन unquote_splicing/1 और unquote_splicing/1 कथनों को छोड़ देता है, जो बच जाता है, प्रभावी रूप से भागने पर सामग्री को अयोग्य कर देता है। यह विकल्प केवल तभी उपयोगी होता है जब एएसटी से बच निकलते हैं जो उनमें अंशों को उद्धृत कर सकते हैं। झूठे की अवहेलना करता है।

  • :prune_metadata - जब सही होता है, तो मेटाडेटा को :prune_metadata एएसटी नोड्स से हटा देता है। ध्यान दें कि यह विकल्प बच गए कोड के शब्दार्थ को बदलता है और इसका उपयोग केवल एएसटी से बचते समय किया जाना चाहिए, कभी भी मान नहीं। झूठे की अवहेलना करता है।

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

Kernel.quote/2 तुलना करें। Kernel.quote/2

escape/2 फ़ंक्शन को कभी-कभी Kernel.SpecialForms.quote/2 साथ भ्रमित किया जाता है। Kernel.SpecialForms.quote/2 , क्योंकि उपरोक्त उदाहरण दोनों के साथ समान व्यवहार करते हैं। मुख्य अंतर सबसे अच्छा है जब बचने का मूल्य एक चर में संग्रहीत किया जाता है।

iex> Macro.escape({:a, :b, :c})
{:{}, [], [:a, :b, :c]}
iex> quote do: {:a, :b, :c}
{:{}, [], [:a, :b, :c]}

iex> value = {:a, :b, :c}
iex> Macro.escape(value)
{:{}, [], [:a, :b, :c]}

iex> quote do: value
{:value, [], __MODULE__}

iex> value = {:a, :b, :c}
iex> quote do: unquote(value)
{:a, :b, :c}

escape/2 का उपयोग मानों से बचने के लिए किया जाता है (या तो सीधे या चर बाउंड), जबकि Kernel.SpecialForms.quote/2 अभिव्यक्ति के लिए वाक्यविन्यास के पेड़ पैदा करता है।

विस्तार (पेड़, एनवी)

एएसटी नोड प्राप्त करता है और इसका विस्तार करता है जब तक कि इसे अब विस्तारित नहीं किया जा सकता है।

यह फ़ंक्शन हुड के तहत expand_once/2 का उपयोग करता है। अधिक जानकारी और उदाहरणों के लिए इसे देखें।

Expand_once (ast, env)

एएसटी नोड प्राप्त करता है और एक बार इसका विस्तार करता है।

निम्नलिखित सामग्री का विस्तार किया गया है:

  • मैक्रोज़ (स्थानीय या दूरस्थ)
  • उपनामों का विस्तार (यदि संभव हो) और वापसी परमाणु हैं
  • संकलन वातावरण मैक्रोज़ ( __CALLER__/0 , __DIR__/0 , __ENV__/0 और __MODULE__/0 )
  • मॉड्यूल विशेषताएँ पाठक ( @foo )

यदि अभिव्यक्ति का विस्तार नहीं किया जा सकता है, तो यह अभिव्यक्ति को ही लौटाता है। ध्यान दें कि expand_once/2 केवल एक बार विस्तार करता है और यह पुनरावर्ती नहीं है। expand/2 लिए विस्तार expand/2 जांचें जब तक कि नोड का विस्तार नहीं किया जा सकता है।

उदाहरण

नीचे दिए गए उदाहरण में, हमारे पास एक मैक्रो है, जो name_length नामक फ़ंक्शन के साथ एक मॉड्यूल बनाता है जो मॉड्यूल नाम की लंबाई लौटाता है। इस फ़ंक्शन के मूल्य की गणना संकलन समय पर की जाएगी न कि रनटाइम पर।

नीचे दिए गए कार्यान्वयन पर विचार करें:

defmacro defmodule_with_length(name, do: block) do
  length = length(Atom.to_charlist(name))

  quote do
    defmodule unquote(name) do
      def name_length, do: unquote(length)
      unquote(block)
    end
  end
end

जब इस तरह आमंत्रित किया गया:

defmodule_with_length My.Module do
  def other_function, do: ...
end

संकलन विफल हो जाएगा क्योंकि My.Module जब उद्धृत किया जाता है, तो वह परमाणु नहीं है, लेकिन एक वाक्यविन्यास वृक्ष इस प्रकार है:

{:__aliases__, [], [:My, :Module]}

उस ने कहा, हमें एक परमाणु के ऊपर एलियास नोड का विस्तार करने की आवश्यकता है, इसलिए हम इसकी लंबाई को पुनः प्राप्त कर सकते हैं। नोड का विस्तार करना सीधा नहीं है क्योंकि हमें कॉलर उपनामों का विस्तार करने की भी आवश्यकता है। उदाहरण के लिए:

alias MyHelpers, as: My

defmodule_with_length My.Module do
  def other_function, do: ...
end

अंतिम मॉड्यूल का नाम MyHelpers.Module होगा न कि My.Module Macro.expand/2 , ऐसे उपनामों को ध्यान में रखा जाता है। स्थानीय और दूरस्थ मैक्रोज़ का भी विस्तार किया जाता है। हम इस फ़ंक्शन का उपयोग करने के लिए ऊपर अपने मैक्रो को फिर से लिख सकते हैं:

defmacro defmodule_with_length(name, do: block) do
  expanded = Macro.expand(name, __CALLER__)
  length   = length(Atom.to_charlist(expanded))

  quote do
    defmodule unquote(name) do
      def name_length, do: unquote(length)
      unquote(block)
    end
  end
end

उत्पन्न_कार्य (राशि, संदर्भ) (1.5.0 से)

Macro.var/2 का उपयोग करके दिए गए आवश्यक तर्क चर की संख्या के लिए एएसटी नोड उत्पन्न करता है।

उदाहरण

iex> Macro.generate_arguments(2, __MODULE__)
[{:var1, [], __MODULE__}, {:var2, [], __MODULE__}]

ऑपरेटर (नाम, arity) (1.7.0 से)

operator?(name :: atom(), arity()) :: boolean()

यदि दिया गया नाम और अर्थ एक ऑपरेटर है, तो सही है।

पाइप (expr, call_args, स्थिति)

pipe(Macro.t(), Macro.t(), integer()) :: Macro.t() | no_return()

पाइप दिए गए position पर call_args में call_args जाते हैं।

पोस्टवॉक (आश्चर्यजनक, मजेदार)

postwalk(t(), (t() -> t())) :: t()

उद्धृत भावों की गहराई-प्रथम, उत्तर-क्रम अनुरेखण करता है।

पोस्टवॉक (एस्ट्रो, एसीसी, फन)

postwalk(t(), any(), (t(), any() -> {t(), any()})) ::
  {t(), any()}

एक संचायक का उपयोग करते हुए उद्धृत अभिव्यक्तियों की गहराई-प्रथम, पोस्ट-ऑर्डर ट्रैवर्सल करता है।

प्रीवॉक (खगोल, मजेदार)

prewalk(t(), (t() -> t())) :: t()

उद्धृत भावों की गहराई-प्रथम, पूर्व-क्रम अनुरेखण करता है।

प्रीवॉक (एस्ट्रो, एसीसी, फन)

prewalk(t(), any(), (t(), any() -> {t(), any()})) ::
  {t(), any()}

एक संचायक का उपयोग करते हुए उद्धृत अभिव्यक्तियों की गहराई-पहले, पूर्व-क्रम अनुक्रमण करता है।

quoted_literal? (टर्म) (1.7.0 के बाद से)

quoted_literal?(expr()) :: false
quoted_literal?(literal()) :: true

true अगर दिए गए उद्धरण अभिव्यक्ति एक एएसटी शाब्दिक है।

special_form? (नाम, arity) (1.7.0 से)

special_form?(name :: atom(), arity()) :: boolean()

यदि दिया गया नाम और अर्थ एक विशेष रूप है, तो सही है।

to_string (पेड़, मज़ेदार \\ fn _ast, string -> string end)

to_string(Macro.t(), (Macro.t(), String.t() -> String.t())) :: String.t()

दिए गए अभिव्यक्ति AST को एक स्ट्रिंग में परिवर्तित करता है।

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

यह फ़ंक्शन मूल कोड के सभी स्वरूपण को छोड़ देता है।

उदाहरण

iex> Macro.to_string(quote(do: foo.bar(1, 2, 3)))
"foo.bar(1, 2, 3)"

iex> Macro.to_string(quote(do: 1 + 2), fn
...>   1, _string -> "one"
...>   2, _string -> "two"
...>   _ast, string -> string
...> end)
"one + two"

ट्रैवर्स (एस्ट, एसीसी, प्री, पोस्ट)

traverse(
  t(),
  any(),
  (t(), any() -> {t(), any()}),
  (t(), any() -> {t(), any()})
) :: {t(), any()}

एक संचायक का उपयोग करते हुए उद्धृत भावों की गहराई-पहला ट्रावेल करता है।

अंडरस्कोर (परमाणु)

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

यदि एक परमाणु दिया जाता है, तो इसे एक अमृत मॉड्यूल माना जाता है, इसलिए इसे एक बाइनरी में बदल दिया जाता है और फिर संसाधित किया जाता है।

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

उदाहरण

iex> Macro.underscore("FooBar")
"foo_bar"

iex> Macro.underscore("Foo.Bar")
"foo/bar"

iex> Macro.underscore(Foo.Bar)
"foo/bar"

सामान्य तौर पर, underscore को camelize के विपरीत माना जा सकता है, हालांकि, कुछ मामलों में प्रारूपण खो सकता है:

iex> Macro.underscore("SAPExample")
"sap_example"

iex> Macro.camelize("sap_example")
"SapExample"

iex> Macro.camelize("hello_10")
"Hello10"

unescape_string (वर्ण)

unescape_string(String.t()) :: String.t()

दिए गए वर्णों को मिटा देता है।

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

इस सेटअप में, अमृत निम्न से बच जाएगा: \0 , \a , \b , \d , \e , \f , \n , \r , \s , \t और \v । बाइट्स को हेक्साडेसिमल के रूप में \xNN और यूनिकोड कोडप्वाइंट्स के माध्यम से \xNN uNNN के रूप में दिया जा सकता है।

इस फ़ंक्शन का उपयोग आमतौर पर सतर्क कार्यान्वयन (जैसे ~r , ~s और अन्य) पर किया जाता है जो एक कच्चा, बिना स्ट्रिंग प्राप्त करते हैं।

उदाहरण

iex> Macro.unescape_string("example\\n")
"example\n"

ऊपर दिए गए उदाहरण में, हम एक स्ट्रिंग पास करते हैं \n बच जाते हैं और इसके साथ एक संस्करण वापस करते हैं।

unescape_string (वर्ण, मानचित्र)

unescape_string(String.t(), (non_neg_integer() -> non_neg_integer() | false)) ::
  String.t()

दिए गए नक्शे के अनुसार दिए गए वर्णों को हटा देता है।

यदि आप अमृत सिंगल- और डबल-उद्धृत स्ट्रिंग्स के समान मानचित्र का उपयोग करना चाहते हैं तो unescape_string(chars) जांच करें।

नक्शा

नक्शा एक कार्य होना चाहिए। फ़ंक्शन एक पूर्णांक प्राप्त करता है जो उस चरित्र के कोडपॉइंट का प्रतिनिधित्व करता है जिसे वह अनस्केप करना चाहता है। यहां एलिक्सिर द्वारा लागू डिफ़ॉल्ट मैपिंग फ़ंक्शन है:

def unescape_map(unicode), do: true
def unescape_map(hex), do: true
def unescape_map(?0), do: ?0
def unescape_map(?a), do: ?\a
def unescape_map(?b), do: ?\b
def unescape_map(?d), do: ?\d
def unescape_map(?e), do: ?\e
def unescape_map(?f), do: ?\f
def unescape_map(?n), do: ?\n
def unescape_map(?r), do: ?\r
def unescape_map(?s), do: ?\s
def unescape_map(?t), do: ?\t
def unescape_map(?v), do: ?\v
def unescape_map(e),  do: e

यदि unescape_map/1 फ़ंक्शन false , तो चार्ट बच नहीं पाता है और बैकस्लैश स्ट्रिंग में रखा जाता है।

यदि मानचित्र फ़ंक्शन ?x लिए true , तो Hexadecimals और Unicode कोडपाइंट बच जाएंगे ?x यूनिकोड कोडपाइंट यदि मानचित्र फ़ंक्शन ?u लिए true है ?u

उदाहरण

ऊपर परिभाषित unescape_map/1 फ़ंक्शन का उपयोग करना आसान है:

Macro.unescape_string "example\\n", &unescape_map(&1)

unpipe (expr)

unpipe(Macro.t()) :: [Macro.t()]

एक सूची में एक पाइपलाइन अभिव्यक्ति को तोड़ता है।

एक पाइपलाइन के लिए एएसटी (ब्योरे के अनुप्रयोगों का एक क्रम |> ) बाइनरी ऑपरेटरों या फ़ंक्शन अनुप्रयोगों के अनुक्रम के एएसटी के समान है: शीर्ष-स्तरीय अभिव्यक्ति सही-सबसे है :|> (जो कि अंतिम एक है निष्पादित), और इसके बाएं हाथ और दाहिने हाथ के पक्ष इसके तर्क हैं:

quote do: 100 |> div(5) |> div(2)
#=> {:|>, _, [arg1, arg2]}

ऊपर दिए गए उदाहरण में; the |> पाइप सही-सबसे पाइप है; arg1 100 |> div(5) लिए एएसटी है 100 |> div(5) , और arg2 div(2) लिए एएसटी है।

फ़ंक्शन अनुप्रयोगों की सूची के रूप में इस तरह के पाइपलाइन के लिए एएसटी होना अक्सर उपयोगी होता है। यह फ़ंक्शन ठीक यही करता है:

Macro.unpipe(quote do: 100 |> div(5) |> div(2))
#=> [{100, 0}, {{:div, [], [5]}, 0}, {{:div, [], [2]}, 0}]

हमें एक सूची मिलती है जो सीधे पाइपलाइन का अनुसरण करती है: पहले 100 , फिर div(5) (अधिक सटीक रूप से, इसकी एएसटी), फिर div(2) । टुपल्स का दूसरा तत्व वर्तमान फ़ंक्शन अनुप्रयोग के अंदर पाइपलाइन में पिछले तत्व की स्थिति है: {{:div, [], [5]}, 0} अर्थ है कि पिछला तत्व ( 100 ) होगा div/2 फ़ंक्शन के लिए 0 वें (पहले) तर्क के रूप में डाला गया है, ताकि उस फ़ंक्शन के लिए AST {:div, [], [100, 5]} ( div(100, 5) ) बन जाएगा।

update_meta (उद्धृत, मजेदार)

update_meta(t(), (keyword() -> keyword())) :: t()

दिए गए फ़ंक्शन को नोड मेटाडेटा पर लागू करता है यदि इसमें एक होता है।

यह अक्सर उपयोगी होता है जब Macro.prewalk/2 साथ उपयोग किया जाता है Macro.prewalk/2 या तो भंडारण या तुलना के लिए अभिव्यक्ति से लाइन्स और Macro.prewalk/2 काउंटर जैसी जानकारी को हटाया जा सके।

उदाहरण

iex> quoted = quote line: 10, do: sample()
{:sample, [line: 10], []}
iex> Macro.update_meta(quoted, &Keyword.delete(&1, :line))
{:sample, [], []}

मान्य (expr)

validate(term()) :: :ok | {:error, term()}

दिए गए भाव मान्य उद्धरण भाव मान्य हैं।

मान्य उद्धृत अभिव्यक्ति के विनिर्देशन के लिए Macro.t/0 जाँच करता है।

यह रिटर्न :ok अगर अभिव्यक्ति वैध है। अन्यथा यह {:error, remainder} के रूप में एक टपल लौटाता है जहां remainder उद्धृत अभिव्यक्ति का अमान्य हिस्सा है।

उदाहरण

iex> Macro.validate({:two_element, :tuple})
:ok
iex> Macro.validate({:three, :element, :tuple})
{:error, {:three, :element, :tuple}}

iex> Macro.validate([1, 2, 3])
:ok
iex> Macro.validate([1, 2, 3, {4}])
{:error, {4}}

var (var, संदर्भ)

var(var, context) :: {var, [], context} when var: atom(), context: atom()

एक एएसटी नोड उत्पन्न करता है जो परमाणुओं के var और context द्वारा दिए गए चर का प्रतिनिधित्व करता context

उदाहरण

एक चर बनाने के लिए, एक संदर्भ अपेक्षित है। अधिकांश बार, स्वच्छता को बनाए रखने के लिए, संदर्भ __MODULE__/0 होना चाहिए:

iex> Macro.var(:foo, __MODULE__)
{:foo, [], __MODULE__}

हालाँकि, यदि उपयोगकर्ता चर को एक्सेस करने की आवश्यकता है, तो nil दिया जा सकता है:

iex> Macro.var(:foo, nil)
{:foo, [], nil}