Elixir v1.4.2 Macro.Env

A struct that holds compile time environment information.

The current environment can be accessed at any time as __ENV__/0. Inside macros, the caller environment can be accessed as __CALLER__/0.

An instance of Macro.Env must not be modified by hand. If you need to create a custom environment to pass to Code.eval_quoted/3, use the following trick:

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

You may then call make_custom_env() to get a struct with the desired imports and aliases included.

It contains the following fields:

  • module - the current module name
  • file - the current file name as a binary
  • line - the current line as an integer
  • function - a tuple as {atom, integer}, where the first element is the function name and the second its arity; returns nil if not inside a function
  • context - the context of the environment; it can be nil (default context), inside a guard or inside a match
  • aliases - a list of two-element tuples, where the first element is the aliased name and the second one the actual name
  • requires - the list of required modules
  • functions - a list of functions imported from each module
  • macros - a list of macros imported from each module
  • macro_aliases - a list of aliases defined inside the current macro
  • context_modules - a list of modules defined in the current context
  • vars - a list keeping all defined variables as {var, context}
  • export_vars - a list keeping all variables to be exported in a construct (may be nil)
  • lexical_tracker - PID of the lexical tracker which is responsible for keeping user info

Summary

Functions

Returns whether the compilation environment is currently inside a guard

Returns whether the compilation environment is currently inside a match clause

Returns a keyword list containing the file and line information as keys

Returns the environment stacktrace

Types

aliases()
aliases() :: [{module, module}]
context()
context() :: :match | :guard | nil
context_modules()
context_modules() :: [module]
export_vars()
export_vars() :: vars | nil
file()
file() :: binary
functions()
functions() :: [{module, [name_arity]}]
lexical_tracker()
lexical_tracker() :: pid
line()
line() :: non_neg_integer
local()
local() :: atom | nil
macro_aliases()
macro_aliases() :: [{module, {integer, module}}]
macros()
macros() :: [{module, [name_arity]}]
name_arity()
name_arity() :: {atom, arity}
requires()
requires() :: [module]
t()
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, export_vars: export_vars, lexical_tracker: lexical_tracker}
vars()
vars() :: [{atom, atom | non_neg_integer}]

Functions

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

Returns whether the compilation environment is currently inside a guard.

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

Returns whether the compilation environment is currently inside a match clause.

location(env)
location(t) :: Keyword.t

Returns a keyword list containing the file and line information as keys.

stacktrace(env)
stacktrace(t) :: list

Returns the environment stacktrace.