Elixir 1.7

Macro.Env




elixir

Macro.Env

एक संरचना जो संकलन समय पर्यावरण की जानकारी रखती है।

वर्तमान वातावरण को __ENV__/0 रूप में किसी भी समय एक्सेस किया जा सकता है। मैक्रोज़ के अंदर, कॉलर वातावरण को __CALLER__/0 रूप में एक्सेस किया जा सकता है।

Macro.Env का एक उदाहरण हाथ से संशोधित नहीं होना चाहिए। यदि आपको Code.eval_quoted/3 पास करने के लिए एक कस्टम वातावरण बनाने की आवश्यकता है, तो निम्न चाल का उपयोग करें:

def make_custom_env do
  import SomeModule, only: [some_function: 2]
  alias A.B.C
  __ENV__
end

फिर आप इच्छित आयात और उपनामों के साथ एक संरचना प्राप्त करने के लिए make_custom_env() को कॉल कर सकते हैं।

इसमें निम्नलिखित फ़ील्ड शामिल हैं:

  • module - वर्तमान मॉड्यूल का नाम
  • file - बाइनरी के रूप में वर्तमान फ़ाइल नाम
  • line - एक पूर्णांक के रूप में वर्तमान रेखा
  • function - एक {atom, integer} रूप में {atom, integer} , जहां पहला तत्व फ़ंक्शन का नाम है और दूसरा इसकी आर्किटी; एक फ़ंक्शन के अंदर नहीं होने पर nil देता है
  • context - पर्यावरण का संदर्भ; यह nil (डिफ़ॉल्ट संदर्भ), एक गार्ड के अंदर या एक मैच के अंदर हो सकता है
  • aliases - दो-तत्व ट्यूपल्स की एक सूची, जहां पहला तत्व उपनाम नाम है और दूसरा वास्तविक नाम
  • requires - आवश्यक मॉड्यूल की सूची
  • functions - प्रत्येक मॉड्यूल से आयात किए गए फ़ंक्शंस की एक सूची
  • macros - प्रत्येक मॉड्यूल से आयातित मैक्रोज़ की एक सूची
  • macro_aliases - वर्तमान मैक्रो के अंदर परिभाषित उपनामों की एक सूची
  • context_modules - वर्तमान संदर्भ में परिभाषित मॉड्यूल की एक सूची
  • लेक्सिकल_ट्रैकर - लेक्सिकल ट्रैकर की पीआईडी ​​जो उपयोगकर्ता की जानकारी रखने के लिए जिम्मेदार है

निम्न फ़ील्ड परिवर्तनशील हैंडलिंग से संबंधित हैं और उन तक पहुँच या निर्भर नहीं होना चाहिए। सभी चर की सूची प्राप्त करने के लिए, vars/1 देखें:

  • current_vars
  • unused_vars
  • prematch_vars
  • contextual_vars

निम्नलिखित क्षेत्रों को हटा दिया गया है और उन तक पहुंच या उन पर निर्भर नहीं होना चाहिए:

  • vars - सभी परिभाषित चर को {var, context} रूप में रखने वाली सूची

सारांश

प्रकार

aliases()
context()
context_modules()
file()
functions()
lexical_tracker()
line()
macro_aliases()
macros()
name_arity()
requires()
t()
var()

कार्य

has_var? (env, var)

जाँचता है कि क्या एक चर पर्यावरण का है

in_guard?(env)

यह संकलित करता है कि संकलन वातावरण वर्तमान में एक गार्ड के अंदर है या नहीं

in_match?(env)

वापसी करता है कि संकलन वातावरण वर्तमान में एक मैच क्लॉज के अंदर है

location(env)

एक कीवर्ड सूची लौटाता है जिसमें फ़ाइल और पंक्ति जानकारी कुंजियों के रूप में होती है

stacktrace(env)

पर्यावरण स्टैकट्रेस लौटाता है

to_match(env)

मैच के संदर्भ में एक Macro.Env लौटाता है

vars/1

वर्तमान परिवेश में चर की सूची लौटाता है

प्रकार

उपनाम ()

aliases() :: [{module(), module()}]

संदर्भ ()

context() :: :match | :guard | nil

context_modules ()

context_modules() :: [module()]

फ़ाइल ()

file() :: binary()

कार्य ()

functions() :: [{module(), [name_arity()]}]

lexical_tracker ()

lexical_tracker() :: pid() | nil

लाइन ()

line() :: non_neg_integer()

macro_aliases ()

macro_aliases() :: [{module(), {integer(), module()}}]

मैक्रो ()

macros() :: [{module(), [name_arity()]}]

name_arity ()

name_arity() :: {atom(), arity()}

की आवश्यकता है ()

requires() :: [module()]

टी ()

t() :: %Macro.Env{
  module: atom(),
  file: file(),
  line: line(),
  function: name_arity() | nil,
  context: context(),
  requires: requires(),
  aliases: aliases(),
  functions: functions(),
  macros: macros(),
  macro_aliases: aliases(),
  context_modules: context_modules(),
  vars: vars(),
  unused_vars: unused_vars(),
  current_vars: current_vars(),
  prematch_vars: prematch_vars(),
  lexical_tracker: lexical_tracker(),
  contextual_vars: contextual_vars()
}

वर ()

var() :: {atom(), atom() | non_neg_integer()}

कार्य

has_var? (env, var) (1.7.0 से)

has_var?(t(), var()) :: boolean()

जाँचता है कि क्या एक चर पर्यावरण का है।

in_guard? (env)

in_guard?(t()) :: boolean()

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

in_match? (env)

in_match?(t()) :: boolean()

वापसी करता है कि संकलन वातावरण वर्तमान में एक मैच क्लॉज के अंदर है।

स्थान (env)

location(t()) :: keyword()

एक कीवर्ड सूची लौटाता है जिसमें फ़ाइल और पंक्ति जानकारी कुंजियों के रूप में होती है।

स्टैकट्रेस (env)

stacktrace(t()) :: list()

पर्यावरण स्टैकट्रेस लौटाता है।

to_match (env)

to_match(t()) :: t()

मैच के संदर्भ में एक Macro.Env लौटाता है।

vars (env) (1.7.0 के बाद से)

vars(t()) :: [var()]

वर्तमान परिवेश में चर की सूची लौटाता है।

प्रत्येक चर की पहचान दो तत्वों के एक समूह द्वारा की जाती है, जहां पहला तत्व एक परमाणु के रूप में चर नाम है और दूसरा तत्व इसका संदर्भ है, जो एक परमाणु या पूर्णांक हो सकता है।