erl_syntax

模块

erl_syntax

模块摘要

抽象的Erlang语法树。

描述

摘要Erlang语法树。

该模块定义了一种抽象数据类型，用于将Erlang源代码表示为语法树，以一种与Erlang标准库解析器模块创建的数据结构向后兼容的方式erl_parse（通常称为“解析树”，这是一种一个用词不当）。这意味着所有erl_parse树都是有效的抽象语法树，但反过来却不是这样：抽象语法树通常不能用作期望erl_parse树的函数的输入。然而，只要一个抽象语法树表示一个正确的Erlang程序，该函数revert/1应该能够将其转换为相应的erl_parse表示。

首次使用者推荐的起点是syntaxTree()数据类型和函数的文档type/1。

注：

这个模块处理句法实体的组成和分解（与语义实体相对）。其目的是隐藏对用于表示这些实体的数据结构的所有直接引用。除少数例外情况外，本模块中的功能不会对其输入执行语义解释，并且通常假定用户传递类型正确的参数 - 如果未完成，则不会定义效果。

除erl_parse()数据结构外，抽象语法树的内部表示如有更改，恕不另行通知，不应在本模块之外记录。此外，我们不保证抽象语法树如何表示或不表示，除了以下例外：没有语法树由单个原子表示，例如none由列表构造函数[X | Y]或空列表表示[]。在编写对语法树进行操作的函数时，这可以依赖。

数据类型

encoding() = utf8 | unicode | latin1erl_parse() =erl_parse:abstract_clause()|erl_parse:abstract_expr()|erl_parse:abstract_form()|erl_parse:abstract_type()|erl_parse:form_info()| {bin_element, term(), term(), term(), term()}forms() =syntaxTree()| [syntaxTree()]guard() = none |syntaxTree()| [syntaxTree()] | [[syntaxTree()]]padding() = none | integer()syntaxTree()

抽象语法树。在erl_parse()“解析树”表示是的真子集syntaxTree()表示。

每个抽象语法树节点都有一个由函数给出的类型type/1。每个节点也有相关的属性 ; get_attrs/1详情请参阅。功能make_tree/2和subtrees/1是抽象语法树通用构造/分解功能。功能abstract/1和concrete/1不断的Erlang术语及其语法之间转换。该语法树节点集可通过该tree/2函数进行扩展。

语法树可以转换为erl_parse()表示与revert/1功能。

syntaxTreeAttributes()

这是语法树节点属性的抽象表示；看功能get_attrs/1。

出口

abstract(T::term()) ->syntaxTree()

返回对应于Erlang项的语法树。Term必须是一个字面术语，即可以表示为源代码字面量的字面术语。因此，它可能不包含进程标识符，端口，引用，二进制或函数值作为子项。该功能可识别可打印的字符串，以获得紧凑和可读的表示。badarg如果Term不是一个字面的术语，评估失败的原因。

另见： concrete/1，is_literal/1。

add_ann(A::term(), Node::syntaxTree()) ->syntaxTree()

将该术语追加Annotation到用户注释列表中Node。

注：这相当于set_ann(Node, [Annotation | get_ann(Node)])，但可能更有效率。

另见： get_ann/1，set_ann/2。

add_postcomments(Cs::[syntaxTree()], Node::syntaxTree()) ->syntaxTree()

附加Comments到后续评论Node。

注意：这相当于set_postcomments(Node, get_postcomments(Node) ++ Comments)，但可能更有效。

另请参阅： add_precomments/2，comment/2，get_postcomments/1，join_comments/2，set_postcomments/2。

add_precomments(Cs::[syntaxTree()], Node::syntaxTree()) ->syntaxTree()

附加Comments到的预评论Node。

注意：这相当于set_precomments(Node, get_precomments(Node) ++ Comments)，但可能更有效。

另请参阅： add_postcomments/2，comment/2，get_precomments/1，join_comments/2，set_precomments/2。

annotated_type(Name::syntaxTree(), Type::syntaxTree()) ->syntaxTree()

创建一个抽象的带注释的类型表达式。结果代表“ Name :: Type”。

另见： annotated_type_body/1，annotated_type_name/1。

annotated_type_body(Node::syntaxTree()) ->syntaxTree()

返回annotated_type节点的类型子树。

另见： annotated_type/2。

annotated_type_name(Node::syntaxTree()) ->syntaxTree()

返回annotated_type节点的名称子树。

另见： annotated_type/2。

application(Operator::syntaxTree(), Arguments::[syntaxTree()]) ->syntaxTree()

创建一个抽象函数应用程序表达式。如果Arguments是[A1, ..., An]，结果代表“ Operator(A1, ..., An)”。

另请参阅： application/3，application_arguments/1，application_operator/1。

application(Module::none |syntaxTree(), Name::syntaxTree(), Arguments::[syntaxTree()]) ->syntaxTree()

创建一个抽象函数应用程序表达式。如果Module是none，这是调用等效的application(Function, Arguments)，否则就相当于application(module_qualifier(Module, Function), Arguments)。

（这是一个实用功能。）

另见： application/2，module_qualifier/2。

application_arguments(Node::syntaxTree()) -> [syntaxTree()]

返回参数子树的列表。application节点。

另见： application/2。

application_operator(Node::syntaxTree()) ->syntaxTree()

返回application节点的运算符子树。

注意：如果Node代表“ M:F(...)”，则结果是代表“ M:F” 的子树。

另见： application/2，module_qualifier/2。

arity_qualifier(Body::syntaxTree(), Arity::syntaxTree()) ->syntaxTree()

创建一个抽象的arity限定符。结果代表“ Body/Arity”。

另见： arity_qualifier_argument/1，arity_qualifier_body/1。

arity_qualifier_argument(Node::syntaxTree()) ->syntaxTree()

返回arity_qualifier节点的参数（arity）子树。

另见： arity_qualifier/2。

arity_qualifier_body(Node::syntaxTree()) ->syntaxTree()

返回arity_qualifier节点的主体子树。

另见： arity_qualifier/2。

atom(Name::atom() | string()) ->syntaxTree()

创建一个抽象原子文字。原子的打印名称是由Name表示的字符序列。

另请参阅： atom_literal/1，atom_literal/2，atom_name/1，atom_value/1，is_atom/2。

atom_literal(Node::syntaxTree()) -> string()

返回atom节点表示的字符串。如有必要，这包括周围的单引号字符。超过255的字符将被逃脱。

请注意，例如，atom("x\ny")表示x\ny'',x \ 12y'，x\012y'' andx \ ^ Jy \'中的任何一个和全部的结果。见string/1。

另见： atom/1，string/1。

atom_literal(Node, X2) -> term()

返回atom节点表示的字符串。如有必要，这包括周围的单引号字符。根据编码，超过255的字符将被转义（latin1）或复制为is（utf8）。

另请参阅： atom/1，atom_literal/1，string/1。

atom_name(Node::syntaxTree()) -> string()

返回atom节点。

另见： atom/1。

atom_value(Node::syntaxTree()) -> atom()

返回由atom节点。

另见： atom/1。

attribute(Name::syntaxTree()) ->syntaxTree()

相当于attribute(Name, none)。

attribute(Name::syntaxTree(), Args::none | [syntaxTree()]) ->syntaxTree()

创建一个抽象程序属性。如果Arguments是[A1, ..., An]，结果代表“ -Name(A1, ..., An).”。否则，如果Arguments是none，结果代表“ -Name.”。后一种形式可以表示预处理器指令，例如“ -endif.”。属性是源代码形式。

注意：预处理器宏定义指令“ -define(Name, Body).”对语法形式Body（作为一系列令牌）的要求相对较少。该text节点类型可以被用于Body为不是正常的Erlang构造。

另请参阅： attribute/1，attribute_arguments/1，attribute_name/1，is_form/1，text/1。

attribute_arguments(Node::syntaxTree()) -> none | [syntaxTree()]

返回attribute节点的参数子树列表（如果有的话）。如果Node代表“ -Name.”，结果是none。否则，如果Node表示“ -Name(E1, ..., En).”，[E1, ..., E1]则返回。

另见： attribute/1。

attribute_name(Node::syntaxTree()) ->syntaxTree()

返回attribute节点的名称子树。

另见： attribute/1。

binary(List::[syntaxTree()]) ->syntaxTree()

创建一个抽象的二进制对象模板。如果Fields是[F1, ..., Fn]，结果代表“ <<F1, ..., Fn>>”。

另见： binary_field/2，binary_fields/1。

binary_comp(Template::syntaxTree(), Body::[syntaxTree()]) ->syntaxTree()

创建一个抽象的二进制理解。如果Body是[E1, ..., En]，结果代表“ <<Template || E1, ..., En>>”。

另请参阅： binary_comp_body/1，binary_comp_template/1，generator/2。

binary_comp_body(Node::syntaxTree()) -> [syntaxTree()]

返回binary_comp节点。

另见： binary_comp/2。

binary_comp_template(Node::syntaxTree()) ->syntaxTree()

返回binary_comp节点的模板子树。

另见： binary_comp/2。

binary_field(Body::syntaxTree()) ->syntaxTree()

相当于binary_field(Body, [])。

binary_field(Body::syntaxTree(), Types::[syntaxTree()]) ->syntaxTree()

创建一个抽象二进制模板字段。如果Types是空列表，则结果仅表示“ Body”，否则，如果Types是[T1, ..., Tn]，结果表示“ Body/T1-...-Tn”。

另请参阅： binary/1，binary_field/1，binary_field/3，binary_field_body/1，binary_field_size/1，binary_field_types/1。

binary_field(Body::syntaxTree(), Size::none |syntaxTree(), Types::[syntaxTree()]) ->syntaxTree()

创建一个抽象二进制模板字段。如果Size是none，则相当于“ binary_field(Body, Types)”，否则相当于“ binary_field(size_qualifier(Body, Size), Types)”。

（这是一个实用函数。）

另请参阅： binary/1，binary_field/2，size_qualifier/2。

binary_field_body(Node::syntaxTree()) ->syntaxTree()

返回binary_field的正文子树binary_field。

另见： binary_field/2。

binary_field_size(Node::syntaxTree()) -> none |syntaxTree()

返回binary_field节点的大小说明符子树，如果有的话。如果Node代表“ Body:Size”或“ Body:Size/T1, ..., Tn”，结果是Size，否则返回none。

（这是一个实用函数。）

另见： binary_field/2，binary_field/3。

binary_field_types(Node::syntaxTree()) -> [syntaxTree()]

返回binary_field节点的类型说明符子树的列表。如果Node代表“ .../T1, ..., Tn”，结果是[T1, ..., Tn]，否则结果是空的列表。

另见： binary_field/2。

binary_fields(Node::syntaxTree()) -> [syntaxTree()]

返回binary节点的字段子树列表。

另见： binary/1，binary_field/2。

binary_generator(Pattern::syntaxTree(), Body::syntaxTree()) ->syntaxTree()

创建一个抽象的binary_generator。结果代表“ Pattern <- Body”。

另请参阅： binary_comp/2，binary_generator_body/1，binary_generator_pattern/1，list_comp/2。

binary_generator_body(Node::syntaxTree()) ->syntaxTree()

返回generator节点的主体子树。

另见： binary_generator/2。

binary_generator_pattern(Node::syntaxTree()) ->syntaxTree()

对象的模式子树返回generator节点。

另见： binary_generator/2。

bitstring_type(M::syntaxTree(), N::syntaxTree()) ->syntaxTree()

创建一个抽象的位串类型。结果代表“ <<_:M, _:_*N>>”。

另见： bitstring_type_m/1，bitstring_type_n/1。

bitstring_type_m(Node::syntaxTree()) ->syntaxTree()

返回起始位的数量，M，一个的bitstring_type节点。

另见： bitstring_type/2。

bitstring_type_n(Node::syntaxTree()) ->syntaxTree()

返回N段大小，bitstring_type节点。

另见： bitstring_type/2。

block_expr(Body::[syntaxTree()]) ->syntaxTree()

创建一个抽象块表达式。如果Body是[B1, ..., Bn]，结果代表“ begin B1, ..., Bn end”。

另见： block_expr_body/1。

block_expr_body(Node::syntaxTree()) -> [syntaxTree()]

返回block_expr节点。

另见： block_expr/1。

case_expr(Argument::syntaxTree(), Clauses::[syntaxTree()]) ->syntaxTree()

创建一个抽象的case-expression。如果Clauses是[C1, ..., Cn]，结果代表“ case Argument of C1; ...; Cn end”。更确切地说，如果每个Ci代表“ (Pi) Gi -> Bi”，那么结果代表“ case Argument of P1 G1 -> B1; ...; Pn Gn -> Bn end”。

另请参阅： case_expr_argument/1，case_expr_clauses/1，clause/3，cond_expr/1，if_expr/1。

case_expr_argument(Node::syntaxTree()) ->syntaxTree()

返回case_expr节点的参数子树。

另见： case_expr/2。

case_expr_clauses(Node::syntaxTree()) -> [syntaxTree()]

返回case_expr节点的子句子树列表。

另见： case_expr/2。

catch_expr(Expr::syntaxTree()) ->syntaxTree()

创建一个抽象的catch表达式。结果代表“ catch Expr”。

另见： catch_expr_body/1。

catch_expr_body(Node::syntaxTree()) ->syntaxTree()

返回catch_expr节点的主体子树。

另见： catch_expr/1。

char(Char::char()) ->syntaxTree()

创建一个抽象字符文字。结果代表“ $Name”，其中Name对应于Value。

注意：与特定字符值对应的文字不是唯一定义的。例如，a可以将字符“ ”写成“ $a”和“ $\141”，并且可以将制表符写为“ $\11”，“ $\011”或“ $\t”。

另请参阅： char_literal/1，char_literal/2，char_value/1，is_char/2。

char_literal(Node::syntaxTree()) -> nonempty_string()

返回char节点表示的文字字符串。这包括领先的“ $”字符。超过255的字符将被逃脱。

另见： char/1。

char_literal(Node::syntaxTree(), X2::encoding()) -> nonempty_string()

返回char节点表示的文字字符串。这包括领先的“ $”字符。根据编码，超过255的字符将被转义（latin1）或复制为is（utf8）。

另见： char/1。

char_value(Node::syntaxTree()) -> char()

返回char节点表示的值。

另见： char/1。

class_qualifier(Class::syntaxTree(), Body::syntaxTree()) ->syntaxTree()

创建一个抽象类限定符。结果代表“ Class:Body”。

另请参阅： class_qualifier_argument/1，class_qualifier_body/1，try_expr/4。

class_qualifier_argument(Node::syntaxTree()) ->syntaxTree()

返回class_qualifier节点的参数（类）子树。

另见： class_qualifier/2。

class_qualifier_body(Node::syntaxTree()) ->syntaxTree()

返回class_qualifier节点的主体子树。

另见： class_qualifier/2。

clause(Guard::guard(), Body::[syntaxTree()]) ->syntaxTree()

相当于clause([], Guard, Body)。

clause(Patterns::[syntaxTree()], Guard::guard(), Body::[syntaxTree()]) ->syntaxTree()

创建一个抽象子句。如果Patterns是[P1, ..., Pn]和Body是[B1, ..., Bm]，那么如果Guard是none，结果表示“ (P1, ..., Pn) -> B1, ..., Bm”，否则，除非Guard是一个列表，结果表示“ (P1, ..., Pn) when Guard -> B1, ..., Bm”。

为了简单起见，Guard论证也可以是以下任何一种：

一个空的列表[]。这相当于传球none。

[E1, ..., Ej]语法树的非空列表。这相当于传球conjunction([E1, ..., Ej])。

语法树列表的非空列表，[[E1_1, ..., E1_k1], ..., [Ej_1, ..., Ej_kj]]相当于传递disjunction([conjunction([E1_1, ..., E1_k1]), ..., conjunction([Ej_1, ..., Ej_kj])])。

另请参阅： clause/2，clause_body/1，clause_guard/1，clause_patterns/1。

clause_body(Node::syntaxTree()) -> [syntaxTree()]

返回clause节点的正文子树列表。

另见： clause/3。

clause_guard(Node::syntaxTree()) -> none |syntaxTree()

返回clause节点的防护子树（如果有的话）。如果Node代表“ (P1, ..., Pn) when Guard -> B1, ..., Bm”，则返回Guard。否则，结果是none。

另见： clause/3。

clause_patterns(Node::syntaxTree()) -> [syntaxTree()]

返回模式子树的列表。clause节点。

另见： clause/3。

comment(Strings::[string()]) ->syntaxTree()

相当于comment(none, Strings)。

comment(Pad::padding(), Strings::[string()]) ->syntaxTree()

用给定的填充和文本创建抽象注释。如果Strings是（可能为空）列表["Txt1", ..., "TxtN"]，则结果代表源代码文本

%Txt1
...
%TxtN

Padding说明在同一行（如果有）的源代码水平分隔它的注释左边的空字符位置的数量。如果Padding是none，则使用默认的正数。如果Padding是小于1的整数，则不应该有分隔空间。评论本身被视为源程序表单。

另见： comment/1，is_form/1。

comment_padding(Node::syntaxTree()) ->padding()

返回注释之前的填充量，或none。后者意味着可以使用默认的填充。

另见： comment/2。

comment_text(Node::syntaxTree()) -> [string()]

返回抽象注释的文本行。

另见： comment/2。

compact_list(Node::syntaxTree()) ->syntaxTree()

为抽象列表框架生成最紧凑的表单。结果要么代表“ [E1, ..., En | Tail]”，其中Tail不是列表框架，或者简单地“ [E1, ..., En]”。Node表示列表框架的子树上的注释可能会丢失，但注释将传播到结果。Node如果Node不代表列表框架，则返回自身。

另见： list/2，normalize_list/1。

concrete(Node::syntaxTree()) -> term()

返回由语法树表示的Erlang项。badarg如果Node不代表文字，评估将失败。

注意：目前，具有具体表示的语法树集合大于可以使用该函数构建的树集合abstract/1。一个抽象字符将被整理为一个整数，而abstract/1目前还不会产生任何输入的抽象字符。（使用该char/1函数显式创建一个抽象字符。）

注意：arity_qualifier节点被识别。当涉及到野性属性时，这将遵循Erlang解析器：{F,A}和F/A都被识别，这使得可以将野性属性转换为可识别的属性，而同时又无法使用编译文件新版Erlang编译器的新语法。

另请参阅： abstract/1，char/1，is_literal/1。

cond_expr(Clauses::[syntaxTree()]) ->syntaxTree()

创建一个抽象的cond-expression。如果Clauses是[C1, ..., Cn]，结果代表“ cond C1; ...; Cn end”。更确切地说，如果每个Ci代表“ () Ei -> Bi”，那么结果代表“ cond E1 -> B1; ...; En -> Bn end”。

另请参阅： case_expr/2，clause/3，cond_expr_clauses/1。

cond_expr_clauses(Node::syntaxTree()) -> [syntaxTree()]

对象的子句子树列表。cond_expr节点。

另见： cond_expr/1。

conjunction(Tests::[syntaxTree()]) ->syntaxTree()

创建一个抽象连词。如果List是[E1, ..., En]，结果代表“ E1, ..., En”。

另见： conjunction_body/1，disjunction/1。

conjunction_body(Node::syntaxTree()) -> [syntaxTree()]

返回conjunction节点。

另见： conjunction/1。

cons(Head::syntaxTree(), Tail::syntaxTree()) ->syntaxTree()

“Optimising”列表骨架缺陷操作。创建一个抽象列表框架，其第一个元素是Head，其尾部对应于Tail。这与类似list([Head], Tail)，除了Tail可能不是none，并且结果不一定完全代表“ [Head | Tail]”，但可能取决于Tail子树。例如，如果Tail表示[X, Y]，结果可能代表“ [Head, X, Y]”，而不是“ [Head | [X, Y]]”。Tail如果Tail表示列表框架，注释本身可能会丢失，但注释Tail会传播到结果。

另请参阅： list/2，list_head/1，list_tail/1。

constrained_function_type(FunctionType::syntaxTree(), FunctionConstraint::[syntaxTree()]) ->syntaxTree()

创建一个抽象约束函数类型。如果FunctionConstraint是[C1, ..., Cn]，结果代表“ FunctionType when C1, ...Cn”。

另见： constrained_function_type_argument/1，constrained_function_type_body/1。

constrained_function_type_argument(Node::syntaxTree()) ->syntaxTree()

返回函数约束子树。constrained_function_type节点。

另见： constrained_function_type/2。

constrained_function_type_body(Node::syntaxTree()) ->syntaxTree()

类的函数类型子树。constrained_function_type节点。

另见： constrained_function_type/2。

constraint(Name::syntaxTree(), Types::[syntaxTree()]) ->syntaxTree()

创建一个抽象（子类型）约束。结果代表“ Name :: Type”。

另见： constraint_argument/1，constraint_body/1。

constraint_argument(Node::syntaxTree()) ->syntaxTree()

返回constraint节点的名称子树。

另见： constraint/2。

constraint_body(Node::syntaxTree()) -> [syntaxTree()]

返回constraint节点的类型子树。

另见： constraint/2。

copy_ann(Source::syntaxTree(), Target::syntaxTree()) ->syntaxTree()

副本用户注释从列表中Source来Target。

注意：这相当于set_ann(Target, get_ann(Source))，但可能更有效。

另见： get_ann/1，set_ann/2。

copy_attrs(S::syntaxTree(), T::syntaxTree()) ->syntaxTree()

从复制的属性Source来Target。

注意：这相当于set_attrs(Target, get_attrs(Source))，但可能更有效。

另见： get_attrs/1，set_attrs/2。

copy_comments(Source::syntaxTree(), Target::syntaxTree()) ->syntaxTree()

从前Source到后复制预评论和后评论Target。

注意：这相当于set_postcomments(set_precomments(Target, get_precomments(Source)), get_postcomments(Source))，但可能更有效。

另请参阅： comment/2，get_postcomments/1，get_precomments/1，set_postcomments/2，set_precomments/2。

copy_pos(Source::syntaxTree(), Target::syntaxTree()) ->syntaxTree()

从位置信息复制Source到Target。

这相当于set_pos(Target, get_pos(Source))，但可能更有效。

另见： get_pos/1，set_pos/2。

data(Tree::syntaxTree()) -> term()

仅限特殊用途。返回语法树节点的关联数据。badarg如果is_tree(Node)不收益，评估失败的原因true。

另见： tree/2。

disjunction(Tests::[syntaxTree()]) ->syntaxTree()

创建抽象析取。如果List是[E1, ..., En]，结果代表“ E1; ...; En”。

另见： conjunction/1，disjunction_body/1。

disjunction_body(Node::syntaxTree()) -> [syntaxTree()]

返回disjunction节点。

另见： disjunction/1。

eof_marker() ->syntaxTree()

创建一个抽象的文件结束标记。这表示读取源代码表单序列时的输入结束。文件结束标记本身被认为是源代码形式（即，它出现的任何顺序中的最后一个）。它没有定义的词汇形式。

注意：这只是为了与现有解析器和工具的向后兼容性而保留。

另请参阅： error_marker/1，is_form/1，warning_marker/1。

error_marker(Error::term()) ->syntaxTree()

创建一个抽象的错误标记。结果表示源代码中出现错误，并给出了相关的Erlang I / O ErrorInfo结构Error（详见模块io(3)）。错误标记被视为源代码形式，但没有定义的词法形式。

注意：这仅支持与现有解析器和工具的向后兼容性。

另请参阅： eof_marker/0，error_marker_info/1，is_form/1，warning_marker/1。

error_marker_info(Node::syntaxTree()) -> term()

返回error_marker节点的ErrorInfo结构。

另见： error_marker/1。

flatten_form_list(Node::syntaxTree()) ->syntaxTree()

展平form_list节点的子列表。返回Node所有类型form_list递归扩展的子树，产生一个单一的“扁平”抽象表单序列。

另见： form_list/1。

float(Value::float()) ->syntaxTree()

创建一个抽象浮点文字。词法表示是十进制浮点数字Value。

另见： float_literal/1，float_value/1。

float_literal(Node::syntaxTree()) -> string()

返回由float节点。

另见： float/1。

float_value(Node::syntaxTree()) -> float()

返回float节点表示的值。请注意，通常不应将浮点值进行相等比较。

另见： float/1。

form_list(Forms::[syntaxTree()]) ->syntaxTree()

创建一个“source code forms”的抽象序列。如果Forms是[F1, ..., Fn]，那么每个Fi表单都是一个表单（请参阅is_form/1结果表示

F1
...
Fn

其中Fi由一个或多个换行分离。类型的节点form_list本身被视为源代码形式; 见flatten_form_list/1。

注意：这只是将源代码表单分组为单个语法树的一种方式，通常是为了形成一个Erlang模块定义。

另请参阅： flatten_form_list/1，form_list_elements/1，is_form/1。

form_list_elements(Node::syntaxTree()) -> [syntaxTree()]

对象的子节点列表。form_list节点。

另见： form_list/1。

fun_expr(Clauses::[syntaxTree()]) ->syntaxTree()

创建一个抽象的fun-expression。如果Clauses是[C1, ..., Cn]，结果代表“ fun C1; ...; Cn end”。更确切地说，如果每个Ci代表“ (Pi1, ..., Pim) Gi -> Bi”，那么结果代表“ fun (P11, ..., P1m) G1 -> B1; ...; (Pn1, ..., Pnm) Gn -> Bn end”。

另见： fun_expr_arity/1，fun_expr_clauses/1。

fun_expr_arity(Node::syntaxTree()) -> arity()

返回fun_expr节点的arity 。结果是fun-expression的第一个子句中的参数模式的数量; 后续条款被忽略。

如果一个异常被抛出fun_expr_clauses(Node)返回一个空列表，或者如果该列表的第一个元素是不是语法树C类型的clause这样clause_patterns(C)一个非空列表。

另请参阅： clause/3，clause_patterns/1，fun_expr/1，fun_expr_clauses/1。

fun_expr_clauses(Node::syntaxTree()) -> [syntaxTree()]

对象的子句子树列表。fun_expr节点。

另见： fun_expr/1。

fun_type() ->syntaxTree()

创建任何类型的抽象乐趣。结果代表“fun()“

function(Name::syntaxTree(), Clauses::[syntaxTree()]) ->syntaxTree()

创建一个抽象函数定义。如果Clauses是[C1, ..., Cn]，结果代表“ Name C1; ...; Name Cn.”。更确切地说，如果每个Ci代表“ (Pi1, ..., Pim) Gi -> Bi”，那么结果代表“ Name(P11, ..., P1m) G1 -> B1; ...; Name(Pn1, ..., Pnm) Gn -> Bn.”。函数定义是源代码形式。

另请参阅： function_arity/1，function_clauses/1，function_name/1，is_form/1。

function_arity(Node::syntaxTree()) -> arity()

返回function节点的arity 。结果是该函数的第一个子句中的参数模式的数量; 后续条款被忽略。

如果一个异常被抛出function_clauses(Node)返回一个空列表，或者如果该列表的第一个元素是不是语法树C类型的clause这样clause_patterns(C)一个非空列表。

另请参阅： clause/3，clause_patterns/1，function/2，function_clauses/1。

function_clauses(Node::syntaxTree()) -> [syntaxTree()]

返回function节点的子句子树列表。

另见： function/2。

function_name(Node::syntaxTree()) ->syntaxTree()

返回function节点的名称子树。

另见： function/2。

function_type(Type) -> term()

相当于function_type(any_arity, Type)。

function_type(Arguments::any_arity |syntaxTree(), Return::syntaxTree()) ->syntaxTree()

创建一个抽象函数类型。如果Arguments是[T1, ..., Tn]，那么如果它出现在函数规范中，则结果代表“ (T1, ...Tn) -> Return”; 否则它代表“ fun((T1, ...Tn) -> Return)”。如果Arguments是any_arity，它代表“ fun((...) -> Return)”。

请注意，erl_parse表示与“ FunctionType”和“ fun(FunctionType)” 相同。

另见： function_type_arguments/1，function_type_return/1。

function_type_arguments(Node::syntaxTree()) -> any_arity | [syntaxTree()]

返回function_type节点的参数类型子树。如果Node代表“ fun((...) -> Return)”，any_arity则返回; 否则，如果Node代表“ (T1, ...Tn) -> Return”或“ fun((T1, ...Tn) -> Return)”，[T1, ..., Tn]则返回。

另见： function_type/1，function_type/2。

function_type_return(Node::syntaxTree()) ->syntaxTree()

返回function_type节点的返回类型子树。

另见： function_type/1，function_type/2。

generator(Pattern::syntaxTree(), Body::syntaxTree()) ->syntaxTree()

创建一个抽象生成器。结果代表“ Pattern <- Body”。

另请参阅： binary_comp/2，generator_body/1，generator_pattern/1，list_comp/2。

generator_body(Node::syntaxTree()) ->syntaxTree()

返回generator节点的主体子树。

另见： generator/2。

generator_pattern(Node::syntaxTree()) ->syntaxTree()

返回generator节点的模式子树。

另见： generator/2。

get_ann(Tree::syntaxTree()) -> [term()]

返回与语法树节点关联的用户注释列表。对于新创建的节点，这是空列表。注释可以是任何术语。

另见： get_attrs/1，set_ann/2。

get_attrs(Tree::syntaxTree()) ->syntaxTreeAttributes()

返回与语法树节点关联的属性的表示。属性是可以附加到节点的所有额外信息。目前，这包括位置信息，源代码注释和用户注释。此功能的结果不能直接检查; 只附加到另一个节点（请参阅set_attrs/2）。

为了访问单个属性，参见get_pos/1，get_ann/1，get_precomments/1和get_postcomments/1。

另请参阅： get_ann/1，get_pos/1，get_postcomments/1，get_precomments/1，set_attrs/2。

get_pos(Tree::syntaxTree()) -> term()

返回与之相关的位置信息Node。这通常是一个非负整数（表示源代码行号），但可以是任何术语。默认情况下，所有新的树节点都将其关联的位置信息设置为整数零。

另见： get_attrs/1，set_pos/2。

get_postcomments(Tree::syntaxTree()) -> [syntaxTree()]

返回节点的相关后期评论。这是一个可能为空的抽象评论列表，按照自上而下的文本顺序排列。代码格式化后，后续评论通常显示在节点的右侧和/或下方。例如：

{foo, X, Y}     % Post-comment of tuple

如果可能的话，注释应该移过同一行上的任何后续分隔符，而不是将分隔符放在下一行。例如：

foo([X | Xs], Y) ->
    foo(Xs, bar(X)     % Post-comment of 'bar(X)' node
 ...

（评论被移到最右边的“ )”和“ ;”）。

另请参阅： comment/2，get_attrs/1，get_precomments/1，set_postcomments/2。

get_precomments(Tree::syntaxTree()) -> [syntaxTree()]

返回节点的相关预评论。这是一个可能为空的抽象评论列表，按照自上而下的文本顺序排列。代码格式化后，预注释通常直接显示在节点上方。例如：

% Pre-comment of function
foo(X) -> {bar, X}.

如果可能的话，注释应该在同一行上的任何前面的分隔符之前移动。例如：

foo([X | Xs]) ->
    % Pre-comment of 'bar(X)' node
    [bar(X) | foo(Xs)];
...

（评论在“ [” 之前移动的地方）。

另请参阅： comment/2，get_attrs/1，get_postcomments/1，set_precomments/2。

has_comments(Tree::syntaxTree()) -> boolean()

产量false如果节点没有相关评论，以及true其他。

注意：这相当于(get_precomments(Node) == []) and (get_postcomments(Node) == [])，但可能更有效。

另请参阅： get_postcomments/1，get_precomments/1，remove_comments/1。

if_expr(Clauses::[syntaxTree()]) ->syntaxTree()

创建一个抽象的if表达式。如果Clauses是[C1, ..., Cn]，结果代表“ if C1; ...; Cn end”。更确切地说，如果每个Ci代表“ () Gi -> Bi”，那么结果代表“ if G1 -> B1; ...; Gn -> Bn end”。

另请参阅： case_expr/2，clause/3，if_expr_clauses/1。

if_expr_clauses(Node::syntaxTree()) -> [syntaxTree()]

返回if_expr节点的子句子树的列表。

另见： if_expr/1。

implicit_fun(Name::syntaxTree()) ->syntaxTree()

创建一个抽象的“隐含的乐趣”表达式。结果代表“ fun Name”。Name应该代表F/A或者M:F/A

另请参阅： arity_qualifier/2，implicit_fun/2，implicit_fun/3，implicit_fun_name/1，module_qualifier/2。

implicit_fun(Name::syntaxTree(), Arity::none |syntaxTree()) ->syntaxTree()

创建一个抽象的“隐含的乐趣”表达式。如果Arity是none，这相当于implicit_fun(Name)，否则相当于implicit_fun(arity_qualifier(Name, Arity))。

（这是一个实用函数。）

另见： implicit_fun/1，implicit_fun/3。

implicit_fun(Module::none |syntaxTree(), Name::syntaxTree(), Arity::syntaxTree()) ->syntaxTree()

创建抽象模块限定的“implicit fun”表达式。如果Module是none，这相当于implicit_fun(Name, Arity)，否则相当于implicit_fun(module_qualifier(Module, arity_qualifier(Name, Arity))。

（这是一个实用函数。）

另见： implicit_fun/1，implicit_fun/2。

implicit_fun_name(Node::syntaxTree()) ->syntaxTree()

返回implicit_fun节点的名称子树。

注意：如果Node代表“ fun N/A”或“ fun M:N/A”，则结果分别代表“ N/A”或“ M:N/A” 的子树。

另请参阅： arity_qualifier/2，implicit_fun/1，module_qualifier/2。

infix_expr(Left::syntaxTree(), Operator::syntaxTree(), Right::syntaxTree()) ->syntaxTree()

创建一个抽象的中缀运算符表达式。结果代表“ Left Operator Right”。

另请参阅： infix_expr_left/1，infix_expr_operator/1，infix_expr_right/1，prefix_expr/2。

infix_expr_left(Node::syntaxTree()) ->syntaxTree()

返回infix_expr节点的左参数子树。

另见： infix_expr/3。

infix_expr_operator(Node::syntaxTree()) ->syntaxTree()

返回infix_expr节点的运算符子树。

另见： infix_expr/3。

infix_expr_right(Node::syntaxTree()) ->syntaxTree()

返回infix_expr节点的正确参数子树。

另见： infix_expr/3。

integer(Value::integer()) ->syntaxTree()

创建一个抽象的整数文字。词法表示是标准的十进制数字Value。

另请参阅： integer_literal/1，integer_value/1，is_integer/2。

integer_literal(Node::syntaxTree()) -> string()

返回由integer节点。

另见： integer/1。

integer_range_type(Low::syntaxTree(), High::syntaxTree()) ->syntaxTree()

创建一个抽象范围类型。结果代表“ Low .. High”。

另见： integer_range_type_high/1，integer_range_type_low/1。

integer_range_type_high(Node::syntaxTree()) ->syntaxTree()

返回integer_range_type节点的上限。

另见： integer_range_type/2。

integer_range_type_low(Node::syntaxTree()) ->syntaxTree()

返回integer_range_type节点的下限。

另见： integer_range_type/2。

integer_value(Node::syntaxTree()) -> integer()

返回integer节点表示的值。

另见： integer/1。

is_atom(Node::syntaxTree(), Value::atom()) -> boolean()

返回true如果Node有类型atom并表示Value，否则返回false。

另见： atom/1。

is_char(Node::syntaxTree(), Value::char()) -> boolean()

返回true如果Node有类型char并表示Value，否则返回false。

另见： char/1。

is_form(Node::syntaxTree()) -> boolean()

true如果Node是代表所谓“source code form”的语法树，则返回，否则返回false。表单是Erlang源代码单元，按顺序排列，构成一个Erlang程序。当前的表单类型是：

attributecommenterror_markereof_marker

form_listfunctionwarning_markertext

另请参阅： attribute/2，comment/2，eof_marker/0，error_marker/1，form_list/1，function/2，type/1，warning_marker/1。

is_integer(Node::syntaxTree(), Value::integer()) -> boolean()

返回true如果Node有类型integer并表示Value，否则返回false。

另见： integer/1。

is_leaf(Node::syntaxTree()) -> boolean()

true如果Node是叶节点则返回，否则返回false。当前可识别的叶节点类型是：

atomcharcommenteof_markererror_marker

floatfun_typeintegerniloperatorstring

textunderscorevariablewarning_marker

类型map_expr的节点当且仅当它没有参数且没有字段时是叶节点。类型map_type的节点当且仅当它没有字段（any_size）时是叶节点。类型tuple的节点当且仅当其元数为零时是叶节点。类型tuple_type的节点当且仅当它没有元素（any_size）时是叶节点。

注意：并非所有文字都是叶节点，反之亦然。例如，具有非零元素和非空列表的元组可能是文字，但不是叶节点。另一方面，变量是叶节点，但不是文字。

另见： is_literal/1，type/1。

is_list_skeleton(Node::syntaxTree()) -> boolean()

返回true如果Node已键入list或nil，否则false。

另见： list/2，nil/0。

is_literal(T::syntaxTree()) -> boolean()

返回trueif Node表示一个文字词，否则false。true当且仅当concrete(Node)定义的值被定义时，该函数返回。

另见： abstract/1，concrete/1。

is_proper_list(Node::syntaxTree()) -> boolean()

返回trueif Node表示一个正确的列表，false否则返回。一个适当的列表是一个列表框架，可以是“ []”或“ [E1, ..., En]”或“ [... | Tail]”，Tail也可以递归地表示一个合适的列表。

注意：由于Node是语法树，因此与其子树对应的实际运行时间值通常可能部分或完全未知。因此，如果Node代表例如“ [... | Ns]”（其中Ns是一个变量），则该函数将返回false，因为不知道Ns在运行时是否将其绑定到列表。如果Node代表例如“ [1, 2, 3]”或“ [A | []]”，则该函数将返回true。

另见： list/2。

is_string(Node::syntaxTree(), Value::string()) -> boolean()

返回true如果Node有类型string并表示Value，否则返回false。

另见： string/1。

is_tree(Tree::syntaxTree()) -> boolean()

仅限特殊用途。true如果Tree是抽象语法树则返回，false否则返回。

注意：这个函数false适用于所有“旧式” erl_parse兼容的“分析树”。

另见： tree/2。

join_comments(Source::syntaxTree(), Target::syntaxTree()) ->syntaxTree()

将评论附加Source到当前的评论Target。

注意：这相当于add_postcomments(get_postcomments(Source), add_precomments(get_precomments(Source), Target))，但可能更有效。

另请参阅： add_postcomments/2，add_precomments/2，comment/2，get_postcomments/1，get_precomments/1。

list(List::[syntaxTree()]) ->syntaxTree()

相当于list(List, none)。

list(Elements::[syntaxTree()], Tail::none |syntaxTree()) ->syntaxTree()

构造一个抽象列表框架。结果有类型list或nil。如果List是非空列表[E1, ..., En]，则结果为类型list并表示“ [E1, ..., En]”，如果Tail是none或否则为“ [E1, ..., En | Tail]”。如果List是空列表，则Tail 必须是none，并且在这种情况下，结果具有类型nil并表示“ []”（参见nil/0）。

列表作为语义对象（由单独的“cons”和“nil”项组成）以及用于表示列表的各种语法形式之间的区别首先可能令人困惑。该模块提供了精确控制句法表示的功能，以及简单的合成和解构，以及cons和head/tail操作。

注意：in list(Elements, none)，“nil”列表结束符是隐式的，并且没有关联信息（参见参考资料get_attrs/1），而在类型看似等价的list(Elements, Tail)情况下，Tail列表结束符子树可能具有附加的属性，例如nil位置，注释和注释等保存在结果Tail中。

另请参阅： compact_list/1，cons/2，get_attrs/1，is_list_skeleton/1，is_proper_list/1，list/1，list_elements/1，list_head/1，list_length/1，list_prefix/1，list_suffix/1，list_tail/1，nil/0，normalize_list/1。

list_comp(Template::syntaxTree(), Body::[syntaxTree()]) ->syntaxTree()

创建抽象列表理解。如果Body是[E1, ..., En]，结果代表“ [Template || E1, ..., En]”。

另请参阅： generator/2，list_comp_body/1，list_comp_template/1。

list_comp_body(Node::syntaxTree()) -> [syntaxTree()]

返回list_comp节点。

另见： list_comp/2。

list_comp_template(Node::syntaxTree()) ->syntaxTree()

返回模板子树。list_comp节点。

另见：list_comp/2...

list_elements(Node::syntaxTree()) -> [syntaxTree()]

返回列表骨架的元素子树列表。Node必须代表正确的列表。例如，如果Node代表“[X1, X2 | [X3, X4 | []]“那么list_elements(Node)产生列表[X1, X2, X3, X4]...

另见：is_proper_list/1，，，list/2...

list_head(Node::syntaxTree()) ->syntaxTree()

返回list节点。如果Node代表“[Head ...]“，结果将代表”Head“

另见：cons/2，，，list/2，，，list_tail/1...

list_length(Node::syntaxTree()) -> non_neg_integer()

返回列表骨架的元素子树数。Node必须代表正确的列表。例如，如果Node代表“[X1 | [X2, X3 | [X4, X5, X6]]]“那么list_length(Node)返回整数6。

注：这相当于length(list_elements(Node))，但可能更有效率。

另见：is_proper_list/1，，，list/2，，，list_elements/1...

list_prefix(Node::syntaxTree()) -> [syntaxTree()]

的前缀元素子树。list节点。如果Node代表“[E1, ..., En]“或”[E1, ..., En | Tail]“，返回的值是[E1, ..., En]...

另见：list/2...

list_suffix(Node::syntaxTree()) -> none |syntaxTree()

对象的后缀子树。list节点，如果存在。如果Node代表“[E1, ..., En | Tail]“，返回的值是Tail，否则，即，如果Node代表“[E1, ..., En]“none会被归还。

注意，即使这个函数返回一些Tail那不是none，类型Tail可以nil，如果已经显式地给出了尾，并且列表骨架没有压缩%28，请参见compact_list/129%。

另见：compact_list/1，，，list/2，，，nil/0...

list_tail(Node::syntaxTree()) ->syntaxTree()

返回list节点。如果Node表示“单一元素列表”。[E]“，则结果具有类型nil，代表“[]“.如果Node代表“[E1, E2 ...]“，结果将代表”[E2 ...]“，如果Node代表“[Head | Tail]“，结果将代表”Tail“

另见：cons/2，，，list/2，，，list_head/1...

macro(Name::syntaxTree()) ->syntaxTree()

相当于macro(Name, none)...

macro(Name::syntaxTree(), Arguments::none | [syntaxTree()]) ->syntaxTree()

创建抽象宏应用程序。如果Arguments是none，结果代表“?Name“，否则，如果Arguments是[A1, ..., An]，结果代表“?Name(A1, ..., An)“

注：如Arguments为空列表，则结果将表示“?Name()“，包括一对匹配的括号。

预处理器对宏应用程序%28的参数施加的唯一语法限制是，它们必须与括号、括号、begin ... end，，，case ... end等text节点类型可以用来表示非常规Erlang构造的参数。

另见：macro/1，，，macro_arguments/1，，，macro_name/1，，，text/1...

macro_arguments(Node::syntaxTree()) -> none | [syntaxTree()]

返回参数子树的列表。macro节点，如果有的话。如果Node代表“?Name“none会被归还。否则，如果Node代表“?Name(A1, ..., An)“[A1, ..., An]会被归还。

另见：macro/2...

macro_name(Node::syntaxTree()) ->syntaxTree()

的名称子树。macro节点。

另见：macro/2...

make_tree(X1::atom(), X2::[[syntaxTree()]]) ->syntaxTree()

创建具有给定类型和子树的语法树。Type必须是节点类型名称%28(参见type/1%29不表示叶节点类型%28(参见is_leaf/129%。Groups一定是非空表示给定类型节点的子树的语法树组列表，按从左到右的顺序排列，就像它们在打印的程序文本中发生的那样，按类别分组，如下所做的那样：subtrees/1...

结果copy_attrs(Node, make_tree(type(Node), subtrees(Node)))28%见update_tree/2%29表示与原始代码相同的源代码文本。Node，假设subtrees(Node)生成一个非空列表。但是，它不一定具有与Node...

另见：copy_attrs/2，，，is_leaf/1，，，subtrees/1，，，type/1，，，update_tree/2...

map_expr(Fields::[syntaxTree()]) ->syntaxTree()

相当于map_expr(none, Fields)...

map_expr(Argument::none |syntaxTree(), Fields::[syntaxTree()]) ->syntaxTree()

创建一个抽象的映射表达式。如果Fields是[F1, ..., Fn]，那么如果Argument是none，结果代表“#{F1, ..., Fn}“，否则它代表”Argument#{F1, ..., Fn}“

另见：map_expr/1，，，map_expr_argument/1，，，map_expr_fields/1，，，map_field_assoc/2，，，map_field_exact/2...

map_expr_argument(Node::syntaxTree()) -> none |syntaxTree()

对象的参数子树返回map_expr节点，如果有的话。如果Node代表“#{...}“none会被归还。否则，如果Node代表“Argument#{...}“Argument会被归还。

另见：map_expr/2...

map_expr_fields(Node::syntaxTree()) -> [syntaxTree()]

对象的字段子树列表。map_expr节点。

另见：map_expr/2...

map_field_assoc(Name::syntaxTree(), Value::syntaxTree()) ->syntaxTree()

创建一个抽象地图Assoc字段。结果代表“Name => Value“

另见：map_expr/2，，，map_field_assoc_name/1，，，map_field_assoc_value/1...

map_field_assoc_name(Node::syntaxTree()) ->syntaxTree()

的名称子树。map_field_assoc节点。

另见：map_field_assoc/2...

map_field_assoc_value(Node::syntaxTree()) ->syntaxTree()

对象的值子树返回map_field_assoc节点。

另见：map_field_assoc/2...

map_field_exact(Name::syntaxTree(), Value::syntaxTree()) ->syntaxTree()

创建一个抽象的地图精确字段。结果代表“Name := Value“

另见：map_expr/2，，，map_field_exact_name/1，，，map_field_exact_value/1...

map_field_exact_name(Node::syntaxTree()) ->syntaxTree()

的名称子树。map_field_exact节点。

另见：map_field_exact/2...

map_field_exact_value(Node::syntaxTree()) ->syntaxTree()

对象的值子树返回map_field_exact节点。

另见：map_field_exact/2...

map_type() -> term()

相当于map_type(any_size)...

map_type(Fields::any_size | [syntaxTree()]) ->syntaxTree()

创建抽象类型映射。如果Fields是[F1, ..., Fn]，结果代表“#{F1, ..., Fn}“；否则，如果Fields是any_size，它代表“map()“

另见：map_type_fields/1...

map_type_assoc(Name::syntaxTree(), Value::syntaxTree()) ->syntaxTree()

创建抽象映射类型Assoc字段。结果代表“Name => Value“

另见：map_type/1，，，map_type_assoc_name/1，，，map_type_assoc_value/1...

map_type_assoc_name(Node::syntaxTree()) ->syntaxTree()

的名称子树。map_type_assoc节点。

另见：map_type_assoc/2...

map_type_assoc_value(Node::syntaxTree()) ->syntaxTree()

对象的值子树返回map_type_assoc节点。

另见：map_type_assoc/2...

map_type_exact(Name::syntaxTree(), Value::syntaxTree()) ->syntaxTree()

创建一个抽象的映射类型精确字段。结果代表“Name := Value“

另见：map_type/1，，，map_type_exact_name/1，，，map_type_exact_value/1...

map_type_exact_name(Node::syntaxTree()) ->syntaxTree()

的名称子树。map_type_exact节点。

另见：map_type_exact/2...

map_type_exact_value(Node::syntaxTree()) ->syntaxTree()

对象的值子树返回map_type_exact节点。

另见：map_type_exact/2...

map_type_fields(Node::syntaxTree()) -> any_size | [syntaxTree()]

对象的字段子树列表。map_type节点。如果Node代表“map()“any_size返回；否则，如果Node代表“#{F1, ..., Fn}“[F1, ..., Fn]会被归还。

另见：map_type/0，，，map_type/1...

match_expr(Pattern::syntaxTree(), Body::syntaxTree()) ->syntaxTree()

创建一个抽象匹配表达式。结果代表“Pattern = Body“

另见：match_expr_body/1，，，match_expr_pattern/1...

match_expr_body(Node::syntaxTree()) ->syntaxTree()

返回match_expr节点。

另见：match_expr/2...

match_expr_pattern(Node::syntaxTree()) ->syntaxTree()

对象的模式子树返回match_expr节点。

另见：match_expr/2...

meta(T::syntaxTree()) ->syntaxTree()

创建语法树的元表示形式。结果表示一个Erlang表达式“MetaTree“如果进行计算，将产生一个新的语法树，表示与Tree%28虽然实际数据表示可能不同，但%29。代表的表达式MetaTree是执行独立关于抽象语法树实现所使用的数据结构。的节点上附加的注释。Tree将被保存，但其他属性将丢失。

中的任何节点Tree其节点类型为variable28%见type/1%29，其注释列表%28请参见get_ann/1%29包含原子meta_var，则在结果树中保持不变，但只有一个发生在meta_var从其注释列表中删除。

功能的主要用途meta/1是转换数据结构。Tree，它表示一段程序代码，转换为打印时表示独立...。例如，假设Tree表示名为“V”的变量。那么%28假设一个函数print/1用于打印语法树%29，计算print(abstract(Tree))-只是使用abstract/1要将实际的数据结构映射到语法树表示上，可以输出类似于“{tree, variable, ..., "V", ...}，这显然依赖于抽象语法树的实现。例如，这对于缓存文件中的语法树很有用。但是，在某些情况下，例如在程序生成器%28和两个“生成器”%29中，这可能是不可接受的。使用print(meta(Tree))相反，会输出一个表示无关生成表达式的语法树；在上述情况下，类似于“erl_syntax:variable("V")“

另见：abstract/1，，，get_ann/1，，，type/1...

module_qualifier(Module::syntaxTree(), Body::syntaxTree()) ->syntaxTree()

创建一个抽象模块限定符。结果代表“Module:Body“

另见：module_qualifier_argument/1，，，module_qualifier_body/1...

module_qualifier_argument(Node::syntaxTree()) ->syntaxTree()

对象的模块%29子树返回参数%28module_qualifier节点。

另见：module_qualifier/2...

module_qualifier_body(Node::syntaxTree()) ->syntaxTree()

返回module_qualifier节点。

另见：module_qualifier/2...

named_fun_expr(Name::syntaxTree(), Clauses::[syntaxTree()]) ->syntaxTree()

创建一个名为“有趣表达式”的抽象。如果Clauses是[C1, ..., Cn]，结果代表“fun Name C1; ...; Name Cn end“.更确切地说，如果每个Ci代表“(Pi1, ..., Pim) Gi -> Bi“，则结果表示”fun Name(P11, ..., P1m) G1 -> B1; ...; Name(Pn1, ..., Pnm) Gn -> Bn end“

另见：named_fun_expr_arity/1，，，named_fun_expr_clauses/1，，，named_fun_expr_name/1...

named_fun_expr_arity(Node::syntaxTree()) -> arity()

返回named_fun_expr节点。其结果是命名的兴趣表达式的第一个子句中的参数模式的数量；忽略后续子句。

则引发异常。named_fun_expr_clauses(Node)返回空列表，或者如果该列表的第一个元素不是语法树。C类型clause使...clause_patterns(C)是一个非空的列表。

另见：clause/3，，，clause_patterns/1，，，named_fun_expr/2，，，named_fun_expr_clauses/1...

named_fun_expr_clauses(Node::syntaxTree()) -> [syntaxTree()]

对象的子句子树列表。named_fun_expr节点。

另见：named_fun_expr/2...

named_fun_expr_name(Node::syntaxTree()) ->syntaxTree()

的名称子树。named_fun_expr节点。

另见：named_fun_expr/2...

nil() ->syntaxTree()

创建一个抽象的空列表。结果代表“[]空列表传统上称为“零”。

另见：is_list_skeleton/1，，，list/2...

normalize_list(Node::syntaxTree()) ->syntaxTree()

另见：compact_list/1，，，list/2...

operator(Name::atom() | string()) ->syntaxTree()

创建一个抽象运算符。运算符的名称是由Name这类似于原子的打印名称，但运算符从来不使用单引号；例如，operator(++%27%29%27表示“++“而不是”++%27%27“。

另见：atom/1，，，operator_literal/1，，，operator_name/1...

operator_literal(Node::syntaxTree()) -> string()

返回由operator节点。这只是操作符名作为字符串。

另见：operator/1...

operator_name(Node::syntaxTree()) -> atom()

返回operator节点。注意，名称作为一个原子返回。

另见：operator/1...

parentheses(Expr::syntaxTree()) ->syntaxTree()

创建一个抽象括号表达式。结果代表“(Body)“，与上下文无关。

另见：parentheses_body/1...

parentheses_body(Node::syntaxTree()) ->syntaxTree()

返回parentheses节点。

另见：parentheses/1...

prefix_expr(Operator::syntaxTree(), Argument::syntaxTree()) ->syntaxTree()

创建一个抽象前缀运算符表达式。结果代表“Operator Argument“

另见：infix_expr/3，，，prefix_expr_argument/1，，，prefix_expr_operator/1...

prefix_expr_argument(Node::syntaxTree()) ->syntaxTree()

对象的参数子树返回prefix_expr节点。

另见：prefix_expr/2...

prefix_expr_operator(Node::syntaxTree()) ->syntaxTree()

的运算符子树。prefix_expr节点。

另见：prefix_expr/2...

receive_expr(Clauses::[syntaxTree()]) ->syntaxTree()

相当于receive_expr(Clauses, none, [])...

receive_expr(Clauses::[syntaxTree()], Timeout::none |syntaxTree(), Action::[syntaxTree()]) ->syntaxTree()

创建一个抽象的接收表达式。如果Timeout是none，结果代表“receive C1; ...; Cn end“%28Action参数被忽略%29。否则，如果Clauses是[C1, ..., Cn]和Action是[A1, ..., Am]，结果代表“receive C1; ...; Cn after Timeout -> A1, ..., Am end“.更确切地说，如果每个Ci代表“(Pi) Gi -> Bi“，则结果表示”receive P1 G1 -> B1; ...; Pn Gn -> Bn ... end“

注意，在Erlang中，如果没有指定超时部分，接收表达式必须至少有一个子句。

另见：case_expr/2，，，clause/3，，，receive_expr/1，，，receive_expr_action/1，，，receive_expr_clauses/1，，，receive_expr_timeout/1...

receive_expr_action(Node::syntaxTree()) -> [syntaxTree()]

对象的操作主体子树的列表。receive_expr节点。如果Node代表“receive C1; ...; Cn end“这是空名单。

另见：receive_expr/3...

receive_expr_clauses(Node::syntaxTree()) -> [syntaxTree()]

对象的子句子树列表。receive_expr节点。

另见：receive_expr/3...

receive_expr_timeout(Node::syntaxTree()) -> none |syntaxTree()

对象的超时值子树。receive_expr节点，如果有的话。如果Node代表“receive C1; ...; Cn end“none会被归还。否则，如果Node代表“receive C1; ...; Cn after Timeout -> ... end“Timeout会被归还。

另见：receive_expr/3...

record_access(Argument::syntaxTree(), Type::syntaxTree(), Field::syntaxTree()) ->syntaxTree()

创建抽象记录字段访问表达式。结果代表“Argument#Type.Field“

另见：record_access_argument/1，，，record_access_field/1，，，record_access_type/1，，，record_expr/3...

record_access_argument(Node::syntaxTree()) ->syntaxTree()

对象的参数子树返回record_access节点。

另见：record_access/3...

record_access_field(Node::syntaxTree()) ->syntaxTree()

返回record_access节点。

另见：record_access/3...

record_access_type(Node::syntaxTree()) ->syntaxTree()

类的类型子树。record_access节点。

另见：record_access/3...

record_expr(Type::syntaxTree(), Fields::[syntaxTree()]) ->syntaxTree()

相当于record_expr(none, Type, Fields)...

record_expr(Argument::none |syntaxTree(), Type::syntaxTree(), Fields::[syntaxTree()]) ->syntaxTree()

创建一个抽象记录表达式。如果Fields是[F1, ..., Fn]，那么如果Argument是none，结果代表“#Type{F1, ..., Fn}“，否则它代表”Argument#Type{F1, ..., Fn}“

另见：record_access/3，，，record_expr/2，，，record_expr_argument/1，，，record_expr_fields/1，，，record_expr_type/1，，，record_field/2，，，record_index_expr/2...

record_expr_argument(Node::syntaxTree()) -> none |syntaxTree()

对象的参数子树返回record_expr节点，如果有的话。如果Node代表“#Type{...}“none会被归还。否则，如果Node代表“Argument#Type{...}“Argument会被归还。

另见：record_expr/3...

record_expr_fields(Node::syntaxTree()) -> [syntaxTree()]

对象的字段子树列表。record_expr节点。

另见：record_expr/3...

record_expr_type(Node::syntaxTree()) ->syntaxTree()

类的类型子树。record_expr节点。

另见：record_expr/3...

record_field(Name::syntaxTree()) ->syntaxTree()

相当于record_field(Name, none)...

record_field(Name::syntaxTree(), Value::none |syntaxTree()) ->syntaxTree()

创建抽象记录字段规范。如果Value是none，结果只表示“Name“，否则它代表”Name = Value“

另见：record_expr/3，，，record_field_name/1，，，record_field_value/1...

record_field_name(Node::syntaxTree()) ->syntaxTree()

的名称子树。record_field节点。

另见：record_field/2...

record_field_value(Node::syntaxTree()) -> none |syntaxTree()

对象的值子树返回record_field节点，如果有的话。如果Node代表“Name“none会被归还。否则，如果Node代表“Name = Value“Value会被归还。

另见：record_field/2...

record_index_expr(Type::syntaxTree(), Field::syntaxTree()) ->syntaxTree()

创建一个抽象记录字段索引表达式。结果代表“#Type.Field“

%28注：函数名record_index/2是由Erlang编译器保留的，这就是为什么不能将该名称用于此构造函数。

另见：record_expr/3，，，record_index_expr_field/1，，，record_index_expr_type/1...

record_index_expr_field(Node::syntaxTree()) ->syntaxTree()

返回record_index_expr节点。

另见：record_index_expr/2...

record_index_expr_type(Node::syntaxTree()) ->syntaxTree()

类的类型子树。record_index_expr节点。

另见：record_index_expr/2...

record_type(Name::syntaxTree(), Fields::[syntaxTree()]) ->syntaxTree()

创建抽象记录类型。如果Fields是[F1, ..., Fn]，结果代表“#Name{F1, ..., Fn}“

另见：record_type_fields/1，，，record_type_name/1...

record_type_field(Name::syntaxTree(), Type::syntaxTree()) ->syntaxTree()

创建一个抽象记录类型字段。结果代表“Name :: Type“

另见：record_type_field_name/1，，，record_type_field_type/1...

record_type_field_name(Node::syntaxTree()) ->syntaxTree()

的名称子树。record_type_field节点。

另见：record_type_field/2...

record_type_field_type(Node::syntaxTree()) ->syntaxTree()

类的类型子树。record_type_field节点。

另见：record_type_field/2...

record_type_fields(Node::syntaxTree()) -> [syntaxTree()]

对象的字段子树返回record_type节点。

另见：record_type/2...

record_type_name(Node::syntaxTree()) ->syntaxTree()

的名称子树。record_type节点。

另见：record_type/2...

remove_comments(Node::syntaxTree()) ->syntaxTree()

的相关注释。Node...

注：这相当于set_precomments(set_postcomments(Node, []), [])，但可能更有效率。

另见：set_postcomments/2，，，set_precomments/2...

revert(Node::syntaxTree()) ->syntaxTree()

返回erl_parse-如果可能的话，语法树的兼容表示。如果Tree表示一个格式良好的Erlang程序或表达式，转换应该没有问题.。典型的，is_tree/1产量true如果转换失败，%28i。，结果仍然是抽象语法树%29，并且false否则。

大is_tree/1测试并不完全是万无一失的。对于一些特殊的节点类型，%28例如。arity_qualifier%29，如果这样的节点发生在不需要它的上下文中，它将保持不变，作为结果的非恢复子树。只有当Tree实际上并不代表合法的Erlang代码。

另见：erl_parse(3)，，，revert_forms/1...

revert_forms(Forms::forms()) -> [erl_parse()]

恢复一系列Erlang源代码表单。序列可以作为form_list语法树%28可能嵌套%29，或作为“程序形式”语法树的列表。如果成功，则相应的erl_parse-兼容语法树返回%28(参见revert/129%。如果某个程序形式无法恢复，{error, Form}被扔了。表单序列中的独立注释被丢弃。

另见：form_list/1，，，is_form/1，，，revert/1...

set_ann(Node::syntaxTree(), As::[term()]) ->syntaxTree()

的用户注释列表。Node到Annotations...

另见：add_ann/2，，，copy_ann/2，，，get_ann/1...

set_attrs(Node::syntaxTree(), Attr::syntaxTreeAttributes()) ->syntaxTree()

的属性。Node到Attributes...

另见：copy_attrs/2，，，get_attrs/1...

set_pos(Node::syntaxTree(), Pos::term()) ->syntaxTree()

的位置信息。Node到Pos...

另见：copy_pos/2，，，get_pos/1...

set_postcomments(Node::syntaxTree(), Cs::[syntaxTree()]) ->syntaxTree()

的后置注释。Node到Comments...Comments应该是一个空的抽象注释列表，按自顶向下的文本顺序排列。

另见：add_postcomments/2，，，comment/2，，，copy_comments/2，，，get_postcomments/1，，，join_comments/2，，，remove_comments/1，，，set_precomments/2...

set_precomments(Node::syntaxTree(), Cs::[syntaxTree()]) ->syntaxTree()

设置Node到Comments...Comments应该是一个空的抽象注释列表，按自上而下的文本顺序排列。

另见：add_precomments/2，，，comment/2，，，copy_comments/2，，，get_precomments/1，，，join_comments/2，，，remove_comments/1，，，set_postcomments/2...

size_qualifier(Body::syntaxTree(), Size::syntaxTree()) ->syntaxTree()

创建抽象大小限定符。结果代表“Body:Size“

另见：size_qualifier_argument/1，，，size_qualifier_body/1...

size_qualifier_argument(Node::syntaxTree()) ->syntaxTree()

返回参数子树%28，大小为size_qualifier节点。

另见：size_qualifier/2...

size_qualifier_body(Node::syntaxTree()) ->syntaxTree()

返回size_qualifier节点。

另见：size_qualifier/2...

string(String::string()) ->syntaxTree()

创建一个抽象字符串文本。结果表示"Text"%28包括周围的双引号%29，其中Text中的字符序列。Value，但不代表专一字符串文字。

例如，string("x\ny")表示"x\ny"，，，"x\12y"，，，"x\012y"和"x\^Jy"；见char/1...

另见：char/1，，，is_string/2，，，string_literal/1，，，string_literal/2，，，string_value/1...

string_literal(Node::syntaxTree()) -> nonempty_string()

返回由string节点。这包括周围的双引号字符.。255个以上的字符将被转义。

另见：string/1...

string_literal(Node::syntaxTree(), X2::encoding()) -> nonempty_string()

返回由string节点。这包括周围的双引号字符.。取决于超过255的编码字符，将转义%28latin1%29或复制为%28utf829%。

另见：string/1...

string_value(Node::syntaxTree()) -> string()

返回由string节点。

另见：string/1...

subtrees(T::syntaxTree()) -> [[syntaxTree()]]

返回语法树的所有子树的分组列表。如果Node是叶节点%28(参见is_leaf/1%29，这是空列表，否则结果总是非空列表，包含Node，按从左到右的顺序排列，它们在打印的程序文本中出现，并按类别分组。通常，每个组只包含一个子树。

取决于Node，某些组的大小可能是可变的%28e。g.，由元组%29的所有元素组成的组，而其他组则总是包含相同数量的元素--通常正好是1%28e。包含案例表达式%29的参数表达式的组。但是，请注意，对于给定的节点类型%29，返回的列表%28的确切结构一般不应依赖，因为它可能会在没有通知的情况下更改。

功能subtrees/1和构造函数make_tree/2和update_tree/2如果一个人想要遍历语法树，访问它的所有子树，但在大多数情况下或所有情况下都以统一的方式对待树的节点，那么这将是一个很大的帮助。使用这些函数可以简化此操作，并确保代码对语法树数据类型的扩展不太敏感，因为代码没有显式处理的任何节点类型都可以留待默认情况处理。

例如：

postorder(F, Tree) ->
   F(case subtrees(Tree) of
       [] -> Tree;
       List -> update_tree(Tree,
                           [[postorder(F, Subtree)
                             || Subtree &lt;- Group]
                            || Group &lt;- List])
     end).

映射函数F上Tree以及它的所有子树，对语法树进行顺序遍历。%28注意使用update_tree/2若要保留节点属性.%29，请使用以下简单函数：

f(Node) ->
   case type(Node) of
       atom -> atom("a_" ++ atom_name(Node)
       _ -> Node
   end.

打电话postorder(fun f/1, Tree)将产生一个新的表示形式Tree中，所有原子名称都以前缀“a”进行扩展。[医]“，但是没有更改任何其他%28，包括注释、注释和行号%29。

另见：copy_attrs/2，，，is_leaf/1，，，make_tree/2，，，type/1...

text(String::string()) ->syntaxTree()

创建一段抽象的源代码文本。结果准确地表示了String这在一个人想要完全控制结果输出的情况下是有用的，例如，对于浮点数或宏定义的出现。

另见：text_string/1...

text_string(Node::syntaxTree()) -> string()

返回由text节点。

另见：text/1...

tree(Type::atom()) -> #tree{type=atom(), attr=#attr{pos=term(), ann=[term()], com=none | #com{pre=[syntaxTree()], post=[syntaxTree()]}}, data=term()}

相当于tree(Type, [])...

tree(Type::atom(), Data::term()) -> #tree{type=atom(), attr=#attr{pos=term(), ann=[term()], com=none | #com{pre=[syntaxTree()], post=[syntaxTree()]}}, data=term()}

只作特殊用途创建带有类型标记的抽象语法树节点。Type和相关数据Data...

这一职能及其相关is_tree/1和data/1提供一种统一的方法来扩展erl_parse节点类型。关联的数据是任何术语，其格式可能取决于类型标记。

注：

在此模块之外创建的任何节点都必须具有与此模块当前定义的类型标记不同的类型标记；请参见type/1一份完整的名单。

语法树节点的类型标记也可由erl_parse表示；在这种情况下，选择器为该节点类型起作用。必同时处理抽象语法树和erl_parse表格。功能type(T)的表示形式都应该返回正确的类型标记。T，这样用户就不会看到erl_syntax和erl_parse节点。

另见：data/1，，，is_tree/1，，，type/1...

try_after_expr(Body::[syntaxTree()], After::[syntaxTree()]) ->syntaxTree()

相当于try_expr(Body, [], [], After)...

try_expr(Body::[syntaxTree()], Handlers::[syntaxTree()]) ->syntaxTree()

相当于try_expr(Body, [], Handlers)...

try_expr(Body::[syntaxTree()], Clauses::[syntaxTree()], Handlers::[syntaxTree()]) ->syntaxTree()

相当于try_expr(Body, Clauses, Handlers, [])...

try_expr(Body::[syntaxTree()], Clauses::[syntaxTree()], Handlers::[syntaxTree()], After::[syntaxTree()]) ->syntaxTree()

创建一个抽象的尝试表达式。如果Body是[B1, ..., Bn]，，，Clauses是[C1, ..., Cj]，，，Handlers是[H1, ..., Hk]，和After是[A1, ..., Am]，结果代表“try B1, ..., Bn of C1; ...; Cj catch H1; ...; Hk after A1, ..., Am end“.更确切地说，如果每个Ci代表“(CPi) CGi -> CBi“，每一个Hi代表“(HPi) HGi -> HBi“，则结果表示”try B1, ..., Bn of CP1 CG1 -> CB1; ...; CPj CGj -> CBj catch HP1 HG1 -> HB1; ...; HPk HGk -> HBk after A1, ..., Am end“；见case_expr/2.如果Clauses是空列表，of ...部分被忽略了。如果After是空列表，after ...部分被忽略了。如果Handlers是空列表，并且After是非空的，catch ...部分被忽略了。

另见：case_expr/2，，，class_qualifier/2，，，clause/3，，，try_after_expr/2，，，try_expr/2，，，try_expr/3，，，try_expr_after/1，，，try_expr_body/1，，，try_expr_clauses/1，，，try_expr_handlers/1...

try_expr_after(Node::syntaxTree()) -> [syntaxTree()]

对象的“后”子树的列表。try_expr节点。

另见：try_expr/4...

try_expr_body(Node::syntaxTree()) -> [syntaxTree()]

返回try_expr节点。

另见：try_expr/4...

try_expr_clauses(Node::syntaxTree()) -> [syntaxTree()]

对象的case-子句子树列表。try_expr节点。如果Node代表“try Body catch H1; ...; Hn end“，结果是空列表。

另见：try_expr/4...

try_expr_handlers(Node::syntaxTree()) -> [syntaxTree()]

返回处理程序-子句子树的列表。try_expr节点。

另见：try_expr/4...

tuple(List::[syntaxTree()]) ->syntaxTree()

创建抽象元组。如果Elements是[X1, ..., Xn]，结果代表“{X1, ..., Xn}“

注：二郎语言有不同的1元组，即，{X}总是有别于X本身。

另见：tuple_elements/1，，，tuple_size/1...

tuple_elements(Node::syntaxTree()) -> [syntaxTree()]

对象的元素子树列表。tuple节点。

另见：tuple/1...

tuple_size(Node::syntaxTree()) -> non_neg_integer()

返回tuple节点。

注：这相当于length(tuple_elements(Node))，但可能更有效率。

另见：tuple/1，，，tuple_elements/1...

tuple_type() -> term()

相当于tuple_type(any_size)...

tuple_type(Elements::any_size | [syntaxTree()]) ->syntaxTree()

创建抽象类型元组。如果Elements是[T1, ..., Tn]，结果代表“{T1, ..., Tn}“；否则，如果Elements是any_size，它代表“tuple()“

另见：tuple_type_elements/1...

tuple_type_elements(Node::syntaxTree()) -> any_size | [syntaxTree()]

对象的类型元素子树的列表。tuple_type节点。如果Node代表“tuple()“any_size返回；否则，如果Node代表“{T1, ..., Tn}“[T1, ..., Tn]会被归还。

另见：tuple_type/0，，，tuple_type/1...

type(Tree::syntaxTree()) -> atom()

的类型标记。Node.如果Node不表示语法树，则计算失败是有原因的。badarg本模块当前定义的节点类型为：

应用程序注释[医]类型性[医]限定符原子

属性二进制[医]字段位串[医]类型

块[医]费用案件[医]费用渔获量[医]焦焦

类[医]限定符子句注释[医]费用

连接约束[医]功能[医]类型约束分离

EOF[医]标记误差[医]标记浮子形式[医]列单

乐趣[医]娱乐[医]类型函数[医]类型

发电机中频[医]外隐[医]乐趣灌输[医]费用

整数整数[医]范围[医]类型列表[医]康普

宏观地图[医]扩展图[医]场域[医]Assoc地图[医]场域[医]精确性

地图[医]类型图[医]类型[医]Assoc地图[医]类型[医]完全匹配[医]Exr模块[医]限定符

命名[医]乐趣[医]Exr nil运算符括号

前缀[医]费用接收[医]费用记录[医]存取记录[医]费用

记录[医]现场记录[医]指数[医]费用记录[医]类型记录[医]类型[医]场域

大小[医]限定符字符串文本尝试[医]费用

元组[医]类型类型化[医]记录[医]字段类型[医]应用类型[医]联合下划线用户[医]类型[医]应用变量

警告[医]标记物

用户可以为特殊目的创建%28%29使用其他类型标记创建附加节点，使用tree/2功能。

注意：节点类型的主构造函数应该始终与节点类型本身的名称相同。

另见：annotated_type/2，，，application/3，，，arity_qualifier/2，，，atom/1，，，attribute/2，，，binary/1，，，binary_field/2，，，bitstring_type/2，，，block_expr/1，，，case_expr/2，，，catch_expr/1，，，char/1，，，class_qualifier/2，，，clause/3，，，comment/2，，，cond_expr/1，，，conjunction/1，，，constrained_function_type/2，，，constraint/2，，，disjunction/1，，，eof_marker/0，，，error_marker/1，，，float/1，，，form_list/1，，，fun_expr/1，，，fun_type/0，，，function/2，，，function_type/1，，，function_type/2，，，generator/2，，，if_expr/1，，，implicit_fun/2，，，infix_expr/3，，，integer/1，，，integer_range_type/2，，，list/2，，，list_comp/2，，，macro/2，，，map_expr/2，，，map_field_assoc/2，，，map_field_exact/2，，，map_type/0，，，map_type/1，，，map_type_assoc/2，，，map_type_exact/2，，，match_expr/2，，，module_qualifier/2，，，named_fun_expr/2，，，nil/0，，，operator/1，，，parentheses/1，，，prefix_expr/2，，，receive_expr/3，，，record_access/3，，，record_expr/2，，，record_field/2，，，record_index_expr/2，，，record_type/2，，，record_type_field/2，，，size_qualifier/2，，，string/1，，，text/1，，，tree/2，，，try_expr/3，，，tuple/1，，，tuple_type/0，，，tuple_type/1，，，type_application/2，，，type_union/1，，，typed_record_field/2，，，underscore/0，，，user_type_application/2，，，variable/1，，，warning_marker/1...

type_application(TypeName::syntaxTree(), Arguments::[syntaxTree()]) ->syntaxTree()

创建抽象类型的应用程序表达式。如果Arguments是[T1, ..., Tn]，结果代表“TypeName(T1, ...Tn)“

另见：type_application/3，，，type_application_arguments/1，，，type_application_name/1，，，user_type_application/2...

type_application(Module::none |syntaxTree(), TypeName::syntaxTree(), Arguments::[syntaxTree()]) ->syntaxTree()

创建抽象类型的应用程序表达式。如果Module是none，这是调用等效于type_application(TypeName, Arguments)，否则就等于type_application(module_qualifier(Module, TypeName), Arguments)...

%28这是一个实用函数。

另见：module_qualifier/2，，，type_application/2...

type_application_arguments(Node::syntaxTree()) -> [syntaxTree()]

的参数子树。type_application节点。

另见：type_application/2...

type_application_name(Node::syntaxTree()) ->syntaxTree()

类的类型名称子树。type_application节点。

另见：type_application/2...

type_union(Types::[syntaxTree()]) ->syntaxTree()

创建抽象类型联合。如果Types是[T1, ..., Tn]，结果代表“T1 | ... | Tn“

另见：type_union_types/1...

type_union_types(Node::syntaxTree()) -> [syntaxTree()]

类的类型子树的列表。type_union节点。

另见：type_union/1...

typed_record_field(Field::syntaxTree(), Type::syntaxTree()) ->syntaxTree()

创建抽象类型的记录字段规范。结果代表“Field :: Type“

另见：typed_record_field_body/1，，，typed_record_field_type/1...

typed_record_field_body(Node::syntaxTree()) ->syntaxTree()

返回typed_record_field节点。

另见：typed_record_field/2...

typed_record_field_type(Node::syntaxTree()) ->syntaxTree()

类的类型子树。typed_record_field节点。

另见：typed_record_field/2...

underscore() ->syntaxTree()

创建抽象通用模式%28“_“%29。词法表示是一个单独的下划线字符。注意这是不一个变量，从词汇上讲。

另见：variable/1...

update_tree(Node::syntaxTree(), Groups::[[syntaxTree()]]) ->syntaxTree()

创建与给定树具有相同类型和属性的语法树。这相当于copy_attrs(Node, make_tree(type(Node), Groups))...

另见：copy_attrs/2，，，make_tree/2，，，type/1...

user_type_application(TypeName::syntaxTree(), Arguments::[syntaxTree()]) ->syntaxTree()

创建抽象用户类型。如果Arguments是[T1, ..., Tn]，结果代表“TypeName(T1, ...Tn)“

另见：type_application/2，，，user_type_application_arguments/1，，，user_type_application_name/1...

user_type_application_arguments(Node::syntaxTree()) -> [syntaxTree()]

的参数子树。user_type_application节点。

另见：user_type_application/2...

user_type_application_name(Node::syntaxTree()) ->syntaxTree()

类的类型名称子树。user_type_application节点。

另见：user_type_application/2...

variable(Name::atom() | string()) ->syntaxTree()

创建一个具有给定名称的抽象变量。Name可以是表示词汇上有效的变量名的任何原子或字符串，但是不单个下划线字符；参见underscore/0...

注意：不检查字符序列是否代表一个适当的变量名，即它的第一个字符是否为大写Erlang字符，或者它是否包含控制字符、空格等。

另见：underscore/0，，，variable_literal/1，，，variable_name/1...

variable_literal(Node::syntaxTree()) -> string()

返回variable节点作为字符串。

另见：variable/1...

variable_name(Node::syntaxTree()) -> atom()

返回variable节点作为原子。

另见：variable/1...

warning_marker(Warning::term()) ->syntaxTree()

创建抽象警告标记。结果表示源代码中可能出现的问题，并给出了关联的Erlang I/O ErrorInfo结构。Error%28见模块io(3)详情见%29。警告标记被视为源代码形式，但没有定义词法形式。

注意：只支持向后兼容现有解析器和工具。

另见：eof_marker/0，，，error_marker/1，，，is_form/1，，，warning_marker_info/1...

warning_marker_info(Node::syntaxTree()) -> term()

的ErrorInfo结构。warning_marker节点。

另见：warning_marker/1...

richard@gmail.com

 © 2010–2017 Ericsson AB

根据ApacheLicense，版本2.0获得许可。