View Source erl_syntax_lib (syntax_tools v3.2)
Support library for abstract Erlang syntax trees.
This module contains utility functions for working with the abstract data type
defined in the module erl_syntax
.
Summary
Functions
Returns the name of a called function. The result is a representation of the
name of the applied function F/A
, if Node
represents a function application
"F(X_1, ..., X_A)
". If the function is not explicitly named (i.e., F
is
given by some expression), only the arity A
is returned.
Analyzes an attribute node. If Node
represents a preprocessor directive, the
atom preprocessor
is returned. Otherwise, if Node
represents a module
attribute "-Name...
", a tuple {Name, Info}
is returned, where Info
depends
on Name
, as follows
Returns the list of function names declared by an export attribute. We do not guarantee that each name occurs at most once in the list. The order of listing is not defined.
Returns the file name and line number of a file
attribute. The result is the
pair {File, Line}
if Node
represents "-file(File, Line).
".
Analyzes a "source code form" node. If Node
is a "form" type (cf.
erl_syntax:is_form/1
), the returned value is a tuple {Type, Info}
where
Type
is the node type and Info
depends on Type
, as follows
Analyzes a sequence of "program forms". The given Forms
may be a single syntax
tree of type form_list
, or a list of "program form" syntax trees. The returned
value is a list of pairs {Key, Info}
, where each value of Key
occurs at most
once in the list; the absence of a particular key indicates that there is no
well-defined value for that key.
Returns the name and arity of a function definition. The result is a pair
{Name, A}
if Node
represents a function definition
"Name(P_1, ..., P_A) -> ...
".
Returns the function name represented by a syntax tree. If Node
represents a
function name, such as "foo/1
" or "bloggs:fred/2
", a uniform representation
of that name is returned. Different nestings of arity and module name qualifiers
in the syntax tree does not affect the result.
Returns the name of an implicit fun expression "fun F
". The result is a
representation of the function name F
. (Cf.
analyze_function_name/1
.)
Returns the module name and (if present) list of function names declared by an
import attribute. The returned value is an atom Module
or a pair
{Module, Names}
, where Names
is a list of function names declared as
imported from the module named by Module
. We do not guarantee that each name
occurs at most once in Names
. The order of listing is not defined.
Returns the module name and possible parameters declared by a module attribute.
If the attribute is a plain module declaration such as -module(name)
, the
result is the module name. If the attribute is a parameterized module
declaration, the result is a tuple containing the module name and a list of the
parameter variable names.
Returns the name and the list of fields of a record declaration attribute. The
result is a pair {Name, Fields}
, if Node
represents
"-record(Name, {...}).
", where Fields
is a list of pairs
{Label, {Default, Type}}
for each field "Label
", "Label = Default
",
"Label :: Type
", or "Label = Default :: Type
" in the declaration, listed in
left-to-right order. If the field has no default-value declaration, the value
for Default
will be the atom none
. If the field has no type declaration, the
value for Type
will be the atom none
. We do not guarantee that each label
occurs at most once in the list.
Returns the record name and field name/names of a record expression. If Node
has type record_expr
, record_index_expr
or record_access
, a pair
{Type, Info}
is returned, otherwise an atom Type
is returned. Type
is the
node type of Node
, and Info
depends on Type
, as follows
Returns the label, value-expression, and type of a record field specifier. The
result is a pair {Label, {Default, Type}}
, if Node
represents "Label
",
"Label = Default
", "Label :: Type
", or "Label = Default :: Type
". If the
field has no value-expression, the value for Default
will be the atom none
.
If the field has no type, the value for Type
will be the atom none
.
Returns the name of a used type. The result is a representation of the name of
the used pre-defined or local type N/A
, if Node
represents a local (user)
type application "N(T_1, ..., T_A)
", or a representation of the name of the
used remote type M:N/A
if Node
represents a remote user type application
"M:N(T_1, ..., T_A)
".
Returns the type name represented by a syntax tree. If Node
represents a type
name, such as "foo/1
" or "bloggs:fred/2
", a uniform representation of that
name is returned.
Returns the name and value of a "wild" attribute. The result is the pair
{Name, Value}
, if Node
represents "-Name(Value)
".
Adds or updates annotations on nodes in a syntax tree. Equivalent to
annotate_bindings(Tree, Bindings)
where the top-level
environment Bindings
is taken from the annotation {env, Bindings}
on the
root node of Tree
. An exception is thrown if no such annotation should exist.
Adds or updates annotations on nodes in a syntax tree. Bindings
specifies the
set of bound variables in the environment of the top level node. The following
annotations are affected
Folds a function over all nodes of a syntax tree. The result is the value of
Function(X1, Function(X2, ... Function(Xn, Start) ... ))
, where
[X1, X2, ..., Xn]
are the nodes of Tree
in a post-order traversal.
Folds a function over the immediate subtrees of a syntax tree. This is similar
to fold/3
, but only on the immediate subtrees of Tree
, in
left-to-right order; it does not include the root node of Tree
.
Like lists:foldl/3
, but over a list of lists.
Creates a mapping from corresponding short names to full function names. Names
are represented by nested tuples of atoms and integers (cf.
analyze_function_name/1
). The result is a list
containing a pair {ShortName, Name}
for each element Name
in the given list,
where the corresponding ShortName
is the rightmost-innermost part of Name
.
The list thus represents a finite mapping from unqualified names to the
corresponding qualified names.
Returns true
if Tree
represents an expression which never terminates
normally. Note that the reverse does not apply. Currently, the detected cases
are calls to exit/1
, throw/1
, erlang:error/1
and
erlang:error/2
.
Equivalent to limit(Tree, Depth, Text)
using the text "..."
as
default replacement.
Limits a syntax tree to a specified depth. Replaces all non-leaf subtrees in
Tree
at the given Depth
by Node
. If Depth
is negative, the result is
always Node
, even if Tree
has no subtrees.
Applies a function to each node of a syntax tree. The result of each application replaces the corresponding original node. The order of traversal is bottom-up.
Applies a function to each immediate subtree of a syntax tree. The result of each application replaces the corresponding original node.
Combines map and fold in a single operation. This is similar to
map/2
, but also propagates an extra value from each application of
the Function
to the next, while doing a post-order traversal of the tree like
fold/3
. The value Start
is passed to the first function
application, and the final result is the result of the last application.
Does a mapfold operation over the immediate subtrees of a syntax tree. This is
similar to mapfold/3
, but only on the immediate subtrees of
Tree
, in left-to-right order; it does not include the root node of Tree
.
Like lists:mapfoldl/3
, but over a list of lists. The list of lists in the
result has the same structure as the given list of lists.
Returns an atom which is not already in the set Used
. This is equivalent to
new_variable_name(Function, Used)
, where Function
maps a given integer N
to the atom whose name consists of "V
" followed by
the numeral for N
.
Returns a user-named atom which is not already in the set Used
. The atom is
generated by applying the given Function
to a generated integer. Integers are
generated using an algorithm which tries to keep the names randomly distributed
within a reasonably small range relative to the number of elements in the set.
Like new_variable_name/1
, but generates a list of N
new names.
Like new_variable_name/2
, but generates a list of N
new names.
Removes all comments from all nodes of a syntax tree. All other attributes (such as position information) remain unchanged. Standalone comments in form lists are removed; any other standalone comments are changed into null-comments (no text, no indentation).
Equivalent to to_comment(Tree, "% ").
Equivalent to to_comment(Tree, Prefix, F)
for a default
formatting function F
. The default F
simply calls erl_prettypr:format/1
.
Transforms a syntax tree into an abstract comment. The lines of the comment
contain the text for Node
, as produced by the given Printer
function. Each
line of the comment is prefixed by the string Prefix
(this does not include
the initial "%
" character of the comment line).
Returns the names of variables occurring in a syntax tree, The result is a set of variable names represented by atoms. Macro names are not included.
Types
-type field() :: {atom(), {field_default(), field_type()}}.
-type field_default() :: none | syntaxTree().
-type field_type() :: none | syntaxTree().
-type fields() :: [field()].
-type key() :: attributes | errors | exports | functions | imports | module | records | warnings.
-type ordset(T) :: ordsets:ordset(T).
-type set(T) :: sets:set(T).
-type syntaxTree() :: erl_syntax:syntaxTree().
Functions
-spec analyze_application(syntaxTree()) -> appFunName() | arity().
Returns the name of a called function. The result is a representation of the
name of the applied function F/A
, if Node
represents a function application
"F(X_1, ..., X_A)
". If the function is not explicitly named (i.e., F
is
given by some expression), only the arity A
is returned.
The evaluation throws syntax_error
if Node
does not represent a well-formed
application expression.
See also: analyze_function_name/1
.
-spec analyze_attribute(syntaxTree()) -> preprocessor | {atom(), term()}.
Analyzes an attribute node. If Node
represents a preprocessor directive, the
atom preprocessor
is returned. Otherwise, if Node
represents a module
attribute "-Name...
", a tuple {Name, Info}
is returned, where Info
depends
on Name
, as follows:
{module, Info}
- whereInfo = analyze_module_attribute(Node)
.{export, Info}
- whereInfo = analyze_export_attribute(Node)
.{import, Info}
- whereInfo = analyze_import_attribute(Node)
.{file, Info}
- whereInfo = analyze_file_attribute(Node)
.{record, Info}
- whereInfo = analyze_record_attribute(Node)
.{Name, Info}
- where{Name, Info} = analyze_wild_attribute(Node)
.
The evaluation throws syntax_error
if Node
does not represent a well-formed
module attribute.
See also: analyze_export_attribute/1
, analyze_file_attribute/1
,
analyze_import_attribute/1
, analyze_module_attribute/1
,
analyze_record_attribute/1
, analyze_wild_attribute/1
.
-spec analyze_export_attribute(syntaxTree()) -> [functionName()].
Returns the list of function names declared by an export attribute. We do not guarantee that each name occurs at most once in the list. The order of listing is not defined.
The evaluation throws syntax_error
if Node
does not represent a well-formed
export attribute.
See also: analyze_attribute/1
.
-spec analyze_file_attribute(syntaxTree()) -> {string(), integer()}.
Returns the file name and line number of a file
attribute. The result is the
pair {File, Line}
if Node
represents "-file(File, Line).
".
The evaluation throws syntax_error
if Node
does not represent a well-formed
file
attribute.
See also: analyze_attribute/1
.
-spec analyze_form(syntaxTree()) -> {atom(), term()} | atom().
Analyzes a "source code form" node. If Node
is a "form" type (cf.
erl_syntax:is_form/1
), the returned value is a tuple {Type, Info}
where
Type
is the node type and Info
depends on Type
, as follows:
{attribute, Info}
- whereInfo = analyze_attribute(Node)
.{error_marker, Info}
- whereInfo = erl_syntax:error_marker_info(Node)
.{function, Info}
- whereInfo = analyze_function(Node)
.{warning_marker, Info}
- whereInfo = erl_syntax:warning_marker_info(Node)
.
For other types of forms, only the node type is returned.
The evaluation throws syntax_error
if Node
is not well-formed.
See also: analyze_attribute/1
, analyze_function/1
,
erl_syntax:error_marker_info/1
, erl_syntax:is_form/1
,
erl_syntax:warning_marker_info/1
.
-spec analyze_forms(erl_syntax:forms()) -> [info_pair()].
Analyzes a sequence of "program forms". The given Forms
may be a single syntax
tree of type form_list
, or a list of "program form" syntax trees. The returned
value is a list of pairs {Key, Info}
, where each value of Key
occurs at most
once in the list; the absence of a particular key indicates that there is no
well-defined value for that key.
Each entry in the resulting list contains the following corresponding information about the program forms:
{attributes, Attributes}
Attributes = [{atom(), term()}]
Attributes
is a list of pairs representing the names and corresponding values of all so-called "wild" attributes (as e.g. "-compile(...)
") occurring inForms
(cf.analyze_wild_attribute/1
). We do not guarantee that each name occurs at most once in the list. The order of listing is not defined.{errors, Errors}
Errors = [term()]
Errors
is the list of error descriptors of allerror_marker
nodes that occur inForms
. The order of listing is not defined.{exports, Exports}
Exports = [FunctionName]
FunctionName = atom() | {atom(), integer()} | {ModuleName, FunctionName}
ModuleName = atom()
Exports
is a list of representations of those function names that are listed by export declaration attributes inForms
(cf.analyze_export_attribute/1
). We do not guarantee that each name occurs at most once in the list. The order of listing is not defined.{functions, Functions}
Functions = [{atom(), integer()}]
Functions
is a list of the names of the functions that are defined inForms
(cf.analyze_function/1
). We do not guarantee that each name occurs at most once in the list. The order of listing is not defined.{imports, Imports}
Imports = [{Module, Names}]
Module = atom()
Names = [FunctionName]
FunctionName = atom() | {atom(), integer()} | {ModuleName, FunctionName}
ModuleName = atom()
Imports
is a list of pairs representing those module names and corresponding function names that are listed by import declaration attributes inForms
(cf.analyze_import_attribute/1
), where eachModule
occurs at most once inImports
. We do not guarantee that each name occurs at most once in the lists of function names. The order of listing is not defined.{module, ModuleName}
ModuleName = atom()
ModuleName
is the name declared by a module attribute inForms
. If no module name is defined inForms
, the result will contain no entry for themodule
key. If multiple module name declarations should occur, all but the first will be ignored.{records, Records}
Records = [{atom(), Fields}]
Fields = [{atom(), {Default, Type}}]
Default = none | syntaxTree()
Type = none | syntaxTree()
Records
is a list of pairs representing the names and corresponding field declarations of all record declaration attributes occurring inForms
. For fields declared without a default value, the corresponding value forDefault
is the atomnone
. Similarly, for fields declared without a type, the corresponding value forType
is the atomnone
(cf.analyze_record_attribute/1
). We do not guarantee that each record name occurs at most once in the list. The order of listing is not defined.{warnings, Warnings}
Warnings = [term()]
Warnings
is the list of error descriptors of allwarning_marker
nodes that occur inForms
. The order of listing is not defined.
The evaluation throws syntax_error
if an ill-formed Erlang construct is
encountered.
See also: analyze_export_attribute/1
, analyze_function/1
,
analyze_import_attribute/1
, analyze_record_attribute/1
,
analyze_wild_attribute/1
, erl_syntax:error_marker_info/1
,
erl_syntax:warning_marker_info/1
.
-spec analyze_function(syntaxTree()) -> {atom(), arity()}.
Returns the name and arity of a function definition. The result is a pair
{Name, A}
if Node
represents a function definition
"Name(P_1, ..., P_A) -> ...
".
The evaluation throws syntax_error
if Node
does not represent a well-formed
function definition.
-spec analyze_function_name(syntaxTree()) -> functionName().
Returns the function name represented by a syntax tree. If Node
represents a
function name, such as "foo/1
" or "bloggs:fred/2
", a uniform representation
of that name is returned. Different nestings of arity and module name qualifiers
in the syntax tree does not affect the result.
The evaluation throws syntax_error
if Node
does not represent a well-formed
function name.
-spec analyze_implicit_fun(syntaxTree()) -> functionName().
Returns the name of an implicit fun expression "fun F
". The result is a
representation of the function name F
. (Cf.
analyze_function_name/1
.)
The evaluation throws syntax_error
if Node
does not represent a well-formed
implicit fun.
See also: analyze_function_name/1
.
-spec analyze_import_attribute(syntaxTree()) -> {atom(), [functionName()]} | atom().
Returns the module name and (if present) list of function names declared by an
import attribute. The returned value is an atom Module
or a pair
{Module, Names}
, where Names
is a list of function names declared as
imported from the module named by Module
. We do not guarantee that each name
occurs at most once in Names
. The order of listing is not defined.
The evaluation throws syntax_error
if Node
does not represent a well-formed
import attribute.
See also: analyze_attribute/1
.
-spec analyze_module_attribute(syntaxTree()) -> atom() | {atom(), [atom()]}.
Returns the module name and possible parameters declared by a module attribute.
If the attribute is a plain module declaration such as -module(name)
, the
result is the module name. If the attribute is a parameterized module
declaration, the result is a tuple containing the module name and a list of the
parameter variable names.
The evaluation throws syntax_error
if Node
does not represent a well-formed
module attribute.
See also: analyze_attribute/1
.
-spec analyze_record_attribute(syntaxTree()) -> {atom(), fields()}.
Returns the name and the list of fields of a record declaration attribute. The
result is a pair {Name, Fields}
, if Node
represents
"-record(Name, {...}).
", where Fields
is a list of pairs
{Label, {Default, Type}}
for each field "Label
", "Label = Default
",
"Label :: Type
", or "Label = Default :: Type
" in the declaration, listed in
left-to-right order. If the field has no default-value declaration, the value
for Default
will be the atom none
. If the field has no type declaration, the
value for Type
will be the atom none
. We do not guarantee that each label
occurs at most once in the list.
The evaluation throws syntax_error
if Node
does not represent a well-formed
record declaration attribute.
See also: analyze_attribute/1
, analyze_record_field/1
.
-spec analyze_record_expr(syntaxTree()) -> {atom(), info()} | atom().
Returns the record name and field name/names of a record expression. If Node
has type record_expr
, record_index_expr
or record_access
, a pair
{Type, Info}
is returned, otherwise an atom Type
is returned. Type
is the
node type of Node
, and Info
depends on Type
, as follows:
record_expr
: -{atom(), [{atom(), Value}]}
record_access
: -{atom(), atom()}
record_index_expr
: -{atom(), atom()}
For a record_expr
node, Info
represents the record name and the list of
descriptors for the involved fields, listed in the order they appear. A field
descriptor is a pair {Label, Value}
, if Node
represents "Label = Value
".
For a record_access
node, Info
represents the record name and the field
name. For a record_index_expr
node, Info
represents the record name and the
name field name.
The evaluation throws syntax_error
if Node
represents a record expression
that is not well-formed.
See also: analyze_record_attribute/1
, analyze_record_field/1
.
-spec analyze_record_field(syntaxTree()) -> field().
Returns the label, value-expression, and type of a record field specifier. The
result is a pair {Label, {Default, Type}}
, if Node
represents "Label
",
"Label = Default
", "Label :: Type
", or "Label = Default :: Type
". If the
field has no value-expression, the value for Default
will be the atom none
.
If the field has no type, the value for Type
will be the atom none
.
The evaluation throws syntax_error
if Node
does not represent a well-formed
record field specifier.
See also: analyze_record_attribute/1
, analyze_record_expr/1
.
-spec analyze_type_application(syntaxTree()) -> typeName().
Returns the name of a used type. The result is a representation of the name of
the used pre-defined or local type N/A
, if Node
represents a local (user)
type application "N(T_1, ..., T_A)
", or a representation of the name of the
used remote type M:N/A
if Node
represents a remote user type application
"M:N(T_1, ..., T_A)
".
The evaluation throws syntax_error
if Node
does not represent a well-formed
(user) type application expression.
See also: analyze_type_name/1
.
-spec analyze_type_name(syntaxTree()) -> typeName().
Returns the type name represented by a syntax tree. If Node
represents a type
name, such as "foo/1
" or "bloggs:fred/2
", a uniform representation of that
name is returned.
The evaluation throws syntax_error
if Node
does not represent a well-formed
type name.
-spec analyze_wild_attribute(syntaxTree()) -> {atom(), term()}.
Returns the name and value of a "wild" attribute. The result is the pair
{Name, Value}
, if Node
represents "-Name(Value)
".
Note that no checking is done whether Name
is a reserved attribute name such
as module
or export
: it is assumed that the attribute is "wild".
The evaluation throws syntax_error
if Node
does not represent a well-formed
wild attribute.
See also: analyze_attribute/1
.
-spec annotate_bindings(syntaxTree()) -> syntaxTree().
Adds or updates annotations on nodes in a syntax tree. Equivalent to
annotate_bindings(Tree, Bindings)
where the top-level
environment Bindings
is taken from the annotation {env, Bindings}
on the
root node of Tree
. An exception is thrown if no such annotation should exist.
See also: annotate_bindings/2
.
-spec annotate_bindings(syntaxTree(), ordset(atom())) -> syntaxTree().
Adds or updates annotations on nodes in a syntax tree. Bindings
specifies the
set of bound variables in the environment of the top level node. The following
annotations are affected:
{env, Vars}
, representing the input environment of the subtree.{bound, Vars}
, representing the variables that are bound in the subtree.{free, Vars}
, representing the free variables in the subtree.
Bindings
and Vars
are ordered-set lists (cf. module ordsets
) of atoms
representing variable names.
See also: //stdlib/ordsets, annotate_bindings/1
.
-spec fold(fun((syntaxTree(), term()) -> term()), term(), syntaxTree()) -> term().
Folds a function over all nodes of a syntax tree. The result is the value of
Function(X1, Function(X2, ... Function(Xn, Start) ... ))
, where
[X1, X2, ..., Xn]
are the nodes of Tree
in a post-order traversal.
See also: fold_subtrees/3
, foldl_listlist/3
.
-spec fold_subtrees(fun((syntaxTree(), term()) -> term()), term(), syntaxTree()) -> term().
Folds a function over the immediate subtrees of a syntax tree. This is similar
to fold/3
, but only on the immediate subtrees of Tree
, in
left-to-right order; it does not include the root node of Tree
.
See also: fold/3
.
Like lists:foldl/3
, but over a list of lists.
See also: //stdlib/lists:foldl/3, fold/3
.
Creates a mapping from corresponding short names to full function names. Names
are represented by nested tuples of atoms and integers (cf.
analyze_function_name/1
). The result is a list
containing a pair {ShortName, Name}
for each element Name
in the given list,
where the corresponding ShortName
is the rightmost-innermost part of Name
.
The list thus represents a finite mapping from unqualified names to the
corresponding qualified names.
Note: the resulting list can contain more than one tuple {ShortName, Name}
for
the same ShortName
, possibly with different values for Name
, depending on
the given list.
See also: analyze_function_name/1
.
-spec is_fail_expr(syntaxTree()) -> boolean().
Returns true
if Tree
represents an expression which never terminates
normally. Note that the reverse does not apply. Currently, the detected cases
are calls to exit/1
, throw/1
, erlang:error/1
and
erlang:error/2
.
See also: //erts/erlang:error/1, //erts/erlang:error/2, //erts/erlang:exit/1, //erts/erlang:throw/1.
-spec limit(syntaxTree(), integer()) -> syntaxTree().
Equivalent to limit(Tree, Depth, Text)
using the text "..."
as
default replacement.
See also: limit/3
, erl_syntax:text/1
.
-spec limit(syntaxTree(), integer(), syntaxTree()) -> syntaxTree().
Limits a syntax tree to a specified depth. Replaces all non-leaf subtrees in
Tree
at the given Depth
by Node
. If Depth
is negative, the result is
always Node
, even if Tree
has no subtrees.
When a group of subtrees (as e.g., the argument list of an application
node)
is at the specified depth, and there are two or more subtrees in the group,
these will be collectively replaced by Node
even if they are leaf nodes.
Groups of subtrees that are above the specified depth will be limited in size,
as if each subsequent tree in the group were one level deeper than the previous.
E.g., if Tree
represents a list of integers
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
", the result of limit(Tree, 5)
will represent [1, 2, 3, 4, ...]
.
The resulting syntax tree is typically only useful for pretty-printing or similar visual formatting.
See also: limit/2
.
-spec map(fun((syntaxTree()) -> syntaxTree()), syntaxTree()) -> syntaxTree().
Applies a function to each node of a syntax tree. The result of each application replaces the corresponding original node. The order of traversal is bottom-up.
See also: map_subtrees/2
.
-spec map_subtrees(fun((syntaxTree()) -> syntaxTree()), syntaxTree()) -> syntaxTree().
Applies a function to each immediate subtree of a syntax tree. The result of each application replaces the corresponding original node.
See also: map/2
.
-spec mapfold(fun((syntaxTree(), term()) -> {syntaxTree(), term()}), term(), syntaxTree()) -> {syntaxTree(), term()}.
Combines map and fold in a single operation. This is similar to
map/2
, but also propagates an extra value from each application of
the Function
to the next, while doing a post-order traversal of the tree like
fold/3
. The value Start
is passed to the first function
application, and the final result is the result of the last application.
-spec mapfold_subtrees(fun((syntaxTree(), term()) -> {syntaxTree(), term()}), term(), syntaxTree()) -> {syntaxTree(), term()}.
Does a mapfold operation over the immediate subtrees of a syntax tree. This is
similar to mapfold/3
, but only on the immediate subtrees of
Tree
, in left-to-right order; it does not include the root node of Tree
.
See also: mapfold/3
.
-spec mapfoldl_listlist(fun((term(), term()) -> {term(), term()}), term(), [[term()]]) -> {[[term()]], term()}.
Like lists:mapfoldl/3
, but over a list of lists. The list of lists in the
result has the same structure as the given list of lists.
Returns an atom which is not already in the set Used
. This is equivalent to
new_variable_name(Function, Used)
, where Function
maps a given integer N
to the atom whose name consists of "V
" followed by
the numeral for N
.
See also: new_variable_name/2
.
Returns a user-named atom which is not already in the set Used
. The atom is
generated by applying the given Function
to a generated integer. Integers are
generated using an algorithm which tries to keep the names randomly distributed
within a reasonably small range relative to the number of elements in the set.
This function uses the module rand
to generate new keys. The seed it uses may
be initialized by calling rand:seed/1
or rand:seed/2
before this function is
first called.
See also: //stdlib/random, //stdlib/sets,
new_variable_name/1
.
Like new_variable_name/1
, but generates a list of N
new names.
See also: new_variable_name/1
.
Like new_variable_name/2
, but generates a list of N
new names.
See also: new_variable_name/2
.
-spec strip_comments(syntaxTree()) -> syntaxTree().
Removes all comments from all nodes of a syntax tree. All other attributes (such as position information) remain unchanged. Standalone comments in form lists are removed; any other standalone comments are changed into null-comments (no text, no indentation).
-spec to_comment(syntaxTree()) -> syntaxTree().
Equivalent to to_comment(Tree, "% ").
-spec to_comment(syntaxTree(), string()) -> syntaxTree().
Equivalent to to_comment(Tree, Prefix, F)
for a default
formatting function F
. The default F
simply calls erl_prettypr:format/1
.
See also: to_comment/3
, erl_prettypr:format/1
.
-spec to_comment(syntaxTree(), string(), fun((syntaxTree()) -> string())) -> syntaxTree().
Transforms a syntax tree into an abstract comment. The lines of the comment
contain the text for Node
, as produced by the given Printer
function. Each
line of the comment is prefixed by the string Prefix
(this does not include
the initial "%
" character of the comment line).
For example, the result of
to_comment(erl_syntax:abstract([a,b,c]))
represents
%% [a,b,c]
(cf. to_comment/1
).
Note: the text returned by the formatting function will be split automatically into separate comment lines at each line break. No extra work is needed.
See also: to_comment/1
, to_comment/2
.
-spec variables(syntaxTree()) -> set(atom()).
Returns the names of variables occurring in a syntax tree, The result is a set of variable names represented by atoms. Macro names are not included.
See also: //stdlib/sets.