查看源代码 erl_syntax (syntax_tools v3.2.1)
抽象 Erlang 语法树。
此模块定义了一个抽象数据类型，用于将 Erlang 源代码表示为语法树，该方式与 Erlang 标准库解析器模块 erl_parse（通常被称为“解析树”，这有点用词不当）创建的数据结构向后兼容。这意味着所有 erl_parse 树都是有效的抽象语法树，但反之则不然：抽象语法树通常不能用作期望 erl_parse 树的函数的输入。但是，只要抽象语法树表示正确的 Erlang 程序，函数 revert/1 就应该能够将其转换为相应的 erl_parse 表示形式。
对于首次使用的用户，建议的起点是 syntaxTree() 数据类型的文档以及函数 type/1。
注意
此模块处理句法实体（而非语义实体）的组成和分解；其目的是隐藏对用于表示这些实体的数据结构的所有直接引用。除了少数例外，此模块中的函数不对其输入执行任何语义解释，并且通常假定用户传递类型正确的参数——如果不是这样，则效果未定义。
除了 erl_parse() 数据结构外，抽象语法树的内部表示形式可能会在不通知的情况下发生更改，并且不应在此模块之外进行记录。此外，我们不保证抽象语法树如何表示，但以下情况例外：没有语法树由单个原子（例如 none）、列表构造函数 [X | Y] 或空列表 [] 表示。在编写对语法树进行操作的函数时，可以依赖这一点。
概要
函数
创建一个抽象空列表。
返回与 Erlang 术语对应的语法树。
将术语 Annotation 追加到 Node 的用户注释列表中。
将 Comments 追加到 Node 的后置注释中。
将 Comments 追加到 Node 的前置注释中。
创建一个抽象的带注释的类型表达式。
返回 annotated_type 节点的类型子树。
返回 annotated_type 节点的名称子树。
创建一个抽象的函数应用表达式。
创建一个抽象的函数应用表达式。
返回 application 节点的参数子树列表。
返回 application 节点的操作符子树。
创建一个抽象的元数限定符。
返回 arity_qualifier 节点的参数（元数）子树。
返回 arity_qualifier 节点的正文子树。
创建一个抽象的原子字面量。
返回 atom 节点表示的字面量字符串。
返回 atom 节点表示的字面量字符串。
返回 atom 节点的打印名称。
返回 atom 节点表示的值。
创建一个抽象的程序属性。
返回 attribute 节点的参数子树列表（如果有）。
返回 attribute 节点的名称子树。
创建一个抽象的二进制对象模板。
创建一个抽象的二进制推导式。
返回 binary_comp 节点的主体子树列表。
返回 binary_comp 节点的模板子树。
创建一个抽象的二进制模板字段。
创建一个抽象的二进制模板字段。
返回 binary_field 的主体子树。
返回 binary_field 节点的大小说明符子树（如果有）。
返回 binary_field 节点的类型说明符子树列表。
返回 binary 节点的字段子树列表。
创建一个抽象的 binary_generator。
返回 generator 节点的主体子树。
返回 generator 节点的模式子树。
创建一个抽象的位串类型。
返回 bitstring_type 节点的起始位数 M。
返回 bitstring_type 节点的段大小 N。
创建一个抽象的块表达式。
返回 block_expr 节点的主体子树列表。
创建一个抽象的 case 表达式。
返回 case_expr 节点的参数子树。
返回 case_expr 节点的子句子树列表。
创建一个抽象的 catch 表达式。
返回 catch_expr 节点的主体子树。
创建一个抽象的字符字面量。
返回 char 节点表示的字面量字符串。
返回 char 节点表示的字面量字符串。
返回 char 节点表示的值。
创建一个抽象的类限定符。
创建一个抽象的类限定符。
返回 class_qualifier 节点的参数（类）子树。
返回 class_qualifier 节点的主体子树。
返回 class_qualifier 节点的堆栈跟踪子树。
创建一个抽象的子句。
返回 clause 节点的主体子树列表。
返回 clause 节点的保护子树（如果有）。
返回 clause 节点的模式子树列表。
创建一个带有给定填充和文本的抽象注释。
返回注释之前的填充量，或 none。
返回抽象注释的文本行。
为抽象列表骨架生成最紧凑的形式。
返回语法树表示的 Erlang 术语。
创建一个抽象的合取。
返回 conjunction 节点的主体子树列表。
“优化”列表骨架 cons 操作。
创建一个抽象的约束函数类型。
返回 constrained_function_type 节点的函数约束子树。
返回 constrained_function_type 节点的函数类型子树。
创建一个抽象的（子类型）约束。
返回 constraint 节点的名称子树。
返回 constraint 节点的类型子树。
将用户注释列表从 Source 复制到 Target。
将属性从 Source 复制到 Target。
将前置和后置注释从 Source 复制到 Target。
将注释从 Source 复制到 Target。
仅用于特殊目的。返回语法树节点的关联数据。
创建一个抽象的析取。
返回 disjunction 节点的主体子树列表。
创建一个抽象的 else 表达式。
返回 else_expr 节点的子句子树列表。
创建一个抽象的文件结束标记。
创建一个抽象的错误标记。
返回 error_marker 节点的 ErrorInfo 结构。
扁平化 form_list 节点的子列表。
创建一个抽象的浮点字面量。
返回由 float 节点表示的数字字符串。
返回由 float 节点表示的值。
创建一个“源代码形式”的抽象序列。
返回 form_list 节点的子节点列表。
创建一个抽象的 fun 表达式。
返回 fun_expr 节点的元数。
返回 fun_expr 节点的子句子树列表。
创建一个任何类型的抽象 fun。
创建一个抽象的函数定义。
返回 function 节点的元数。
返回 function 节点的子句子树列表。
返回 function 节点的名称子树。
创建一个抽象的函数类型。
返回 function_type 节点的参数类型子树。
返回 function_type 节点的返回类型子树。
创建一个抽象的列表生成器。
返回 generator 节点的主体子树。
返回 generator 节点的模式子树。
返回与语法树关联的用户注释列表。
返回与语法树节点关联的属性的表示。
返回与 Node 关联的注释（参见 //stdlib/erl_anno）。
返回节点的关联后置注释。
返回节点的关联前置注释。
如果节点没有关联的注释，则返回 false，否则返回 true。
创建一个抽象的 if 表达式。
返回 if_expr 节点的子句子树列表。
创建一个抽象的“隐式 fun”表达式。
创建一个抽象的“隐式 fun”表达式。
创建一个抽象的模块限定的“隐式 fun”表达式。
返回 implicit_fun 节点的名称子树。
创建一个抽象的中缀运算符表达式。
返回 infix_expr 节点的左侧参数子树。
返回 infix_expr 节点的运算符子树。
返回 infix_expr 节点的右侧参数子树。
创建一个抽象的整数文字。
返回由 integer 节点表示的数字字符串。
创建一个抽象的范围类型。
返回 integer_range_type 节点的上限。
返回 integer_range_type 节点的下限。
返回由 integer 节点表示的值。
如果 Node 的类型为 atom 且表示 Value，则返回 true，否则返回 false。
如果 Node 的类型为 char 且表示 Value，则返回 true，否则返回 false。
如果 Node 是表示所谓的“源代码形式”的语法树，则返回 true，否则返回 false。
如果 Node 的类型为 integer 且表示 Value，则返回 true，否则返回 false。
如果 Node 是叶节点，则返回 true，否则返回 false。
如果 Node 的类型为 list 或 nil，则返回 true，否则返回 false。
如果 Node 表示文字项，则返回 true，否则返回 false。
如果 Node 表示一个正规列表，则返回 true，否则返回 false。
如果 Node 的类型为 string 且表示 Value，则返回 true，否则返回 false。
仅用于特殊目的。如果 Tree 是抽象语法树，则返回 true，否则返回 false。
将 Source 的注释附加到 Target 的当前注释中。
构造一个抽象的列表框架。
创建一个抽象的列表推导式。
返回 list_comp 节点的 body 子树列表。
返回 list_comp 节点的模板子树。
返回列表框架的元素子树列表。
返回 list 节点的头部元素子树。
返回列表框架的元素子树的数量。
返回 list 节点的前缀元素子树。
返回 list 节点的后缀子树（如果存在）。
返回 list 节点的尾部。
创建一个抽象的宏应用程序。
返回 macro 节点的参数子树列表（如果存在）。
返回 macro 节点的名称子树。
创建一个具有给定类型和子树的语法树。
创建一个抽象的映射推导式。
返回 map_comp 节点的 body 子树列表。
返回 map_comp 节点的模板子树。
创建一个抽象的映射表达式。
返回 map_expr 节点的参数子树（如果存在）。
返回 map_expr 节点的字段子树列表。
创建一个抽象的映射关联字段。
返回 map_field_assoc 节点的名称子树。
返回 map_field_assoc 节点的值子树。
创建一个抽象的映射精确字段。
返回 map_field_exact 节点的名称子树。
返回 map_field_exact 节点的值子树。
创建一个抽象的 map_generator。
返回 map_generator 节点的 body 子树。
返回 map_generator 节点的模式子树。
创建一个抽象的类型映射。
创建一个抽象的映射类型关联字段。
返回 map_type_assoc 节点的名称子树。
返回 map_type_assoc 节点的值子树。
创建一个抽象的映射类型精确字段。
返回 map_type_exact 节点的名称子树。
返回 map_type_exact 节点的值子树。
返回 map_type 节点的字段子树列表。
创建一个抽象的匹配表达式。
返回 match_expr 节点的 body 子树。
返回 match_expr 节点的模式子树。
创建一个抽象的 maybe 表达式。
返回 maybe_expr 节点的 body 子树列表。
返回 maybe_expr 节点的 else 子树。
创建一个抽象的 maybe 表达式，用于 maybe 块中。
返回 maybe_expr 节点的 body 子树。
返回 maybe_expr 节点的模式子树。
创建语法树的元表示。
创建一个抽象的模块限定符。
返回 module_qualifier 节点的参数（模块）子树。
返回 module_qualifier 节点的 body 子树。
创建一个抽象的命名 fun 表达式。
返回 named_fun_expr 节点的元数。
返回 named_fun_expr 节点的子句子树列表。
返回 named_fun_expr 节点的名称子树。
将抽象列表骨架展开为其最明确的形式。
创建一个抽象运算符。
返回 operator 节点表示的字面字符串。
返回 operator 节点的名称。
创建一个抽象的带括号的表达式。
返回 parentheses 节点的正文子树。
创建一个抽象的前缀运算符表达式。
返回 prefix_expr 节点的参数子树。
返回 prefix_expr 节点的运算符子树。
创建一个抽象的接收表达式。
返回 receive_expr 节点的动作正文子树列表。
返回 receive_expr 节点的子句子树列表。
返回 receive_expr 节点的超时子树（如果有）。
创建一个抽象的记录字段访问表达式。
返回 record_access 节点的参数子树。
返回 record_access 节点的字段子树。
返回 record_access 节点的类型子树。
创建一个抽象的记录表达式。
返回 record_expr 节点的参数子树（如果有）。
返回 record_expr 节点的字段子树列表。
返回 record_expr 节点的类型子树。
创建一个抽象的记录字段规范。
返回 record_field 节点的名称子树。
返回 record_field 节点的值子树（如果有）。
创建一个抽象的记录字段索引表达式。结果表示 "#Type.Field"。
返回 record_index_expr 节点的字段子树。
返回 record_index_expr 节点的类型子树。
创建一个抽象的记录类型。
创建一个抽象的记录类型字段。
返回 record_type_field 节点的名称子树。
返回 record_type_field 节点的类型子树。
返回 record_type 节点的字段子树。
返回 record_type 节点的名称子树。
清除与 节点 关联的注释。
如果可能，返回语法树的 erl_parse 兼容表示形式。
恢复 Erlang 源代码形式的序列。
将 节点 的用户注释列表设置为 注释。
将 节点 的属性设置为 属性。
将 节点 的位置信息设置为 位置。
将 节点 的后置注释设置为 注释。
将 节点 的前置注释设置为 注释。
创建一个抽象的大小限定符。
返回 size_qualifier 节点的参数子树（大小）。
返回 size_qualifier 节点的主体子树。
创建一个抽象的字符串字面量。
返回 string 节点表示的字面字符串。
返回 string 节点表示的字面字符串。
返回 string 节点表示的值。
返回语法树的所有子树的分组列表。
创建一个抽象的源代码文本片段。
返回 text 节点表示的字符序列。
等效于 tree(类型, [])。
仅用于特殊目的。创建一个具有类型标签 类型 和关联数据 数据 的抽象语法树节点。
创建一个抽象的 try 表达式。
返回 try_expr 节点的 "after" 子树列表。
返回 try_expr 节点的主体子树列表。
返回 try_expr 节点的 case 子句子树列表。如果 节点 表示 "try Body catch H1; ...; Hn end"，则结果为空列表。
返回 try_expr 节点的处理程序子句子树列表。
创建一个抽象的元组。
返回 tuple 节点的元素子树列表。
返回 tuple 节点的元素数量。
创建一个抽象的类型元组。
返回 tuple_type 节点的类型元素子树列表。
返回 节点 的类型标记。
创建一个抽象的类型应用表达式。
创建一个抽象的类型应用表达式。
返回 type_application 节点的参数子树。
返回 type_application 节点的类型名称子树。
创建一个抽象的类型联合。
返回 type_union 节点的类型子树列表。
创建一个抽象的带类型的记录字段规范。
返回 typed_record_field 节点的字段子树。
返回 typed_record_field 节点的类型子树。
创建一个抽象的通用模式（"_"）。
创建一个具有与给定树相同类型和属性的语法树。
创建一个抽象的用户类型。
返回 user_type_application 节点的参数子树。
返回 user_type_application 节点的类型名称子树。
创建一个具有给定名称的抽象变量。
返回 variable 节点的名称作为字符串。
返回 variable 节点的名称作为原子。
创建一个抽象的警告标记。
返回 warning_marker 节点的 ErrorInfo 结构。
类型
-type annotation_or_location() :: erl_anno:anno() | erl_anno:location().
-type encoding() :: utf8 | unicode | latin1.
-type erl_parse() :: erl_parse:abstract_clause() | erl_parse:abstract_expr() | erl_parse:abstract_form() | erl_parse:abstract_type() | erl_parse:form_info() | erl_parse:af_binelement(term()) | erl_parse:af_generator() | erl_parse:af_remote_function().
-type forms() :: syntaxTree() | [syntaxTree()].
-type guard() :: none | syntaxTree() | [syntaxTree()] | [[syntaxTree()]].
-type padding() :: none | integer().
-type syntaxTreeAttributes() :: #attr{pos :: term(), ann :: [term()], com :: none | #com{pre :: [syntaxTree()], post :: [syntaxTree()]}}.
-type tree() :: #tree{type :: atom(), attr :: #attr{pos :: term(), ann :: [term()], com :: none | #com{pre :: [syntaxTree()], post :: [syntaxTree()]}}, data :: term()}.
-type wrapper() :: #wrapper{type :: atom(), attr :: #attr{pos :: term(), ann :: [term()], com :: none | #com{pre :: [syntaxTree()], post :: [syntaxTree()]}}, tree :: erl_parse()}.
函数
-spec nil() -> syntaxTree().
创建一个抽象空列表。
结果表示 "[]"。空列表传统上称为“nil”。
另请参阅： is_list_skeleton/1、list/2。
-spec abstract(term()) -> syntaxTree().
返回与 Erlang 术语对应的语法树。
Term 必须是字面量，这意味着它可以表示为源代码字面量。因此，它不能包含进程标识符、端口、引用或函数值作为子项。该函数识别可打印的字符串，以便获得紧凑且可读的表示形式。如果 Term 不是字面量，则求值将失败并出现原因 badarg。
另请参阅： concrete/1、is_literal/1。
-spec add_ann(term(), syntaxTree()) -> syntaxTree().
将术语 Annotation 追加到 Node 的用户注释列表中。
注意：这等效于 set_ann(Node, [Annotation | get_ann(Node)])，但可能更有效率。
-spec add_postcomments([syntaxTree()], 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。
-spec add_precomments([syntaxTree()], 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。
-spec annotated_type(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的带注释的类型表达式。
结果表示“名称 :: 类型”。
-spec annotated_type_body(syntaxTree()) -> syntaxTree().
返回 annotated_type 节点的类型子树。
另请参阅：annotated_type/2。
-spec annotated_type_name(syntaxTree()) -> syntaxTree().
返回 annotated_type 节点的名称子树。
另请参阅：annotated_type/2。
-spec application(syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的函数应用表达式。
如果 Arguments 是 [A1, ..., An]，则结果表示 “Operator(A1, ..., An)”。
另请参阅：application/3、application_arguments/1、application_operator/1。
-spec application(none | syntaxTree(), syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的函数应用表达式。
如果 Module 为 none，则此调用等效于 application(Function, Arguments)；否则，等效于 application(module_qualifier(Module, Function), Arguments)。
（这是一个实用函数。）
-spec application_arguments(syntaxTree()) -> [syntaxTree()].
返回 application 节点的参数子树列表。
另请参阅：application/2。
-spec application_operator(syntaxTree()) -> syntaxTree().
返回 application 节点的操作符子树。
如果 Node 表示 “M:F(...)”，则结果是表示 “M:F” 的子树。
-spec arity_qualifier(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的元数限定符。
结果表示 “Body/Arity”。
-spec arity_qualifier_argument(syntaxTree()) -> syntaxTree().
返回 arity_qualifier 节点的参数（元数）子树。
另请参阅：arity_qualifier/2。
-spec arity_qualifier_body(syntaxTree()) -> syntaxTree().
返回 arity_qualifier 节点的正文子树。
另请参阅：arity_qualifier/2。
-spec atom(atom() | string()) -> syntaxTree().
创建一个抽象的原子字面量。
原子 (atom) 的打印名称是由 Name 表示的字符序列。
另请参阅：atom_literal/1、atom_literal/2、atom_name/1、atom_value/1、is_atom/2。
-spec atom_literal(syntaxTree()) -> string().
返回 atom 节点表示的字面量字符串。
这包括必要的周围单引号字符。超出 255 的字符将被转义。
请注意，例如，atom("x\ny") 的结果表示 'x\ny'、'x\12y'、'x\012y' 和 'x\^Jy' 中的任何一个和所有值；请参阅 string/1。
-spec atom_literal(syntaxTree(), utf8 | unicode | latin1) -> string().
返回 atom 节点表示的字面量字符串。
这包括必要的周围单引号字符。根据编码，超出 255 的字符将被转义 (latin1) 或按原样复制 (utf8)。
另请参阅：atom/1、atom_literal/1、string/1。
-spec atom_name(syntaxTree()) -> string().
返回 atom 节点的打印名称。
另请参阅：atom/1。
-spec atom_value(syntaxTree()) -> atom().
返回 atom 节点表示的值。
另请参阅：atom/1。
-spec attribute(syntaxTree()) -> syntaxTree().
-spec attribute(syntaxTree(), none | [syntaxTree()]) -> syntaxTree().
创建一个抽象的程序属性。
如果 Arguments 为 [A1, ..., An]，则结果表示 “-Name(A1, ..., An).”。否则，如果 Arguments 为 none，则结果表示 “-Name.”。后一种形式使得表示预处理器指令（如“-endif.”）成为可能。属性是源代码形式。
注意
预处理器宏定义指令 “
-define(Name, Body).” 对Body的语法形式（视为标记序列）的要求相对较少。text节点类型可用于不是普通 Erlang 结构的Body。
另请参阅：attribute/1、attribute_arguments/1、attribute_name/1、is_form/1、text/1。
-spec attribute_arguments(syntaxTree()) -> none | [syntaxTree()].
返回 attribute 节点的参数子树列表（如果有）。
如果 Node 表示 “-Name.”，则结果为 none。否则，如果 Node 表示 “-Name(E1, ..., En).”，则返回 [E1, ..., E1]。
另请参阅：attribute/1。
-spec attribute_name(syntaxTree()) -> syntaxTree().
返回 attribute 节点的名称子树。
另请参阅：attribute/1。
-spec binary([syntaxTree()]) -> syntaxTree().
创建一个抽象的二进制对象模板。
如果 Fields 为 [F1, ..., Fn]，则结果表示 “<<F1, ..., Fn>>”。
-spec binary_comp(syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的二进制推导式。
如果 Body 为 [E1, ..., En]，则结果表示 “<<Template || E1, ..., En>>”。
-spec binary_comp_body(syntaxTree()) -> [syntaxTree()].
返回 binary_comp 节点的主体子树列表。
另请参阅：binary_comp/2。
-spec binary_comp_template(syntaxTree()) -> syntaxTree().
返回 binary_comp 节点的模板子树。
另请参阅：binary_comp/2。
-spec binary_field(syntaxTree()) -> syntaxTree().
-spec binary_field(syntaxTree(), [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。
-spec binary_field(syntaxTree(), none | syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的二进制模板字段。
如果 Size 为 none，则等效于 “binary_field(Body, Types)”，否则等效于 “binary_field(size_qualifier(Body, Size), Types)”。
（这是一个实用函数。）
-spec binary_field_body(syntaxTree()) -> syntaxTree().
返回 binary_field 的主体子树。
另请参阅：binary_field/2。
-spec binary_field_size(syntaxTree()) -> none | syntaxTree().
返回 binary_field 节点的大小说明符子树（如果有）。
如果 Node 表示 “Body:Size” 或 “Body:Size/T1, ..., Tn”，则结果为 Size，否则返回 none。
（这是一个实用函数。）
另请参阅：binary_field/2、binary_field/3。
-spec binary_field_types(syntaxTree()) -> [syntaxTree()].
返回 binary_field 节点的类型说明符子树列表。
如果 Node 表示 “.../T1, ..., Tn”，则结果为 [T1, ..., Tn]，否则结果为空列表。
另请参阅：binary_field/2。
-spec binary_fields(syntaxTree()) -> [syntaxTree()].
返回 binary 节点的字段子树列表。
另请参阅：binary/1、binary_field/2。
-spec binary_generator(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的 binary_generator。
结果表示 “Pattern <= Body”。
另请参阅：binary_comp/2、binary_generator_body/1、binary_generator_pattern/1、list_comp/2、map_comp/2。
-spec binary_generator_body(syntaxTree()) -> syntaxTree().
返回 generator 节点的主体子树。
另请参阅：binary_generator/2。
-spec binary_generator_pattern(syntaxTree()) -> syntaxTree().
返回 generator 节点的模式子树。
另请参阅：binary_generator/2。
-spec bitstring_type(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的位串类型。
结果表示 “<<_:M, _:_N>>”。
-spec bitstring_type_m(syntaxTree()) -> syntaxTree().
返回 bitstring_type 节点的起始位数 M。
另请参阅：bitstring_type/2。
-spec bitstring_type_n(syntaxTree()) -> syntaxTree().
返回 bitstring_type 节点的段大小 N。
另请参阅：bitstring_type/2。
-spec block_expr([syntaxTree()]) -> syntaxTree().
创建一个抽象的块表达式。
如果 Body 为 [B1, ..., Bn]，则结果表示 “begin B1, ..., Bn end”。
另请参阅：block_expr_body/1。
-spec block_expr_body(syntaxTree()) -> [syntaxTree()].
返回 block_expr 节点的主体子树列表。
另请参阅：block_expr/1。
-spec case_expr(syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的 case 表达式。
如果 Clauses 为 [C1, ..., Cn]，则结果表示 “case Argument of C1; ...; Cn end”。更准确地说，如果每个 Ci 表示 “(Pi) Gi -> Bi”，则结果表示 “case Argument of P1G1 -> B1; ...; PnGn -> Bn end”。
另请参阅：case_expr_argument/1、case_expr_clauses/1、clause/3、if_expr/1。
-spec case_expr_argument(syntaxTree()) -> syntaxTree().
返回 case_expr 节点的参数子树。
另请参阅：case_expr/2。
-spec case_expr_clauses(syntaxTree()) -> [syntaxTree()].
返回 case_expr 节点的子句子树列表。
另请参阅：case_expr/2。
-spec catch_expr(syntaxTree()) -> syntaxTree().
创建一个抽象的 catch 表达式。
结果表示 “catch Expr”。
另请参阅：catch_expr_body/1。
-spec catch_expr_body(syntaxTree()) -> syntaxTree().
返回 catch_expr 节点的主体子树。
另请参阅：catch_expr/1。
-spec char(char()) -> syntaxTree().
创建一个抽象的字符字面量。
结果表示 “$Name”，其中 Name 对应于 Value。
注意
对应于特定字符值的文字不是唯一确定的。例如，字符 “a” 可以写成 “$a” 和 “$\141”，而 Tab 字符可以写成 “$\11”、“$\011” 或 “$\t”。
-spec char_literal(syntaxTree()) -> nonempty_string().
返回 char 节点表示的字面量字符串。
这包括前导 “$” 字符。超出 255 的字符将被转义。
另请参阅：char/1。
-spec char_literal(syntaxTree(), encoding()) -> nonempty_string().
返回 char 节点表示的字面量字符串。
这包括前导 “$” 字符。根据编码，超出 255 的字符将被转义 (latin1) 或按原样复制 (utf8)。
另请参阅：char/1。
-spec char_value(syntaxTree()) -> char().
返回 char 节点表示的值。
另请参阅：char/1。
-spec class_qualifier(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的类限定符。
结果表示 “Class:Body”。
另请参阅：class_qualifier_argument/1、class_qualifier_body/1、class_qualifier_stacktrace/1、try_expr/4。
-spec class_qualifier(syntaxTree(), syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的类限定符。
结果表示 “Class:Body:Stacktrace”。
另请参阅：class_qualifier_argument/1、class_qualifier_body/1、try_expr/4。
-spec class_qualifier_argument(syntaxTree()) -> syntaxTree().
返回 class_qualifier 节点的参数（类）子树。
另请参阅：class_qualifier/2。
-spec class_qualifier_body(syntaxTree()) -> syntaxTree().
返回 class_qualifier 节点的主体子树。
另请参阅：class_qualifier/2。
-spec class_qualifier_stacktrace(syntaxTree()) -> syntaxTree().
返回 class_qualifier 节点的堆栈跟踪子树。
另请参阅：class_qualifier/2。
-spec clause(guard(), [syntaxTree()]) -> syntaxTree().
-spec clause([syntaxTree()], guard(), [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。
-spec clause_body(syntaxTree()) -> [syntaxTree()].
返回 clause 节点的主体子树列表。
另请参阅：clause/3。
-spec clause_guard(syntaxTree()) -> none | syntaxTree().
返回 clause 节点的保护子树（如果有）。
如果 Node 表示 “(P1, ..., Pn) when Guard -> B1, ..., Bm”，则返回 Guard。否则，结果为 none。
另请参阅：clause/3。
-spec clause_patterns(syntaxTree()) -> [syntaxTree()].
返回 clause 节点的模式子树列表。
另请参阅：clause/3。
-spec comment([string()]) -> syntaxTree().
-spec comment(padding(), [string()]) -> syntaxTree().
创建一个带有给定填充和文本的抽象注释。
如果 Strings 是（可能为空）列表 ["Txt1", ..., "TxtN"]，则结果表示源代码文本
Txt1
...
TxtNPadding 表示在水平方向上，注释与同一行上的源代码（如果有）之间分隔的空字符位置的数量。如果 Padding 为 none，则使用默认的正数。如果 Padding 是小于 1 的整数，则不应有分隔空格。注释本身被视为源代码形式。
-spec comment_padding(syntaxTree()) -> padding().
返回注释之前的填充量，或 none。
none 表示可以使用默认填充。
另请参阅：comment/2。
-spec comment_text(syntaxTree()) -> [string()].
返回抽象注释的文本行。
另请参阅：comment/2。
-spec compact_list(syntaxTree()) -> syntaxTree().
为抽象列表骨架生成最紧凑的形式。
结果要么表示为 “[E1, ..., En | Tail]”，其中 Tail 不是列表骨架，要么简单地表示为 “[E1, ..., En]”。表示列表骨架的 Node 子树上的注解可能会丢失，但注释会传播到结果。如果 Node 不表示列表骨架，则返回 Node 本身。
另请参阅：list/2, normalize_list/1。
-spec concrete(syntaxTree()) -> term().
返回语法树表示的 Erlang 术语。
如果 Node 不表示字面量，则求值失败，原因是 badarg。
注意
具有具体表示的语法树集合大于可以使用函数
abstract/1构建的树集合。抽象字符将被具体化为整数，而abstract/1目前不会为任何输入生成抽象字符。（使用char/1函数显式创建抽象字符。）
注意
识别
arity_qualifier节点。这是为了遵循 Erlang 解析器处理通配属性的方式：{F, A}和F/A都被识别，这使得可以将通配属性转换为已识别的属性，同时又不会使使用旧版本 Erlang 编译器编译带有新语法的文件的操作变得不可能。
另请参阅：abstract/1, char/1, is_literal/1。
-spec conjunction([syntaxTree()]) -> syntaxTree().
创建一个抽象的合取。
如果 List 是 [E1, ..., En]，则结果表示为 “E1, ..., En”。
另请参阅：conjunction_body/1, disjunction/1。
-spec conjunction_body(syntaxTree()) -> [syntaxTree()].
返回 conjunction 节点的主体子树列表。
另请参阅：conjunction/1。
-spec cons(syntaxTree(), syntaxTree()) -> syntaxTree().
“优化”列表骨架 cons 操作。
创建一个抽象列表骨架，其第一个元素是 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。
-spec constrained_function_type(syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的约束函数类型。
如果 FunctionConstraint 是 [C1, ..., Cn]，则结果表示为 “FunctionType when C1, ...Cn”。
另请参阅：constrained_function_type_argument/1, constrained_function_type_body/1。
-spec constrained_function_type_argument(syntaxTree()) -> syntaxTree().
返回 constrained_function_type 节点的函数约束子树。
-spec constrained_function_type_body(syntaxTree()) -> syntaxTree().
返回 constrained_function_type 节点的函数类型子树。
-spec constraint(syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的（子类型）约束。
结果表示“名称 :: 类型”。
-spec constraint_argument(syntaxTree()) -> syntaxTree().
返回 constraint 节点的名称子树。
另请参阅：constraint/2。
-spec constraint_body(syntaxTree()) -> [syntaxTree()].
返回 constraint 节点的类型子树。
另请参阅：constraint/2。
-spec copy_ann(syntaxTree(), syntaxTree()) -> syntaxTree().
将用户注释列表从 Source 复制到 Target。
注意：这等效于 set_ann(Target, get_ann(Source))，但可能更有效率。
-spec copy_attrs(syntaxTree(), syntaxTree()) -> syntaxTree().
将属性从 Source 复制到 Target。
注意：这等效于 set_attrs(Target, get_attrs(Source))，但可能更有效率。
另请参阅：get_attrs/1, set_attrs/2。
-spec copy_comments(syntaxTree(), 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。
-spec copy_pos(syntaxTree(), syntaxTree()) -> syntaxTree().
将注释从 Source 复制到 Target。
这等效于 set_pos(Target, get_pos(Source))，但可能更有效率。
-spec data(syntaxTree()) -> term().
仅用于特殊目的。返回语法树节点的关联数据。
如果 is_tree(Node) 不返回 true，则求值失败，原因是 badarg。
另请参阅：tree/2。
-spec disjunction([syntaxTree()]) -> syntaxTree().
创建一个抽象的析取。
如果 List 是 [E1, ..., En]，则结果表示为 “E1; ...; En”。
另请参阅：conjunction/1, disjunction_body/1。
-spec disjunction_body(syntaxTree()) -> [syntaxTree()].
返回 disjunction 节点的主体子树列表。
另请参阅：disjunction/1。
-spec else_expr([syntaxTree()]) -> syntaxTree().
创建一个抽象的 else 表达式。
如果 Clauses 是 [C1, ..., Cn]，则结果表示为 “else C1; ...; Cn end”。更准确地说，如果每个 Ci 表示为 “(Pi) Gi -> Bi”，则结果表示为 “else (P1) G1 -> B1; ...; (Pn) Gn -> Bn end”。
另请参阅：clause/3, else_expr_clauses/1, maybe_expr/2。
-spec else_expr_clauses(syntaxTree()) -> [syntaxTree()].
返回 else_expr 节点的子句子树列表。
另请参阅：else_expr/1。
-spec eof_marker() -> syntaxTree().
创建一个抽象的文件结束标记。
这表示读取一系列源代码形式时的输入结束。文件结束标记本身被视为源代码形式（即，在其出现的任何序列中的最后一个）。它没有定义的词法形式。
注意
保留此项仅是为了向后兼容现有解析器和工具。
另请参阅：error_marker/1, is_form/1, warning_marker/1。
-spec error_marker(term()) -> syntaxTree().
创建一个抽象的错误标记。
结果表示源代码中出现错误，并带有由 Error 给出的关联 Erlang I/O ErrorInfo 结构（有关详细信息，请参阅模块 //stdlib/io）。错误标记被视为源代码形式，但没有定义的词法形式。
注意
仅为了向后兼容现有解析器和工具而支持此项。
另请参阅：eof_marker/0, error_marker_info/1, is_form/1, warning_marker/1。
-spec error_marker_info(syntaxTree()) -> term().
返回 error_marker 节点的 ErrorInfo 结构。
另请参阅：error_marker/1。
-spec flatten_form_list(syntaxTree()) -> syntaxTree().
扁平化 form_list 节点的子列表。
返回 Node，其中所有 form_list 类型的子树都递归展开，从而生成单个“扁平”的抽象形式序列。
另请参阅：form_list/1。
-spec float(float()) -> syntaxTree().
创建一个抽象的浮点字面量。
词法表示形式是 Value 的十进制浮点数。
另请参阅：float_literal/1, float_value/1。
-spec float_literal(syntaxTree()) -> string().
返回由 float 节点表示的数字字符串。
另请参阅：float/1。
-spec float_value(syntaxTree()) -> float().
返回由 float 节点表示的值。
请注意，通常不应比较浮点值的相等性。
另请参阅：float/1。
-spec form_list([syntaxTree()]) -> syntaxTree().
创建一个“源代码形式”的抽象序列。
如果 Forms 是 [F1, ..., Fn]，其中每个 Fi 都是一种形式（请参阅 is_form/1），则结果表示为
F1
...
Fn其中 Fi 由一个或多个换行符分隔。form_list 类型的节点本身被视为源代码形式；请参阅 flatten_form_list/1。
注意
这只是一种将源代码形式分组到单个语法树中的方法，通常用于形成 Erlang 模块定义。
-spec form_list_elements(syntaxTree()) -> [syntaxTree()].
返回 form_list 节点的子节点列表。
另请参阅：form_list/1。
-spec fun_expr([syntaxTree()]) -> syntaxTree().
创建一个抽象的 fun 表达式。
如果 Clauses 是 [C1, ..., Cn]，则结果表示为 “fun C1; ...; Cn end”。更准确地说，如果每个 Ci 表示为 “(Pi1, ..., Pim) Gi -> Bi”，则结果表示为 “fun (P11, ..., P1m) G1 -> B1; ...; (Pn1, ..., Pnm) Gn -> Bn end”。
-spec fun_expr_arity(syntaxTree()) -> arity().
返回 fun_expr 节点的元数。
结果是 fun 表达式的第一个子句中参数模式的数量；后续子句将被忽略。
如果 fun_expr_clauses(Node) 返回一个空列表，或者如果该列表的第一个元素不是 clause 类型的语法树 C，并且使得 clause_patterns(C) 是一个非空列表，则会引发异常。
另请参阅：clause/3, clause_patterns/1, fun_expr/1, fun_expr_clauses/1。
-spec fun_expr_clauses(syntaxTree()) -> [syntaxTree()].
返回 fun_expr 节点的子句子树列表。
另请参阅：fun_expr/1。
-spec fun_type() -> syntaxTree().
创建一个任何类型的抽象 fun。
结果表示为 “fun()”。
-spec function(syntaxTree(), [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。
-spec function_arity(syntaxTree()) -> arity().
返回 function 节点的元数。
结果是函数的第一个子句中参数模式的数量；后续子句将被忽略。
如果 function_clauses(Node) 返回一个空列表，或者如果该列表的第一个元素不是 clause 类型的语法树 C，并且使得 clause_patterns(C) 是一个非空列表，则会引发异常。
另请参阅：clause/3, clause_patterns/1, function/2, function_clauses/1。
-spec function_clauses(syntaxTree()) -> [syntaxTree()].
返回 function 节点的子句子树列表。
另请参阅：function/2。
-spec function_name(syntaxTree()) -> syntaxTree().
返回 function 节点的名称子树。
另请参阅：function/2。
-spec function_type(syntaxTree()) -> syntaxTree().
-spec function_type(any_arity | [syntaxTree()], syntaxTree()) -> syntaxTree().
创建一个抽象的函数类型。
如果 Arguments 是 [T1, ..., Tn] 并且 它出现在函数规范中，则结果表示 "(T1, ...Tn) -> Return"；否则，它表示 "fun((T1, ...Tn) -> Return)"。如果 Arguments 是 any_arity，则它表示 "fun((...) -> Return)"。
注意，对于 "FunctionType" 和 "fun(FunctionType)"，erl_parse 表示形式是相同的。
-spec function_type_arguments(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。
-spec function_type_return(syntaxTree()) -> syntaxTree().
返回 function_type 节点的返回类型子树。
另请参阅： function_type/1，function_type/2。
-spec generator(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的列表生成器。
结果表示 "Pattern <- Body"。
另请参阅： binary_comp/2，generator_body/1，generator_pattern/1，map_comp/2，list_comp/2。
-spec generator_body(syntaxTree()) -> syntaxTree().
返回 generator 节点的主体子树。
另请参阅： generator/2。
-spec generator_pattern(syntaxTree()) -> syntaxTree().
返回 generator 节点的模式子树。
另请参阅： generator/2。
-spec get_ann(syntaxTree()) -> [term()].
返回与语法树关联的用户注释列表。
对于新创建的节点，这是一个空列表。 注释可以是任何项。
另请参阅： get_attrs/1，set_ann/2。
-spec get_attrs(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。
-spec get_pos(syntaxTree()) -> annotation_or_location().
返回与 Node 关联的注释（参见 //stdlib/erl_anno）。
默认情况下，所有新树节点的相关位置信息都设置为整数零。 使用 //stdlib/erl_anno:location/1 或 //stdlib/erl_anno:line/1 获取位置信息。
另请参阅： get_attrs/1，set_pos/2。
-spec get_postcomments(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。
-spec get_precomments(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。
-spec has_comments(syntaxTree()) -> boolean().
如果节点没有关联的注释，则返回 false，否则返回 true。
注意：这等效于 (get_precomments(Node) == []) and (get_postcomments(Node) == [])，但可能更高效。
另请参阅： get_postcomments/1，get_precomments/1，remove_comments/1。
-spec if_expr([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。
-spec if_expr_clauses(syntaxTree()) -> [syntaxTree()].
返回 if_expr 节点的子句子树列表。
另请参阅： if_expr/1。
-spec implicit_fun(syntaxTree()) -> syntaxTree().
创建一个抽象的“隐式 fun”表达式。
结果表示 "fun Name"。 Name 应该表示 F/A 或 M:F/A
另请参阅： arity_qualifier/2，implicit_fun/2，implicit_fun/3，implicit_fun_name/1，module_qualifier/2。
-spec implicit_fun(syntaxTree(), none | syntaxTree()) -> syntaxTree().
创建一个抽象的“隐式 fun”表达式。
如果 Arity 是 none，则这等效于 implicit_fun(Name)，否则等效于 implicit_fun(arity_qualifier(Name, Arity))。
（这是一个实用函数。）
另请参阅： implicit_fun/1，implicit_fun/3。
-spec implicit_fun(none | syntaxTree(), syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的模块限定的“隐式 fun”表达式。
如果 Module 是 none，则这等效于 implicit_fun(Name, Arity)，否则等效于 implicit_fun(module_qualifier(Module, arity_qualifier(Name, Arity))。
（这是一个实用函数。）
另请参阅： implicit_fun/1，implicit_fun/2。
-spec implicit_fun_name(syntaxTree()) -> syntaxTree().
返回 implicit_fun 节点的名称子树。
如果 Node 表示 "fun N/A" 或 "fun M:N/A"，则结果是分别表示 "N/A" 或 "M:N/A" 的子树。
-spec infix_expr(syntaxTree(), syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的中缀运算符表达式。
结果表示 "Left Operator Right"。
另请参阅： infix_expr_left/1，infix_expr_operator/1，infix_expr_right/1，prefix_expr/2。
-spec infix_expr_left(syntaxTree()) -> syntaxTree().
返回 infix_expr 节点的左侧参数子树。
另请参阅： infix_expr/3。
-spec infix_expr_operator(syntaxTree()) -> syntaxTree().
返回 infix_expr 节点的运算符子树。
另请参阅： infix_expr/3。
-spec infix_expr_right(syntaxTree()) -> syntaxTree().
返回 infix_expr 节点的右侧参数子树。
另请参阅： infix_expr/3。
-spec integer(integer()) -> syntaxTree().
创建一个抽象的整数文字。
词法表示形式是 Value 的规范十进制数。
-spec integer_literal(syntaxTree()) -> string().
返回由 integer 节点表示的数字字符串。
另请参阅： integer/1。
-spec integer_range_type(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的范围类型。
结果表示 "Low .. High"。
-spec integer_range_type_high(syntaxTree()) -> syntaxTree().
返回 integer_range_type 节点的上限。
另请参阅： integer_range_type/2。
-spec integer_range_type_low(syntaxTree()) -> syntaxTree().
返回 integer_range_type 节点的下限。
另请参阅： integer_range_type/2。
-spec integer_value(syntaxTree()) -> integer().
返回由 integer 节点表示的值。
另请参阅： integer/1。
-spec is_atom(syntaxTree(), atom()) -> boolean().
如果 Node 的类型为 atom 且表示 Value，则返回 true，否则返回 false。
另请参阅：atom/1。
-spec is_char(syntaxTree(), char()) -> boolean().
如果 Node 的类型为 char 且表示 Value，则返回 true，否则返回 false。
另请参阅：char/1。
-spec is_form(syntaxTree()) -> boolean().
如果 Node 是表示所谓的“源代码形式”的语法树，则返回 true，否则返回 false。
形式是 Erlang 源代码单元，按顺序放置构成一个 Erlang 程序。 当前形式类型为
attributecommenterror_markereof_markerform_listfunctionwarning_markertext
另请参阅： attribute/2，comment/2，eof_marker/0，error_marker/1，form_list/1，function/2，type/1，warning_marker/1。
-spec is_integer(syntaxTree(), integer()) -> boolean().
如果 Node 的类型为 integer 且表示 Value，则返回 true，否则返回 false。
另请参阅： integer/1。
-spec is_leaf(syntaxTree()) -> boolean().
如果 Node 是叶节点，则返回 true，否则返回 false。
当前识别的叶节点类型为
atomcharcommenteof_markererror_markerfloatfun_typeintegerniloperatorstringtextunderscorevariablewarning_marker
只有当 map_expr 类型的节点没有参数且没有字段时，它才是叶节点。 只有当 map_type 类型的节点没有字段 (any_size) 时，它才是叶节点。 只有当 tuple 类型的节点的 arity 为零时，它才是叶节点。 只有当 tuple_type 类型的节点没有元素 (any_size) 时，它才是叶节点。
注意：并非所有字面量都是叶节点，反之亦然。 例如，arity 不为零的元组和非空列表可能是字面量，但不是叶节点。 另一方面，变量是叶节点，但不是字面量。
另请参阅： is_literal/1，type/1。
-spec is_list_skeleton(syntaxTree()) -> boolean().
如果 Node 的类型为 list 或 nil，则返回 true，否则返回 false。
-spec is_literal(syntaxTree()) -> boolean().
如果 Node 表示文字项，则返回 true，否则返回 false。
当且仅当 concrete(Node) 的值已定义时，此函数返回 true。
另请参阅： abstract/1，concrete/1。
-spec is_proper_list(syntaxTree()) -> boolean().
如果 Node 表示一个正规列表，则返回 true，否则返回 false。
合适的列表是一个列表骨架，其形式为 "[]" 或 "[E1, ..., En]" 或 "[... | Tail]"，其中递归地，Tail 也表示合适的列表。
注意
由于
Node是一个语法树，因此与其子树对应的实际运行时值通常可能是部分或完全未知的。 例如，如果Node表示 "[... | Ns]"（其中Ns是一个变量），则该函数将返回false，因为不知道Ns在运行时是否会绑定到列表。 反之，如果Node表示，例如，"[1, 2, 3]" 或 "[A | []]"，则该函数将返回true。
另请参阅： list/2。
-spec is_string(syntaxTree(), string()) -> boolean().
如果 Node 的类型为 string 且表示 Value，则返回 true，否则返回 false。
另请参阅： string/1。
-spec is_tree(syntaxTree()) -> boolean().
仅用于特殊目的。如果 Tree 是抽象语法树，则返回 true，否则返回 false。
注意
此函数对所有 "旧式" 兼容
erl_parse的 "解析树" 产生false。
另请参阅：tree/2。
-spec join_comments(syntaxTree(), 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。
-spec list([syntaxTree()]) -> syntaxTree().
等同于 list(List, none)。
-spec list([syntaxTree()], none | syntaxTree()) -> syntaxTree().
构造一个抽象的列表框架。
结果的类型为 list 或 nil。 如果 List 是一个非空列表 [E1, ..., En]，则结果的类型为 list，并且如果 Tail 为 none，则表示 "[E1, ..., En]"，否则表示 "[E1, ..., En | Tail]"。 如果 List 是空列表，则 Tail必须为 none，在这种情况下，结果的类型为 nil，并且表示 "[]"（请参阅 nil/0）。
列表作为语义对象（由单独的 "cons" 和 "nil" 项构成）与表示列表的各种语法形式之间的差异起初可能会令人困惑。此模块提供的函数既可以精确控制语法表示，也可以通过 cons 和 head/tail 操作进行简单的组合和解构。
注意
在
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。
-spec list_comp(syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的列表推导式。
如果 Body 是 [E1, ..., En]，则结果表示 "[Template || E1, ..., En]"。
-spec list_comp_body(syntaxTree()) -> [syntaxTree()].
返回 list_comp 节点的 body 子树列表。
另请参阅：list_comp/2。
-spec list_comp_template(syntaxTree()) -> syntaxTree().
返回 list_comp 节点的模板子树。
另请参阅：list_comp/2。
-spec list_elements(syntaxTree()) -> [syntaxTree()].
返回列表框架的元素子树列表。
Node 必须表示一个规范列表。例如，如果 Node 表示 "[X1, X2 | [X3, X4 | []]"，则 list_elements(Node) 会生成列表 [X1, X2, X3, X4]。
另请参阅：is_proper_list/1、list/2。
-spec list_head(syntaxTree()) -> syntaxTree().
返回 list 节点的头部元素子树。
如果 Node 表示 "[Head ...]"，则结果将表示 "Head"。
另请参阅：cons/2、list/2、list_tail/1。
-spec list_length(syntaxTree()) -> non_neg_integer().
返回列表框架的元素子树的数量。
Node 必须表示一个规范列表。例如，如果 Node 表示 "[X1 | [X2, X3 | [X4, X5, X6]]]"，则 list_length(Node) 返回整数 6。
注意
这等效于
length(list_elements(Node))，但可能效率更高。
-spec list_prefix(syntaxTree()) -> [syntaxTree()].
返回 list 节点的前缀元素子树。
如果 Node 表示 "[E1, ..., En]" 或 "[E1, ..., En | Tail]"，则返回的值是 [E1, ..., En]。
另请参阅： list/2。
-spec list_suffix(syntaxTree()) -> none | syntaxTree().
返回 list 节点的后缀子树（如果存在）。
如果 Node 表示 "[E1, ..., En | Tail]"，则返回的值是 Tail。否则，如果 Node 表示 "[E1, ..., En]"，则返回 none。
注意
即使此函数返回的
Tail不是none，如果尾部已显式给出且列表骨架未压缩（请参阅compact_list/1），则Tail的类型也可以是nil。
另请参阅：compact_list/1、list/2、nil/0。
-spec list_tail(syntaxTree()) -> syntaxTree().
返回 list 节点的尾部。
如果 Node 表示单元素列表 "[E]"，则结果的类型为 nil，表示 "[]"。如果 Node 表示 "[E1, E2 ...]"，则结果将表示 "[E2 ...]"，如果 Node 表示 "[Head | Tail]"，则结果将表示 "Tail"。
另请参阅：cons/2、list/2、list_head/1。
-spec macro(syntaxTree()) -> syntaxTree().
等同于 macro(Name, none)。
-spec macro(syntaxTree(), none | [syntaxTree()]) -> syntaxTree().
创建一个抽象的宏应用程序。
如果 Arguments 是 none，则结果表示 "?Name"；否则，如果 Arguments 是 [A1, ..., An]，则结果表示 "?Name(A1, ..., An)"。
注意：如果 Arguments 是空列表，则结果将因此表示 "?Name()"，包括一对匹配的括号。
预处理器对宏应用程序的参数（视为标记序列）施加的唯一语法限制是它们必须在括号、方括号、begin ... end、case ... end 等方面保持平衡。text 节点类型可用于表示不是常规 Erlang 结构的参数。
-spec macro_arguments(syntaxTree()) -> none | [syntaxTree()].
返回 macro 节点的参数子树列表（如果存在）。
如果 Node 表示 "?Name"，则返回 none。否则，如果 Node 表示 "?Name(A1, ..., An)"，则返回 [A1, ..., An]。
另请参阅：macro/2。
-spec macro_name(syntaxTree()) -> syntaxTree().
返回 macro 节点的名称子树。
另请参阅：macro/2。
-spec make_tree(atom(), [[syntaxTree()]]) -> syntaxTree().
创建一个具有给定类型和子树的语法树。
Type 必须是节点类型名称（请参阅 type/1），该名称不表示叶节点类型（请参阅 is_leaf/1）。Groups 必须是一个非空的语法树组列表，表示给定类型的节点的子树，按照它们在打印的程序文本中出现的从左到右的顺序，按类别分组，如 subtrees/1 所做的那样。
copy_attrs(Node, make_tree(type(Node), subtrees(Node))) 的结果（请参阅 update_tree/2）表示与原始 Node 相同的源代码文本，假设 subtrees(Node) 生成非空列表。但是，它不一定具有与 Node 相同的数据表示形式。
另请参阅：copy_attrs/2、is_leaf/1、subtrees/1、type/1、update_tree/2。
-spec map_comp(syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的映射推导式。
如果 Body 是 [E1, ..., En]，则结果表示 "#{Template || E1, ..., En}"。
-spec map_comp_body(syntaxTree()) -> [syntaxTree()].
返回 map_comp 节点的 body 子树列表。
另请参阅：map_comp/2。
-spec map_comp_template(syntaxTree()) -> syntaxTree().
返回 map_comp 节点的模板子树。
另请参阅：map_comp/2。
-spec map_expr([syntaxTree()]) -> syntaxTree().
-spec map_expr(none | syntaxTree(), [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。
-spec map_expr_argument(syntaxTree()) -> none | syntaxTree().
返回 map_expr 节点的参数子树（如果存在）。
如果 Node 表示 "#{...}"，则返回 none。否则，如果 Node 表示 "Argument#{...}"，则返回 Argument。
另请参阅：map_expr/2。
-spec map_expr_fields(syntaxTree()) -> [syntaxTree()].
返回 map_expr 节点的字段子树列表。
另请参阅：map_expr/2。
-spec map_field_assoc(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的映射关联字段。
结果表示 "Name => Value"。
另请参阅：map_expr/2、map_field_assoc_name/1、map_field_assoc_value/1。
-spec map_field_assoc_name(syntaxTree()) -> syntaxTree().
返回 map_field_assoc 节点的名称子树。
另请参阅：map_field_assoc/2。
-spec map_field_assoc_value(syntaxTree()) -> syntaxTree().
返回 map_field_assoc 节点的值子树。
另请参阅：map_field_assoc/2。
-spec map_field_exact(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的映射精确字段。
结果表示 "Name := Value"。
另请参阅：map_expr/2、map_field_exact_name/1、map_field_exact_value/1。
-spec map_field_exact_name(syntaxTree()) -> syntaxTree().
返回 map_field_exact 节点的名称子树。
另请参阅：map_field_exact/2。
-spec map_field_exact_value(syntaxTree()) -> syntaxTree().
返回 map_field_exact 节点的值子树。
另请参阅：map_field_exact/2。
-spec map_generator(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的 map_generator。
结果表示 "Pattern <- Body"。
另请参阅：binary_comp/2、list_comp/2、map_comp/2、map_generator_body/1、map_generator_pattern/1。
-spec map_generator_body(syntaxTree()) -> syntaxTree().
返回 map_generator 节点的 body 子树。
另请参阅：map_generator/2。
-spec map_generator_pattern(syntaxTree()) -> syntaxTree().
返回 map_generator 节点的模式子树。
另请参阅：map_generator/2。
-spec map_type() -> syntaxTree().
等同于 map_type(any_size)。
-spec map_type(any_size | [syntaxTree()]) -> syntaxTree().
创建一个抽象的类型映射。
如果 Fields 是 [F1, ..., Fn]，则结果表示 "#{F1, ..., Fn}"；否则，如果 Fields 是 any_size，则表示 "map/0"。
另请参阅：map_type_fields/1。
-spec map_type_assoc(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的映射类型关联字段。
结果表示 "Name => Value"。
另请参阅：map_type/1、map_type_assoc_name/1、map_type_assoc_value/1。
-spec map_type_assoc_name(syntaxTree()) -> syntaxTree().
返回 map_type_assoc 节点的名称子树。
另请参阅：map_type_assoc/2。
-spec map_type_assoc_value(syntaxTree()) -> syntaxTree().
返回 map_type_assoc 节点的值子树。
另请参阅：map_type_assoc/2。
-spec map_type_exact(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的映射类型精确字段。
结果表示 "Name := Value"。
另请参阅：map_type/1、map_type_exact_name/1、map_type_exact_value/1。
-spec map_type_exact_name(syntaxTree()) -> syntaxTree().
返回 map_type_exact 节点的名称子树。
另请参阅：map_type_exact/2。
-spec map_type_exact_value(syntaxTree()) -> syntaxTree().
返回 map_type_exact 节点的值子树。
另请参阅：map_type_exact/2。
-spec map_type_fields(syntaxTree()) -> any_size | [syntaxTree()].
返回 map_type 节点的字段子树列表。
如果 Node 表示 "map/0"，则返回 any_size；否则，如果 Node 表示 "#{F1, ..., Fn}"，则返回 [F1, ..., Fn]。
另请参阅：map_type/0、map_type/1。
-spec match_expr(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的匹配表达式。
结果表示 "Pattern = Body"。
-spec match_expr_body(syntaxTree()) -> syntaxTree().
返回 match_expr 节点的 body 子树。
另请参阅：match_expr/2。
-spec match_expr_pattern(syntaxTree()) -> syntaxTree().
返回 match_expr 节点的模式子树。
另请参阅：match_expr/2。
-spec maybe_expr([syntaxTree()]) -> syntaxTree().
-spec maybe_expr([syntaxTree()], none | syntaxTree()) -> syntaxTree().
创建一个抽象的 maybe 表达式。
如果 Body 是 [B1, ..., Bn]，且 OptionalElse 是 none，则结果表示 “maybe B1, ..., Bn end”。 如果 Body 是 [B1, ..., Bn]，且 OptionalElse 表示一个带有子句 [C1, ..., Cn] 的 else_expr 节点，则结果表示 “maybe B1, ..., Bn else C1; ..., Cn end”。
有关 erl_parse 子句的文档，请参阅 clause。
-spec maybe_expr_body(syntaxTree()) -> [syntaxTree()].
返回 maybe_expr 节点的 body 子树列表。
另请参阅：maybe_expr/2。
-spec maybe_expr_else(syntaxTree()) -> none | syntaxTree().
返回 maybe_expr 节点的 else 子树。
另请参阅：maybe_expr/2。
-spec maybe_match_expr(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的 maybe 表达式，用于 maybe 块中。
结果表示 “Pattern ?= Body”。
另请参阅：maybe_expr/2，maybe_match_expr_body/1，maybe_match_expr_pattern/1。
-spec maybe_match_expr_body(syntaxTree()) -> syntaxTree().
返回 maybe_expr 节点的 body 子树。
另请参阅：maybe_match_expr/2。
-spec maybe_match_expr_pattern(syntaxTree()) -> syntaxTree().
返回 maybe_expr 节点的模式子树。
另请参阅：maybe_match_expr/2。
-spec meta(syntaxTree()) -> syntaxTree().
创建语法树的元表示。
结果表示一个 Erlang 表达式 “MetaTree”，如果求值，它将生成一个新的语法树，该语法树表示与 Tree 相同的源代码文本（尽管实际的数据表示可能不同）。 MetaTree 所表示的表达式在抽象语法树实现所使用的数据结构方面是与实现无关的。附加到 Tree 节点的注释将被保留，但其他属性将丢失。
在 Tree 中，任何节点类型为 variable（请参阅 type/1），且其注释列表（请参阅 get_ann/1）包含原子 meta_var 的节点，在结果树中将保持不变，只是从其注释列表中删除一个 meta_var 实例。
函数 meta/1 的主要用途是将表示一段程序代码的数据结构 Tree 转换为一种在打印时与表示无关的形式。例如，假设 Tree 表示一个名为 “V” 的变量。然后（假设有一个用于打印语法树的函数 print/1），求值 print(abstract(Tree)) — 简单地使用 abstract/1 将实际的数据结构映射到语法树表示 — 将输出一个字符串，该字符串可能看起来像 “{tree, variable, ..., "V", ...}”，这显然取决于抽象语法树的实现。例如，这对于在文件中缓存语法树可能很有用。但是，在某些情况下，如在程序生成器生成器（带有两个“生成器”）中，这可能是不可接受的。改为使用 print(meta(Tree)) 将输出一个与表示无关的语法树生成表达式；在上述情况下，类似于 “erl_syntax:variable("V")”。
另请参阅：abstract/1，get_ann/1，type/1。
-spec module_qualifier(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的模块限定符。
结果表示 “Module:Body”。
-spec module_qualifier_argument(syntaxTree()) -> syntaxTree().
返回 module_qualifier 节点的参数（模块）子树。
另请参阅：module_qualifier/2。
-spec module_qualifier_body(syntaxTree()) -> syntaxTree().
返回 module_qualifier 节点的 body 子树。
另请参阅：module_qualifier/2。
-spec named_fun_expr(syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的命名 fun 表达式。
如果 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。
-spec named_fun_expr_arity(syntaxTree()) -> arity().
返回 named_fun_expr 节点的元数。
结果是命名函数表达式的第一个子句中的参数模式数量；忽略后续子句。
如果 named_fun_expr_clauses(Node) 返回一个空列表，或者如果该列表的第一个元素不是类型为 clause 的语法树 C，且 clause_patterns(C) 是一个非空列表，则会抛出异常。
另请参阅：clause/3，clause_patterns/1，named_fun_expr/2，named_fun_expr_clauses/1。
-spec named_fun_expr_clauses(syntaxTree()) -> [syntaxTree()].
返回 named_fun_expr 节点的子句子树列表。
另请参阅：named_fun_expr/2。
-spec named_fun_expr_name(syntaxTree()) -> syntaxTree().
返回 named_fun_expr 节点的名称子树。
另请参阅：named_fun_expr/2。
-spec normalize_list(syntaxTree()) -> syntaxTree().
将抽象列表骨架展开为其最明确的形式。
如果 Node 表示 “[E1, ..., En | Tail]”，则结果表示 “[E1 | ... [En | Tail1] ... ]”，其中 Tail1 是 normalize_list(Tail) 的结果。如果 Node 表示 “[E1, ..., En]”，则结果简单地表示 “[E1 | ... [En | []] ... ]”。如果 Node 不表示列表骨架，则返回 Node 本身。
另请参阅：compact_list/1，list/2。
-spec operator(atom() | string()) -> syntaxTree().
创建一个抽象运算符。
运算符的名称是由 Name 表示的字符序列。这类似于原子的打印名称，但运算符从不用单引号括起来；例如，operator('++') 的结果表示 “++” 而不是 “'++'”。
-spec operator_literal(syntaxTree()) -> string().
返回 operator 节点表示的字面字符串。
这只是作为字符串的运算符名称。
另请参阅：operator/1。
-spec operator_name(syntaxTree()) -> atom().
返回 operator 节点的名称。
请注意，名称以原子形式返回。
另请参阅：operator/1。
-spec parentheses(syntaxTree()) -> syntaxTree().
创建一个抽象的带括号的表达式。
结果表示 “(Body)”，与上下文无关。
另请参阅：parentheses_body/1。
-spec parentheses_body(syntaxTree()) -> syntaxTree().
返回 parentheses 节点的正文子树。
另请参阅：parentheses/1。
-spec prefix_expr(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的前缀运算符表达式。
结果表示 “Operator Argument”。
另请参阅：infix_expr/3，prefix_expr_argument/1，prefix_expr_operator/1。
-spec prefix_expr_argument(syntaxTree()) -> syntaxTree().
返回 prefix_expr 节点的参数子树。
另请参阅：prefix_expr/2。
-spec prefix_expr_operator(syntaxTree()) -> syntaxTree().
返回 prefix_expr 节点的运算符子树。
另请参阅：prefix_expr/2。
-spec receive_expr([syntaxTree()]) -> syntaxTree().
-spec receive_expr([syntaxTree()], none | syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的接收表达式。
如果 Timeout 是 none，则结果表示 “receive C1; ...; Cn end”（忽略 Action 参数）。否则，如果 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 中，如果没有指定超时部分，receive 表达式必须至少有一个子句。
另请参阅：case_expr/2，clause/3，receive_expr/1，receive_expr_action/1，receive_expr_clauses/1，receive_expr_timeout/1。
-spec receive_expr_action(syntaxTree()) -> [syntaxTree()].
返回 receive_expr 节点的动作正文子树列表。
如果 Node 表示 “receive C1; ...; Cn end”，则这是空列表。
另请参阅：receive_expr/3。
-spec receive_expr_clauses(syntaxTree()) -> [syntaxTree()].
返回 receive_expr 节点的子句子树列表。
另请参阅：receive_expr/3。
-spec receive_expr_timeout(syntaxTree()) -> none | syntaxTree().
返回 receive_expr 节点的超时子树（如果有）。
如果 Node 表示 “receive C1; ...; Cn end”，则返回 none。否则，如果 Node 表示 “receive C1; ...; Cn after Timeout -> ... end”，则返回 Timeout。
另请参阅：receive_expr/3。
-spec record_access(syntaxTree(), syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的记录字段访问表达式。
结果表示 “Argument#Type.Field”。
另请参阅：record_access_argument/1，record_access_field/1，record_access_type/1，record_expr/3。
-spec record_access_argument(syntaxTree()) -> syntaxTree().
返回 record_access 节点的参数子树。
另请参阅：record_access/3。
-spec record_access_field(syntaxTree()) -> syntaxTree().
返回 record_access 节点的字段子树。
另请参阅：record_access/3。
-spec record_access_type(syntaxTree()) -> syntaxTree().
返回 record_access 节点的类型子树。
另请参阅：record_access/3。
-spec record_expr(syntaxTree(), [syntaxTree()]) -> syntaxTree().
-spec record_expr(none | syntaxTree(), syntaxTree(), [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。
-spec record_expr_argument(syntaxTree()) -> none | syntaxTree().
返回 record_expr 节点的参数子树（如果有）。
如果 Node 表示 “#Type{...}”，则返回 none。否则，如果 Node 表示 “Argument#Type{...}”，则返回 Argument。
另请参阅：record_expr/3。
-spec record_expr_fields(syntaxTree()) -> [syntaxTree()].
返回 record_expr 节点的字段子树列表。
另请参阅：record_expr/3。
-spec record_expr_type(syntaxTree()) -> syntaxTree().
返回 record_expr 节点的类型子树。
另请参阅：record_expr/3。
-spec record_field(syntaxTree()) -> syntaxTree().
-spec record_field(syntaxTree(), none | syntaxTree()) -> syntaxTree().
创建一个抽象的记录字段规范。
如果 Value 是 none，则结果简单地表示 “Name”，否则它表示 “Name = Value”。
另请参阅：record_expr/3，record_field_name/1，record_field_value/1。
-spec record_field_name(syntaxTree()) -> syntaxTree().
返回 record_field 节点的名称子树。
另请参阅：record_field/2。
-spec record_field_value(syntaxTree()) -> none | syntaxTree().
返回 record_field 节点的值子树（如果有）。
如果 Node 表示 “Name”，则返回 none。否则，如果 Node 表示 “Name = Value”，则返回 Value。
另请参阅：record_field/2。
-spec record_index_expr(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的记录字段索引表达式。结果表示 "#Type.Field"。
注意
函数名
record_index/2由 Erlang 编译器保留，这就是为什么该名称不能用于此构造函数的原因。
另请参阅：record_expr/3，record_index_expr_field/1，record_index_expr_type/1。
-spec record_index_expr_field(syntaxTree()) -> syntaxTree().
返回 record_index_expr 节点的字段子树。
另请参阅：record_index_expr/2。
-spec record_index_expr_type(syntaxTree()) -> syntaxTree().
返回 record_index_expr 节点的类型子树。
另请参阅：record_index_expr/2。
-spec record_type(syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的记录类型。
如果 Fields 是 [F1, ..., Fn]，则结果表示 “#Name{F1, ..., Fn}”。
-spec record_type_field(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的记录类型字段。
结果表示“名称 :: 类型”。
-spec record_type_field_name(syntaxTree()) -> syntaxTree().
返回 record_type_field 节点的名称子树。
另请参阅：record_type_field/2。
-spec record_type_field_type(syntaxTree()) -> syntaxTree().
返回 record_type_field 节点的类型子树。
另请参阅：record_type_field/2。
-spec record_type_fields(syntaxTree()) -> [syntaxTree()].
返回 record_type 节点的字段子树。
另请参阅：record_type/2。
-spec record_type_name(syntaxTree()) -> syntaxTree().
返回 record_type 节点的名称子树。
另请参阅：record_type/2。
-spec remove_comments(syntaxTree()) -> syntaxTree().
清除与 节点 关联的注释。
注意：这等效于 set_precomments(set_postcomments(Node, []), [])，但可能更有效率。
-spec revert(syntaxTree()) -> syntaxTree().
如果可能，返回语法树的 erl_parse 兼容表示形式。
如果 Tree 表示格式良好的 Erlang 程序或表达式，则转换应该可以顺利进行。通常，如果转换失败（即，结果仍然是抽象语法树），则 is_tree/1 会产生 true，否则产生 false。
is_tree/1 测试并非完全万无一失。对于一些特殊的节点类型（例如 arity_qualifier），如果此类节点出现在不期望的上下文中，它将保持不变，作为结果中未还原的子树。只有当 Tree 实际上不代表合法的 Erlang 代码时，才会发生这种情况。
另请参阅： //stdlib/erl_parse，revert_forms/1。
恢复 Erlang 源代码形式的序列。
序列可以作为 form_list 语法树（可能是嵌套的）或作为“程序形式”语法树的列表给出。如果成功，则返回相应的 erl_parse 兼容语法树的扁平列表（参见 revert/1）。如果某些程序形式无法还原，则会抛出 {error, Form}。表单序列中的独立注释将被丢弃。
另请参阅： form_list/1，is_form/1，revert/1。
-spec set_ann(syntaxTree(), [term()]) -> syntaxTree().
将 节点 的用户注释列表设置为 注释。
另请参阅： add_ann/2，copy_ann/2，get_ann/1。
-spec set_attrs(syntaxTree(), syntaxTreeAttributes()) -> syntaxTree().
将 节点 的属性设置为 属性。
另请参阅： copy_attrs/2，get_attrs/1。
-spec set_pos(syntaxTree(), annotation_or_location()) -> syntaxTree().
将 节点 的位置信息设置为 位置。
另请参阅： copy_pos/2，get_pos/1。
-spec set_postcomments(syntaxTree(), [syntaxTree()]) -> syntaxTree().
将 节点 的后置注释设置为 注释。
Comments 应该是抽象注释的列表（可能为空），按自上而下的文本顺序排列。
另请参阅： add_postcomments/2，comment/2，copy_comments/2，get_postcomments/1，join_comments/2，remove_comments/1，set_precomments/2。
-spec set_precomments(syntaxTree(), [syntaxTree()]) -> syntaxTree().
将 节点 的前置注释设置为 注释。
Comments 应该是抽象注释的列表（可能为空），按自上而下的文本顺序排列。
另请参阅： add_precomments/2，comment/2，copy_comments/2，get_precomments/1，join_comments/2，remove_comments/1，set_postcomments/2。
-spec size_qualifier(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的大小限定符。
结果表示 "Body:Size"。
-spec size_qualifier_argument(syntaxTree()) -> syntaxTree().
返回 size_qualifier 节点的参数子树（大小）。
另请参阅： size_qualifier/2。
-spec size_qualifier_body(syntaxTree()) -> syntaxTree().
返回 size_qualifier 节点的主体子树。
另请参阅： size_qualifier/2。
-spec string(string()) -> syntaxTree().
创建一个抽象的字符串字面量。
结果表示 "Text"（包括周围的双引号），其中 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。
-spec string_literal(syntaxTree()) -> nonempty_string().
返回 string 节点表示的字面字符串。
这包括周围的双引号字符。超过 255 的字符将被转义。
另请参阅： string/1。
-spec string_literal(syntaxTree(), encoding()) -> nonempty_string().
返回 string 节点表示的字面字符串。
这包括周围的双引号字符。根据编码，超过 255 的字符将被转义 (latin1) 或按原样复制 (utf8)。
另请参阅： string/1。
-spec string_value(syntaxTree()) -> string().
返回 string 节点表示的值。
另请参阅： string/1。
-spec subtrees(syntaxTree()) -> [[syntaxTree()]].
返回语法树的所有子树的分组列表。
如果 Node 是一个叶节点（参见 is_leaf/1），则这是一个空列表，否则结果始终是一个非空列表，其中包含 Node 的子树列表，按照它们在打印的程序文本中出现的从左到右的顺序排列，并按类别分组。通常，每个组只包含一个子树。
根据 Node 的类型，某些组的大小可能是可变的（例如，由元组的所有元素组成的组），而其他组始终包含相同数量的元素 - 通常正好一个（例如，包含 case 表达式的参数表达式的组）。但是，请注意，返回列表的确切结构（对于给定的节点类型）通常不应依赖，因为它可能会在不另行通知的情况下更改。
如果想要遍历语法树，访问其所有子树，但在大多数或所有情况下以统一的方式处理树的节点，则函数 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 <- Group]
|| Group <- List])
end).将函数 F 映射到 Tree 及其所有子树上，对语法树执行后序遍历。（请注意使用 update_tree/2 来保留节点属性。）对于一个简单的函数，例如
f(Node) ->
case type(Node) of
atom -> atom("a_" ++ atom_name(Node));
_ -> Node
end.调用 postorder(fun f/1, Tree) 将产生 Tree 的新表示形式，其中所有原子名称都已使用前缀 "a_" 扩展，但其他任何内容（包括注释、注释和行号）都未更改。
另请参阅： copy_attrs/2，is_leaf/1，make_tree/2，type/1。
-spec text(string()) -> syntaxTree().
创建一个抽象的源代码文本片段。
结果完全表示 String 中的字符序列。这在需要完全控制结果输出（例如浮点数或宏定义的外观）的情况下很有用。
另请参阅： text_string/1。
-spec text_string(syntaxTree()) -> string().
返回 text 节点表示的字符序列。
另请参阅： text/1。
等效于 tree(类型, [])。
仅用于特殊目的。创建一个具有类型标签 类型 和关联数据 数据 的抽象语法树节点。
此函数以及相关的 is_tree/1 和 data/1 提供了一种统一的方式来扩展 erl_parse 节点类型的集合。关联的数据是任何项，其格式可能取决于类型标记。
注意
-spec try_after_expr([syntaxTree()], [syntaxTree()]) -> syntaxTree().
-spec try_expr([syntaxTree()], [syntaxTree()]) -> syntaxTree().
-spec try_expr([syntaxTree()], [syntaxTree()], [syntaxTree()]) -> syntaxTree().
-spec try_expr([syntaxTree()], [syntaxTree()], [syntaxTree()], [syntaxTree()]) -> syntaxTree().
创建一个抽象的 try 表达式。
如果 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。
-spec try_expr_after(syntaxTree()) -> [syntaxTree()].
返回 try_expr 节点的 "after" 子树列表。
另请参阅： try_expr/4。
-spec try_expr_body(syntaxTree()) -> [syntaxTree()].
返回 try_expr 节点的主体子树列表。
另请参阅： try_expr/4。
-spec try_expr_clauses(syntaxTree()) -> [syntaxTree()].
返回 try_expr 节点的 case 子句子树列表。如果 节点 表示 "try Body catch H1; ...; Hn end"，则结果为空列表。
另请参阅： try_expr/4。
-spec try_expr_handlers(syntaxTree()) -> [syntaxTree()].
返回 try_expr 节点的处理程序子句子树列表。
另请参阅： try_expr/4。
-spec tuple([syntaxTree()]) -> syntaxTree().
创建一个抽象的元组。
如果 Elements 为 [X1, ..., Xn]，则结果表示 "{X1, ..., Xn}"。
注意
Erlang 语言具有不同的 1 元组，这意味着
{X}始终与X本身不同。
另请参阅： tuple_elements/1，tuple_size/1。
-spec tuple_elements(syntaxTree()) -> [syntaxTree()].
返回 tuple 节点的元素子树列表。
另请参阅： tuple/1。
-spec tuple_size(syntaxTree()) -> non_neg_integer().
返回 tuple 节点的元素数量。
注意
这等效于
length(tuple_elements(Node))，但可能更高效。
另请参阅： tuple/1，tuple_elements/1。
-spec tuple_type() -> syntaxTree().
等效于 tuple_type(any_size)。
-spec tuple_type(any_size | [syntaxTree()]) -> syntaxTree().
创建一个抽象的类型元组。
如果 Elements 为 [T1, ..., Tn]，则结果表示 "{T1, ..., Tn}"；否则，如果 Elements 为 any_size，则表示 "tuple/0"。
另请参阅： tuple_type_elements/1。
-spec tuple_type_elements(syntaxTree()) -> any_size | [syntaxTree()].
返回 tuple_type 节点的类型元素子树列表。
如果 Node 表示 "tuple/0"，则返回 any_size；否则，如果 Node 表示 "{T1, ..., Tn}"，则返回 [T1, ..., Tn]。
另请参阅： tuple_type/0，tuple_type/1。
-spec type(syntaxTree()) -> atom().
返回 节点 的类型标记。
如果 Node 不表示语法树，则评估会因原因 badarg 而失败。此模块当前定义的节点类型为
applicationannotated_typearity_qualifieratomattributebinarybinary_fieldbitstring_typeblock_exprcase_exprcatch_exprcharclass_qualifierclausecommentconjunctionconstrained_function_typeconstraintdisjunctionelse_expreof_markererror_markerfloatform_listfun_exprfun_typefunctionfunction_typegeneratorif_exprimplicit_funinfix_exprintegerinteger_range_typelistlist_compmacromap_exprmap_field_assocmap_field_exactmap_typemap_type_assocmap_type_exactmatch_exprmaybe_exprmaybe_match_exprmodule_qualifiernamed_fun_exprniloperatorparenthesesprefix_exprreceive_exprrecord_accessrecord_exprrecord_fieldrecord_index_exprrecord_typerecord_type_fieldsize_qualifierstringtexttry_exprtupletuple_typetyped_record_fieldtype_applicationtype_unionunderscoreuser_type_applicationvariablewarning_marker
用户可以（出于特殊目的）使用 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、conjunction/1、constrained_function_type/2、constraint/2、disjunction/1、else_expr/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、maybe_expr/1、maybe_expr/2、maybe_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。
-spec type_application(syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的类型应用表达式。
如果 Arguments 为 [T1, ..., Tn]，则结果表示 "TypeName(T1, ...Tn)"。
另请参阅： type_application/3、type_application_arguments/1、type_application_name/1、user_type_application/2。
-spec type_application(none | syntaxTree(), syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的类型应用表达式。
如果 Module 为 none，则此调用等效于 type_application(TypeName, Arguments)，否则等效于 type_application(module_qualifier(Module, TypeName), Arguments)。
（这是一个实用函数。）
-spec type_application_arguments(syntaxTree()) -> [syntaxTree()].
返回 type_application 节点的参数子树。
另请参阅： type_application/2。
-spec type_application_name(syntaxTree()) -> syntaxTree().
返回 type_application 节点的类型名称子树。
另请参阅： type_application/2。
-spec type_union([syntaxTree()]) -> syntaxTree().
创建一个抽象的类型联合。
如果 Types 为 [T1, ..., Tn]，则结果表示 "T1 | ... | Tn"。
另请参阅： type_union_types/1。
-spec type_union_types(syntaxTree()) -> [syntaxTree()].
返回 type_union 节点的类型子树列表。
另请参阅： type_union/1。
-spec typed_record_field(syntaxTree(), syntaxTree()) -> syntaxTree().
创建一个抽象的带类型的记录字段规范。
结果表示 "Field :: Type"。
-spec typed_record_field_body(syntaxTree()) -> syntaxTree().
返回 typed_record_field 节点的字段子树。
另请参阅： typed_record_field/2。
-spec typed_record_field_type(syntaxTree()) -> syntaxTree().
返回 typed_record_field 节点的类型子树。
另请参阅： typed_record_field/2。
-spec underscore() -> syntaxTree().
创建一个抽象的通用模式（"_"）。
词法表示为单个下划线字符。请注意，从词法上讲，这不是一个变量。
另请参阅： variable/1。
-spec update_tree(syntaxTree(), [[syntaxTree()]]) -> syntaxTree().
创建一个具有与给定树相同类型和属性的语法树。
这等效于 copy_attrs(Node, make_tree(type(Node), Groups))。
另请参阅： copy_attrs/2、make_tree/2、type/1。
-spec user_type_application(syntaxTree(), [syntaxTree()]) -> syntaxTree().
创建一个抽象的用户类型。
如果 Arguments 为 [T1, ..., Tn]，则结果表示 "TypeName(T1, ...Tn)"。
另请参阅： type_application/2、user_type_application_arguments/1、user_type_application_name/1。
-spec user_type_application_arguments(syntaxTree()) -> [syntaxTree()].
返回 user_type_application 节点的参数子树。
另请参阅： user_type_application/2。
-spec user_type_application_name(syntaxTree()) -> syntaxTree().
返回 user_type_application 节点的类型名称子树。
另请参阅： user_type_application/2。
-spec variable(atom() | string()) -> syntaxTree().
创建一个具有给定名称的抽象变量。
Name 可以是任何表示词法有效变量名称的原子或字符串，但不能是单个下划线字符；请参阅 underscore/0。
注意
不会执行检查来验证字符序列是否表示正确的变量名称，即其第一个字符是否是大写的 Erlang 字符，或者是否包含非法字符（例如控制字符或空格）。
-spec variable_literal(syntaxTree()) -> string().
返回 variable 节点的名称作为字符串。
另请参阅： variable/1。
-spec variable_name(syntaxTree()) -> atom().
返回 variable 节点的名称作为原子。
另请参阅： variable/1。
-spec warning_marker(term()) -> syntaxTree().
创建一个抽象的警告标记。
结果表示源代码中可能出现的问题，以及由 Error 给出的关联 Erlang I/O ErrorInfo 结构（有关详细信息，请参见模块 //stdlib/io）。警告标记被视为源代码形式，但没有定义的词法形式。
注意
仅为了向后兼容现有解析器和工具而支持此项。
另请参阅： eof_marker/0、error_marker/1、is_form/1、warning_marker_info/1。
-spec warning_marker_info(syntaxTree()) -> term().
返回 warning_marker 节点的 ErrorInfo 结构。
另请参阅： warning_marker/1。