PageRenderTime 95ms CodeModel.GetById 27ms RepoModel.GetById 0ms app.codeStats 1ms

/lib/syntax_tools/doc/erl_syntax.html

https://github.com/babo/jungerl
HTML | 2608 lines | 2317 code | 291 blank | 0 comment | 0 complexity | c88080a99e6714ed35d735276bae267c MD5 | raw file
Possible License(s): LGPL-2.1, BSD-3-Clause, AGPL-1.0 
    

  1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    2. 

  2. <html>
    3. 

  3. <head>
    4. 

  4. <title>Module erl_syntax</title>
    5. 

  5. <link rel="stylesheet" type="text/css" href="stylesheet.css">
    6. 

  6. </head>
    7. 

  7. <body bgcolor="white">
    8. 

  8. <h1>Module erl_syntax</h1>
    9. 

  9. Abstract Erlang syntax trees.<ul><li><a href="#description">Description</a></li><li><a href="#types">Data Types</a></li><li><a href="#index">Function Index</a></li><li><a href="#functions">Function Details</a></li></ul><h2><a name="description">Description</a></h2>Abstract Erlang syntax trees.
    10. 

  10.  
    11. 

  11.   <p> This module defines an abstract data type for representing Erlang
    12. 

  12.   source code as syntax trees, in a way that is backwards compatible
    13. 

  13.   with the data structures created by the Erlang standard library
    14. 

  14.   parser module <code>erl_parse</code> (often referred to as "parse
    15. 

  15.   trees", which is a bit of a misnomer). This means that all
    16. 

  16.   <code>erl_parse</code> trees are valid abstract syntax trees, but the
    17. 

  17.   reverse is not true: abstract syntax trees can in general not be used
    18. 

  18.   as input to functions expecting an <code>erl_parse</code> tree.
    19. 

  19.   However, as long as an abstract syntax tree represents a correct
    20. 

  20.   Erlang program, the function <a href="#revert-1"><code>revert/1</code></a> should be able to
    21. 

  21.   transform it to the corresponding <code>erl_parse</code>
    22. 

  22.   representation.</p>
    23. 

  23.  
    24. 

  24.   <p>A recommended starting point for the first-time user is the
    25. 

  25.   documentation of the <a href="#type-syntaxTree"><code>syntaxTree()</code></a> data type, and
    26. 

  26.   the function <a href="#type-1"><code>type/1</code></a>.</p>
    27. 

  27.  
    28. 

  28.   <h3><b>NOTES:</b></h3>
    29. 

  29.  
    30. 

  30.   <p>This module deals with the composition and decomposition of
    31. 

  31.   <em>syntactic</em> entities (as opposed to semantic ones); its
    32. 

  32.   purpose is to hide all direct references to the data structures used
    33. 

  33.   to represent these entities. With few exceptions, the functions in
    34. 

  34.   this module perform no semantic interpretation of their inputs, and
    35. 

  35.   in general, the user is assumed to pass type-correct arguments - if
    36. 

  36.   this is not done, the effects are not defined.</p>
    37. 

  37.  
    38. 

  38.   <p>With the exception of the <code>erl_parse</code> data structures,
    39. 

  39.   the internal representations of abstract syntax trees are subject to
    40. 

  40.   change without notice, and should not be documented outside this
    41. 

  41.   module. Furthermore, we do not give any guarantees on how an abstract
    42. 

  42.   syntax tree may or may not be represented, <em>with the following
    43. 

  43.   exceptions</em>: no syntax tree is represented by a single atom, such
    44. 

  44.   as <code>none</code>, by a list constructor <code>[X | Y]</code>, or
    45. 

  45.   by the empty list <code>[]</code>. This can be relied on when writing
    46. 

  46.   functions that operate on syntax trees.</p>
    47. 

  47.  
    48. 

  48. <h2><a name="types">Data Types</a></h2>
    49. 

  49. 

  50. <h3><a name="type-erl_parse">erl_parse()</a></h3>
    51. 

  51. <p><tt>erl_parse() = <a href="/usr/local/home/richardc/hipe/otp/lib/stdlib/doc/erl_parse.html#type-parse_tree">erl_parse:parse_tree()</a></tt></p>
    52. 

  52. <p>The "parse tree"
    53. 

  53.   representation built by the Erlang standard library parser
    54. 

  54.   <code>erl_parse</code>. This is a subset of the
    55. 

  55.   <a href="#type-syntaxTree"><code>syntaxTree</code></a> type.
    56. 

  56.  </p>
    57. 

  57. 

  58. <h3><a name="type-syntaxTree">syntaxTree()</a></h3>
    59. 

  59. <p><b>abstract datatype</b>: <tt>syntaxTree()</tt></p>
    60. 

  60. <p>An abstract syntax tree. The
    61. 

  61.   <code>erl_parse</code> "parse tree" representation is a subset of the
    62. 

  62.   <code>syntaxTree()</code> representation.
    63. 

  63.  
    64. 

  64.   <p>Every abstract syntax tree node has a <em>type</em>, given by the
    65. 

  65.   function <a href="#type-1"><code>type/1</code></a>. Each node also
    66. 

  66.   has associated <em>attributes</em>; see <a href="#get_attrs-1"><code>get_attrs/1</code></a> for details. The
    67. 

  67.   functions <a href="#make_tree-2"><code>make_tree/2</code></a> and <a href="#subtrees-1"><code>subtrees/1</code></a> are generic
    68. 

  68.   constructor/decomposition functions for abstract syntax trees. The
    69. 

  69.   functions <a href="#abstract-1"><code>abstract/1</code></a> and <a href="#concrete-1"><code>concrete/1</code></a> convert between
    70. 

  70.   constant Erlang terms and their syntactic representations. The set of
    71. 

  71.   syntax tree nodes is extensible through the <a href="#tree-2"><code>tree/2</code></a> function.</p>
    72. 

  72.  
    73. 

  73.   <p>A syntax tree can be transformed to the <code>erl_parse</code>
    74. 

  74.   representation with the <a href="#revert-1"><code>revert/1</code></a>
    75. 

  75.   function.</p>
    76. 

  76.  </p>
    77. 

  77. 

  78. <h3><a name="type-syntaxTreeAttributes">syntaxTreeAttributes()</a></h3>
    79. 

  79. <p><b>abstract datatype</b>: <tt>syntaxTreeAttributes()</tt></p>
    80. 

  80. <p>This is an abstract representation of
    81. 

  81.   syntax tree node attributes; see the function <a href="#get_attrs-1"><code>get_attrs/1</code></a>.
    82. 

  82.  </p>
    83. 

  83. 

  84. <h2><a name="index">Function Index</a></h2>
    85. 

  85. <table width="100%" border="1"><tr><td valign="top"><a href="#abstract-1">abstract/1</a></td><td>Returns the syntax tree corresponding to an Erlang term.</td></tr>
    86. 

  86. <tr><td valign="top"><a href="#add_ann-2">add_ann/2</a></td><td>Appends the term <code>Annotation</code> to the list of user
    87. 

  87.   annotations of <code>Node</code>.</td></tr>
    88. 

  88. <tr><td valign="top"><a href="#add_postcomments-2">add_postcomments/2</a></td><td>Appends <code>Comments</code> to the post-comments of
    89. 

  89.   <code>Node</code>.</td></tr>
    90. 

  90. <tr><td valign="top"><a href="#add_precomments-2">add_precomments/2</a></td><td>Appends <code>Comments</code> to the pre-comments of
    91. 

  91.   <code>Node</code>.</td></tr>
    92. 

  92. <tr><td valign="top"><a href="#application-2">application/2</a></td><td>Creates an abstract function application expression.</td></tr>
    93. 

  93. <tr><td valign="top"><a href="#application-3">application/3</a></td><td>Creates an abstract function application expression.</td></tr>
    94. 

  94. <tr><td valign="top"><a href="#application_arguments-1">application_arguments/1</a></td><td>Returns the list of argument subtrees of an
    95. 

  95.   <code>application</code> node.</td></tr>
    96. 

  96. <tr><td valign="top"><a href="#application_operator-1">application_operator/1</a></td><td>Returns the operator subtree of an <code>application</code>
    97. 

  97.   node.</td></tr>
    98. 

  98. <tr><td valign="top"><a href="#arity_qualifier-2">arity_qualifier/2</a></td><td>Creates an abstract arity qualifier.</td></tr>
    99. 

  99. <tr><td valign="top"><a href="#arity_qualifier_argument-1">arity_qualifier_argument/1</a></td><td>Returns the argument (the arity) subtree of an
    100. 

  100.   <code>arity_qualifier</code> node.</td></tr>
    101. 

  101. <tr><td valign="top"><a href="#arity_qualifier_body-1">arity_qualifier_body/1</a></td><td>Returns the body subtree of an <code>arity_qualifier</code>
    102. 

  102.   node.</td></tr>
    103. 

  103. <tr><td valign="top"><a href="#atom-1">atom/1</a></td><td>Creates an abstract atom literal.</td></tr>
    104. 

  104. <tr><td valign="top"><a href="#atom_literal-1">atom_literal/1</a></td><td>Returns the literal string represented by an <code>atom</code>
    105. 

  105.   node.</td></tr>
    106. 

  106. <tr><td valign="top"><a href="#atom_name-1">atom_name/1</a></td><td>Returns the printname of an <code>atom</code> node.</td></tr>
    107. 

  107. <tr><td valign="top"><a href="#atom_value-1">atom_value/1</a></td><td>Returns the value represented by an <code>atom</code> node.</td></tr>
    108. 

  108. <tr><td valign="top"><a href="#attribute-1">attribute/1</a></td><td><p>Equivalent to <a href="#attribute-2"><tt>attribute(Name, none)</tt></a>.</p>
    109. 

  109. </td></tr>
    110. 

  110. <tr><td valign="top"><a href="#attribute-2">attribute/2</a></td><td>Creates an abstract program attribute.</td></tr>
    111. 

  111. <tr><td valign="top"><a href="#attribute_arguments-1">attribute_arguments/1</a></td><td>Returns the list of argument subtrees of an
    112. 

  112.   <code>attribute</code> node, if any.</td></tr>
    113. 

  113. <tr><td valign="top"><a href="#attribute_name-1">attribute_name/1</a></td><td>Returns the name subtree of an <code>attribute</code> node.</td></tr>
    114. 

  114. <tr><td valign="top"><a href="#binary-1">binary/1</a></td><td>Creates an abstract binary-object template.</td></tr>
    115. 

  115. <tr><td valign="top"><a href="#binary_field-1">binary_field/1</a></td><td><p>Equivalent to <a href="#binary_field-2"><tt>binary_field(Body, [])</tt></a>.</p>
    116. 

  116. </td></tr>
    117. 

  117. <tr><td valign="top"><a href="#binary_field-2">binary_field/2</a></td><td>Creates an abstract binary template field.</td></tr>
    118. 

  118. <tr><td valign="top"><a href="#binary_field-3">binary_field/3</a></td><td>Creates an abstract binary template field.</td></tr>
    119. 

  119. <tr><td valign="top"><a href="#binary_field_body-1">binary_field_body/1</a></td><td>Returns the body subtree of a <code>binary_field</code>.</td></tr>
    120. 

  120. <tr><td valign="top"><a href="#binary_field_size-1">binary_field_size/1</a></td><td>Returns the size specifier subtree of a
    121. 

  121.   <code>binary_field</code> node, if any.</td></tr>
    122. 

  122. <tr><td valign="top"><a href="#binary_field_types-1">binary_field_types/1</a></td><td>Returns the list of type-specifier subtrees of a
    123. 

  123.   <code>binary_field</code> node.</td></tr>
    124. 

  124. <tr><td valign="top"><a href="#binary_fields-1">binary_fields/1</a></td><td>Returns the list of field subtrees of a <code>binary</code>
    125. 

  125.   node.</td></tr>
    126. 

  126. <tr><td valign="top"><a href="#block_expr-1">block_expr/1</a></td><td>Creates an abstract block expression.</td></tr>
    127. 

  127. <tr><td valign="top"><a href="#block_expr_body-1">block_expr_body/1</a></td><td>Returns the list of body subtrees of a <code>block_expr</code>
    128. 

  128.   node.</td></tr>
    129. 

  129. <tr><td valign="top"><a href="#case_expr-2">case_expr/2</a></td><td>Creates an abstract case-expression.</td></tr>
    130. 

  130. <tr><td valign="top"><a href="#case_expr_argument-1">case_expr_argument/1</a></td><td>Returns the argument subtree of a <code>case_expr</code> node.</td></tr>
    131. 

  131. <tr><td valign="top"><a href="#case_expr_clauses-1">case_expr_clauses/1</a></td><td>Returns the list of clause subtrees of a <code>case_expr</code>
    132. 

  132.   node.</td></tr>
    133. 

  133. <tr><td valign="top"><a href="#catch_expr-1">catch_expr/1</a></td><td>Creates an abstract catch-expression.</td></tr>
    134. 

  134. <tr><td valign="top"><a href="#catch_expr_body-1">catch_expr_body/1</a></td><td>Returns the body subtree of a <code>catch_expr</code> node.</td></tr>
    135. 

  135. <tr><td valign="top"><a href="#char-1">char/1</a></td><td>Creates an abstract character literal.</td></tr>
    136. 

  136. <tr><td valign="top"><a href="#char_literal-1">char_literal/1</a></td><td>Returns the literal string represented by a <code>char</code>
    137. 

  137.   node.</td></tr>
    138. 

  138. <tr><td valign="top"><a href="#char_value-1">char_value/1</a></td><td>Returns the value represented by a <code>char</code> node.</td></tr>
    139. 

  139. <tr><td valign="top"><a href="#class_qualifier-2">class_qualifier/2</a></td><td>Creates an abstract class qualifier.</td></tr>
    140. 

  140. <tr><td valign="top"><a href="#class_qualifier_argument-1">class_qualifier_argument/1</a></td><td>Returns the argument (the class) subtree of a
    141. 

  141.   <code>class_qualifier</code> node.</td></tr>
    142. 

  142. <tr><td valign="top"><a href="#class_qualifier_body-1">class_qualifier_body/1</a></td><td>Returns the body subtree of a <code>class_qualifier</code> node.</td></tr>
    143. 

  143. <tr><td valign="top"><a href="#clause-2">clause/2</a></td><td><p>Equivalent to <a href="#clause-3"><tt>clause([], Guard, Body)</tt></a>.</p>
    144. 

  144. </td></tr>
    145. 

  145. <tr><td valign="top"><a href="#clause-3">clause/3</a></td><td>Creates an abstract clause.</td></tr>
    146. 

  146. <tr><td valign="top"><a href="#clause_body-1">clause_body/1</a></td><td>Return the list of body subtrees of a <code>clause</code>
    147. 

  147.   node.</td></tr>
    148. 

  148. <tr><td valign="top"><a href="#clause_guard-1">clause_guard/1</a></td><td>Returns the guard subtree of a <code>clause</code> node, if
    149. 

  149.   any.</td></tr>
    150. 

  150. <tr><td valign="top"><a href="#clause_patterns-1">clause_patterns/1</a></td><td>Returns the list of pattern subtrees of a <code>clause</code>
    151. 

  151.   node.</td></tr>
    152. 

  152. <tr><td valign="top"><a href="#comment-1">comment/1</a></td><td><p>Equivalent to <a href="#comment-2"><tt>comment(none, Strings)</tt></a>.</p>
    153. 

  153. </td></tr>
    154. 

  154. <tr><td valign="top"><a href="#comment-2">comment/2</a></td><td>Creates an abstract comment with the given padding and text.</td></tr>
    155. 

  155. <tr><td valign="top"><a href="#comment_padding-1">comment_padding/1</a></td><td>Returns the amount of padding before the comment, or
    156. 

  156.   <code>none</code>.</td></tr>
    157. 

  157. <tr><td valign="top"><a href="#comment_text-1">comment_text/1</a></td><td>Returns the lines of text of the abstract comment.</td></tr>
    158. 

  158. <tr><td valign="top"><a href="#compact_list-1">compact_list/1</a></td><td>Yields the most compact form for an abstract list skeleton.</td></tr>
    159. 

  159. <tr><td valign="top"><a href="#concrete-1">concrete/1</a></td><td>Returns the Erlang term represented by a syntax tree.</td></tr>
    160. 

  160. <tr><td valign="top"><a href="#cond_expr-1">cond_expr/1</a></td><td>Creates an abstract cond-expression.</td></tr>
    161. 

  161. <tr><td valign="top"><a href="#cond_expr_clauses-1">cond_expr_clauses/1</a></td><td>Returns the list of clause subtrees of a <code>cond_expr</code>
    162. 

  162.   node.</td></tr>
    163. 

  163. <tr><td valign="top"><a href="#conjunction-1">conjunction/1</a></td><td>Creates an abstract conjunction.</td></tr>
    164. 

  164. <tr><td valign="top"><a href="#conjunction_body-1">conjunction_body/1</a></td><td>Returns the list of body subtrees of a
    165. 

  165.   <code>conjunction</code> node.</td></tr>
    166. 

  166. <tr><td valign="top"><a href="#cons-2">cons/2</a></td><td>"Optimising" list skeleton cons operation.</td></tr>
    167. 

  167. <tr><td valign="top"><a href="#copy_ann-2">copy_ann/2</a></td><td>Copies the list of user annotations from <code>Source</code> to
    168. 

  168.   <code>Target</code>.</td></tr>
    169. 

  169. <tr><td valign="top"><a href="#copy_attrs-2">copy_attrs/2</a></td><td>Copies the attributes from <code>Source</code> to
    170. 

  170.   <code>Target</code>.</td></tr>
    171. 

  171. <tr><td valign="top"><a href="#copy_comments-2">copy_comments/2</a></td><td>Copies the pre- and postcomments from <code>Source</code> to
    172. 

  172.   <code>Target</code>.</td></tr>
    173. 

  173. <tr><td valign="top"><a href="#copy_pos-2">copy_pos/2</a></td><td>Copies the position information from <code>Source</code> to
    174. 

  174.   <code>Target</code>.</td></tr>
    175. 

  175. <tr><td valign="top"><a href="#data-1">data/1</a></td><td><em>For special purposes only</em>.</td></tr>
    176. 

  176. <tr><td valign="top"><a href="#disjunction-1">disjunction/1</a></td><td>Creates an abstract disjunction.</td></tr>
    177. 

  177. <tr><td valign="top"><a href="#disjunction_body-1">disjunction_body/1</a></td><td>Returns the list of body subtrees of a
    178. 

  178.   <code>disjunction</code> node.</td></tr>
    179. 

  179. <tr><td valign="top"><a href="#eof_marker-0">eof_marker/0</a></td><td>Creates an abstract end-of-file marker.</td></tr>
    180. 

  180. <tr><td valign="top"><a href="#error_marker-1">error_marker/1</a></td><td>Creates an abstract error marker.</td></tr>
    181. 

  181. <tr><td valign="top"><a href="#error_marker_info-1">error_marker_info/1</a></td><td>Returns the ErrorInfo structure of an <code>error_marker</code>
    182. 

  182.   node.</td></tr>
    183. 

  183. <tr><td valign="top"><a href="#flatten_form_list-1">flatten_form_list/1</a></td><td>Flattens sublists of a <code>form_list</code> node.</td></tr>
    184. 

  184. <tr><td valign="top"><a href="#float-1">float/1</a></td><td>Creates an abstract floating-point literal.</td></tr>
    185. 

  185. <tr><td valign="top"><a href="#float_literal-1">float_literal/1</a></td><td>Returns the numeral string represented by a <code>float</code>
    186. 

  186.   node.</td></tr>
    187. 

  187. <tr><td valign="top"><a href="#float_value-1">float_value/1</a></td><td>Returns the value represented by a <code>float</code> node.</td></tr>
    188. 

  188. <tr><td valign="top"><a href="#form_list-1">form_list/1</a></td><td>Creates an abstract sequence of "source code forms".</td></tr>
    189. 

  189. <tr><td valign="top"><a href="#form_list_elements-1">form_list_elements/1</a></td><td>Returns the list of subnodes of a <code>form_list</code> node.</td></tr>
    190. 

  190. <tr><td valign="top"><a href="#fun_expr-1">fun_expr/1</a></td><td>Creates an abstract fun-expression.</td></tr>
    191. 

  191. <tr><td valign="top"><a href="#fun_expr_arity-1">fun_expr_arity/1</a></td><td>Returns the arity of a <code>fun_expr</code> node.</td></tr>
    192. 

  192. <tr><td valign="top"><a href="#fun_expr_clauses-1">fun_expr_clauses/1</a></td><td>Returns the list of clause subtrees of a <code>fun_expr</code>
    193. 

  193.   node.</td></tr>
    194. 

  194. <tr><td valign="top"><a href="#function-2">function/2</a></td><td>Creates an abstract function definition.</td></tr>
    195. 

  195. <tr><td valign="top"><a href="#function_arity-1">function_arity/1</a></td><td>Returns the arity of a <code>function</code> node.</td></tr>
    196. 

  196. <tr><td valign="top"><a href="#function_clauses-1">function_clauses/1</a></td><td>Returns the list of clause subtrees of a <code>function</code>
    197. 

  197.   node.</td></tr>
    198. 

  198. <tr><td valign="top"><a href="#function_name-1">function_name/1</a></td><td>Returns the name subtree of a <code>function</code> node.</td></tr>
    199. 

  199. <tr><td valign="top"><a href="#generator-2">generator/2</a></td><td>Creates an abstract generator.</td></tr>
    200. 

  200. <tr><td valign="top"><a href="#generator_body-1">generator_body/1</a></td><td>Returns the body subtree of a <code>generator</code> node.</td></tr>
    201. 

  201. <tr><td valign="top"><a href="#generator_pattern-1">generator_pattern/1</a></td><td>Returns the pattern subtree of a <code>generator</code> node.</td></tr>
    202. 

  202. <tr><td valign="top"><a href="#get_ann-1">get_ann/1</a></td><td>Returns the list of user annotations associated with a syntax
    203. 

  203.   tree node.</td></tr>
    204. 

  204. <tr><td valign="top"><a href="#get_attrs-1">get_attrs/1</a></td><td>Returns a representation of the attributes associated with a
    205. 

  205.   syntax tree node.</td></tr>
    206. 

  206. <tr><td valign="top"><a href="#get_pos-1">get_pos/1</a></td><td>Returns the position information associated with
    207. 

  207.   <code>Node</code>.</td></tr>
    208. 

  208. <tr><td valign="top"><a href="#get_postcomments-1">get_postcomments/1</a></td><td>Returns the associated post-comments of a node.</td></tr>
    209. 

  209. <tr><td valign="top"><a href="#get_precomments-1">get_precomments/1</a></td><td>Returns the associated pre-comments of a node.</td></tr>
    210. 

  210. <tr><td valign="top"><a href="#has_comments-1">has_comments/1</a></td><td>Yields <code>false</code> if the node has no associated
    211. 

  211.   comments, and <code>true</code> otherwise.</td></tr>
    212. 

  212. <tr><td valign="top"><a href="#if_expr-1">if_expr/1</a></td><td>Creates an abstract if-expression.</td></tr>
    213. 

  213. <tr><td valign="top"><a href="#if_expr_clauses-1">if_expr_clauses/1</a></td><td>Returns the list of clause subtrees of an <code>if_expr</code>
    214. 

  214.   node.</td></tr>
    215. 

  215. <tr><td valign="top"><a href="#implicit_fun-1">implicit_fun/1</a></td><td>Creates an abstract "implicit fun" expression.</td></tr>
    216. 

  216. <tr><td valign="top"><a href="#implicit_fun-2">implicit_fun/2</a></td><td>Creates an abstract "implicit fun" expression.</td></tr>
    217. 

  217. <tr><td valign="top"><a href="#implicit_fun_name-1">implicit_fun_name/1</a></td><td>Returns the name subtree of an <code>implicit_fun</code> node.</td></tr>
    218. 

  218. <tr><td valign="top"><a href="#infix_expr-3">infix_expr/3</a></td><td>Creates an abstract infix operator expression.</td></tr>
    219. 

  219. <tr><td valign="top"><a href="#infix_expr_left-1">infix_expr_left/1</a></td><td>Returns the left argument subtree of an
    220. 

  220.   <code>infix_expr</code> node.</td></tr>
    221. 

  221. <tr><td valign="top"><a href="#infix_expr_operator-1">infix_expr_operator/1</a></td><td>Returns the operator subtree of an <code>infix_expr</code>
    222. 

  222.   node.</td></tr>
    223. 

  223. <tr><td valign="top"><a href="#infix_expr_right-1">infix_expr_right/1</a></td><td>Returns the right argument subtree of an
    224. 

  224.   <code>infix_expr</code> node.</td></tr>
    225. 

  225. <tr><td valign="top"><a href="#integer-1">integer/1</a></td><td>Creates an abstract integer literal.</td></tr>
    226. 

  226. <tr><td valign="top"><a href="#integer_literal-1">integer_literal/1</a></td><td>Returns the numeral string represented by an
    227. 

  227.   <code>integer</code> node.</td></tr>
    228. 

  228. <tr><td valign="top"><a href="#integer_value-1">integer_value/1</a></td><td>Returns the value represented by an <code>integer</code> node.</td></tr>
    229. 

  229. <tr><td valign="top"><a href="#is_atom-2">is_atom/2</a></td><td>Returns <code>true</code> if <code>Node</code> has type
    230. 

  230.   <code>atom</code> and represents <code>Value</code>, otherwise
    231. 

  231.   <code>false</code>.</td></tr>
    232. 

  232. <tr><td valign="top"><a href="#is_char-2">is_char/2</a></td><td>Returns <code>true</code> if <code>Node</code> has type
    233. 

  233.   <code>char</code> and represents <code>Value</code>, otherwise
    234. 

  234.   <code>false</code>.</td></tr>
    235. 

  235. <tr><td valign="top"><a href="#is_form-1">is_form/1</a></td><td>Returns <code>true</code> if <code>Node</code> is a syntax tree
    236. 

  236.   representing a so-called "source code form", otherwise
    237. 

  237.   <code>false</code>.</td></tr>
    238. 

  238. <tr><td valign="top"><a href="#is_integer-2">is_integer/2</a></td><td>Returns <code>true</code> if <code>Node</code> has type
    239. 

  239.   <code>integer</code> and represents <code>Value</code>, otherwise
    240. 

  240.   <code>false</code>.</td></tr>
    241. 

  241. <tr><td valign="top"><a href="#is_leaf-1">is_leaf/1</a></td><td>Returns <code>true</code> if <code>Node</code> is a leaf node,
    242. 

  242.   otherwise <code>false</code>.</td></tr>
    243. 

  243. <tr><td valign="top"><a href="#is_list_skeleton-1">is_list_skeleton/1</a></td><td>Returns <code>true</code> if <code>Node</code> has type
    244. 

  244.   <code>list</code> or <code>nil</code>, otherwise <code>false</code>.</td></tr>
    245. 

  245. <tr><td valign="top"><a href="#is_literal-1">is_literal/1</a></td><td>Returns <code>true</code> if <code>Node</code> represents a
    246. 

  246.   literal term, otherwise <code>false</code>.</td></tr>
    247. 

  247. <tr><td valign="top"><a href="#is_proper_list-1">is_proper_list/1</a></td><td>Returns <code>true</code> if <code>Node</code> represents a
    248. 

  248.   proper list, and <code>false</code> otherwise.</td></tr>
    249. 

  249. <tr><td valign="top"><a href="#is_string-2">is_string/2</a></td><td>Returns <code>true</code> if <code>Node</code> has type
    250. 

  250.   <code>string</code> and represents <code>Value</code>, otherwise
    251. 

  251.   <code>false</code>.</td></tr>
    252. 

  252. <tr><td valign="top"><a href="#is_tree-1">is_tree/1</a></td><td><em>For special purposes only</em>.</td></tr>
    253. 

  253. <tr><td valign="top"><a href="#join_comments-2">join_comments/2</a></td><td>Appends the comments of <code>Source</code> to the current
    254. 

  254.   comments of <code>Target</code>.</td></tr>
    255. 

  255. <tr><td valign="top"><a href="#list-1">list/1</a></td><td><p>Equivalent to <a href="#list-2"><tt>list(List, none)</tt></a>.</p>
    256. 

  256. </td></tr>
    257. 

  257. <tr><td valign="top"><a href="#list-2">list/2</a></td><td>Constructs an abstract list skeleton.</td></tr>
    258. 

  258. <tr><td valign="top"><a href="#list_comp-2">list_comp/2</a></td><td>Creates an abstract list comprehension.</td></tr>
    259. 

  259. <tr><td valign="top"><a href="#list_comp_body-1">list_comp_body/1</a></td><td>Returns the list of body subtrees of a <code>list_comp</code>
    260. 

  260.   node.</td></tr>
    261. 

  261. <tr><td valign="top"><a href="#list_comp_template-1">list_comp_template/1</a></td><td>Returns the template subtree of a <code>list_comp</code> node.</td></tr>
    262. 

  262. <tr><td valign="top"><a href="#list_elements-1">list_elements/1</a></td><td>Returns the list of element subtrees of a list skeleton.</td></tr>
    263. 

  263. <tr><td valign="top"><a href="#list_head-1">list_head/1</a></td><td>Returns the head element subtree of a <code>list</code> node.</td></tr>
    264. 

  264. <tr><td valign="top"><a href="#list_length-1">list_length/1</a></td><td>Returns the number of element subtrees of a list skeleton.</td></tr>
    265. 

  265. <tr><td valign="top"><a href="#list_prefix-1">list_prefix/1</a></td><td>Returns the prefix element subtrees of a <code>list</code> node.</td></tr>
    266. 

  266. <tr><td valign="top"><a href="#list_suffix-1">list_suffix/1</a></td><td>Returns the suffix subtree of a <code>list</code> node, if one
    267. 

  267.   exists.</td></tr>
    268. 

  268. <tr><td valign="top"><a href="#list_tail-1">list_tail/1</a></td><td>Returns the tail of a <code>list</code> node.</td></tr>
    269. 

  269. <tr><td valign="top"><a href="#macro-1">macro/1</a></td><td><p>Equivalent to <a href="#macro-2"><tt>macro(Name, none)</tt></a>.</p>
    270. 

  270. </td></tr>
    271. 

  271. <tr><td valign="top"><a href="#macro-2">macro/2</a></td><td>Creates an abstract macro application.</td></tr>
    272. 

  272. <tr><td valign="top"><a href="#macro_arguments-1">macro_arguments/1</a></td><td>Returns the list of argument subtrees of a <code>macro</code>
    273. 

  273.   node, if any.</td></tr>
    274. 

  274. <tr><td valign="top"><a href="#macro_name-1">macro_name/1</a></td><td>Returns the name subtree of a <code>macro</code> node.</td></tr>
    275. 

  275. <tr><td valign="top"><a href="#make_tree-2">make_tree/2</a></td><td>Creates a syntax tree with the given type and subtrees.</td></tr>
    276. 

  276. <tr><td valign="top"><a href="#match_expr-2">match_expr/2</a></td><td>Creates an abstract match-expression.</td></tr>
    277. 

  277. <tr><td valign="top"><a href="#match_expr_body-1">match_expr_body/1</a></td><td>Returns the body subtree of a <code>match_expr</code> node.</td></tr>
    278. 

  278. <tr><td valign="top"><a href="#match_expr_pattern-1">match_expr_pattern/1</a></td><td>Returns the pattern subtree of a <code>match_expr</code> node.</td></tr>
    279. 

  279. <tr><td valign="top"><a href="#meta-1">meta/1</a></td><td>Creates a meta-representation of a syntax tree.</td></tr>
    280. 

  280. <tr><td valign="top"><a href="#module_qualifier-2">module_qualifier/2</a></td><td>Creates an abstract module qualifier.</td></tr>
    281. 

  281. <tr><td valign="top"><a href="#module_qualifier_argument-1">module_qualifier_argument/1</a></td><td>Returns the argument (the module) subtree of a
    282. 

  282.   <code>module_qualifier</code> node.</td></tr>
    283. 

  283. <tr><td valign="top"><a href="#module_qualifier_body-1">module_qualifier_body/1</a></td><td>Returns the body subtree of a <code>module_qualifier</code>
    284. 

  284.   node.</td></tr>
    285. 

  285. <tr><td valign="top"><a href="#nil-0">nil/0</a></td><td>Creates an abstract empty list.</td></tr>
    286. 

  286. <tr><td valign="top"><a href="#normalize_list-1">normalize_list/1</a></td><td>Expands an abstract list skeleton to its most explicit form.</td></tr>
    287. 

  287. <tr><td valign="top"><a href="#operator-1">operator/1</a></td><td>Creates an abstract operator.</td></tr>
    288. 

  288. <tr><td valign="top"><a href="#operator_literal-1">operator_literal/1</a></td><td>Returns the literal string represented by an
    289. 

  289.   <code>operator</code> node.</td></tr>
    290. 

  290. <tr><td valign="top"><a href="#operator_name-1">operator_name/1</a></td><td>Returns the name of an <code>operator</code> node.</td></tr>
    291. 

  291. <tr><td valign="top"><a href="#parentheses-1">parentheses/1</a></td><td>Creates an abstract parenthesised expression.</td></tr>
    292. 

  292. <tr><td valign="top"><a href="#parentheses_body-1">parentheses_body/1</a></td><td>Returns the body subtree of a <code>parentheses</code> node.</td></tr>
    293. 

  293. <tr><td valign="top"><a href="#prefix_expr-2">prefix_expr/2</a></td><td>Creates an abstract prefix operator expression.</td></tr>
    294. 

  294. <tr><td valign="top"><a href="#prefix_expr_argument-1">prefix_expr_argument/1</a></td><td>Returns the argument subtree of a <code>prefix_expr</code>
    295. 

  295.   node.</td></tr>
    296. 

  296. <tr><td valign="top"><a href="#prefix_expr_operator-1">prefix_expr_operator/1</a></td><td>Returns the operator subtree of a <code>prefix_expr</code>
    297. 

  297.   node.</td></tr>
    298. 

  298. <tr><td valign="top"><a href="#qualified_name-1">qualified_name/1</a></td><td>Creates an abstract qualified name.</td></tr>
    299. 

  299. <tr><td valign="top"><a href="#qualified_name_segments-1">qualified_name_segments/1</a></td><td>Returns the list of name segments of a
    300. 

  300.   <code>qualified_name</code> node.</td></tr>
    301. 

  301. <tr><td valign="top"><a href="#query_expr-1">query_expr/1</a></td><td>Creates an abstract Mnemosyne query expression.</td></tr>
    302. 

  302. <tr><td valign="top"><a href="#query_expr_body-1">query_expr_body/1</a></td><td>Returns the body subtree of a <code>query_expr</code> node.</td></tr>
    303. 

  303. <tr><td valign="top"><a href="#receive_expr-1">receive_expr/1</a></td><td><p>Equivalent to <a href="#receive_expr-3"><tt>receive_expr(Clauses, none, [])</tt></a>.</p>
    304. 

  304. </td></tr>
    305. 

  305. <tr><td valign="top"><a href="#receive_expr-3">receive_expr/3</a></td><td>Creates an abstract receive-expression.</td></tr>
    306. 

  306. <tr><td valign="top"><a href="#receive_expr_action-1">receive_expr_action/1</a></td><td>Returns the list of action body subtrees of a
    307. 

  307.   <code>receive_expr</code> node.</td></tr>
    308. 

  308. <tr><td valign="top"><a href="#receive_expr_clauses-1">receive_expr_clauses/1</a></td><td>Returns the list of clause subtrees of a
    309. 

  309.   <code>receive_expr</code> node.</td></tr>
    310. 

  310. <tr><td valign="top"><a href="#receive_expr_timeout-1">receive_expr_timeout/1</a></td><td>Returns the timeout subtree of a <code>receive_expr</code> node,
    311. 

  311.   if any.</td></tr>
    312. 

  312. <tr><td valign="top"><a href="#record_access-2">record_access/2</a></td><td><p>Equivalent to <a href="#record_access-3"><tt>record_access(Argument, none, Field)</tt></a>.</p>
    313. 

  313. </td></tr>
    314. 

  314. <tr><td valign="top"><a href="#record_access-3">record_access/3</a></td><td>Creates an abstract record field access expression.</td></tr>
    315. 

  315. <tr><td valign="top"><a href="#record_access_argument-1">record_access_argument/1</a></td><td>Returns the argument subtree of a <code>record_access</code>
    316. 

  316.   node.</td></tr>
    317. 

  317. <tr><td valign="top"><a href="#record_access_field-1">record_access_field/1</a></td><td>Returns the field subtree of a <code>record_access</code>
    318. 

  318.   node.</td></tr>
    319. 

  319. <tr><td valign="top"><a href="#record_access_type-1">record_access_type/1</a></td><td>Returns the type subtree of a <code>record_access</code> node,
    320. 

  320.   if any.</td></tr>
    321. 

  321. <tr><td valign="top"><a href="#record_expr-2">record_expr/2</a></td><td><p>Equivalent to <a href="#record_expr-3"><tt>record_expr(none, Type, Fields)</tt></a>.</p>
    322. 

  322. </td></tr>
    323. 

  323. <tr><td valign="top"><a href="#record_expr-3">record_expr/3</a></td><td>Creates an abstract record expression.</td></tr>
    324. 

  324. <tr><td valign="top"><a href="#record_expr_argument-1">record_expr_argument/1</a></td><td>Returns the argument subtree of a <code>record_expr</code> node,
    325. 

  325.   if any.</td></tr>
    326. 

  326. <tr><td valign="top"><a href="#record_expr_fields-1">record_expr_fields/1</a></td><td>Returns the list of field subtrees of a
    327. 

  327.   <code>record_expr</code> node.</td></tr>
    328. 

  328. <tr><td valign="top"><a href="#record_expr_type-1">record_expr_type/1</a></td><td>Returns the type subtree of a <code>record_expr</code> node.</td></tr>
    329. 

  329. <tr><td valign="top"><a href="#record_field-1">record_field/1</a></td><td><p>Equivalent to <a href="#record_field-2"><tt>record_field(Name, none)</tt></a>.</p>
    330. 

  330. </td></tr>
    331. 

  331. <tr><td valign="top"><a href="#record_field-2">record_field/2</a></td><td>Creates an abstract record field specification.</td></tr>
    332. 

  332. <tr><td valign="top"><a href="#record_field_name-1">record_field_name/1</a></td><td>Returns the name subtree of a <code>record_field</code> node.</td></tr>
    333. 

  333. <tr><td valign="top"><a href="#record_field_value-1">record_field_value/1</a></td><td>Returns the value subtree of a <code>record_field</code> node,
    334. 

  334.   if any.</td></tr>
    335. 

  335. <tr><td valign="top"><a href="#record_index_expr-2">record_index_expr/2</a></td><td>Creates an abstract record field index expression.</td></tr>
    336. 

  336. <tr><td valign="top"><a href="#record_index_expr_field-1">record_index_expr_field/1</a></td><td>Returns the field subtree of a <code>record_index_expr</code>
    337. 

  337.   node.</td></tr>
    338. 

  338. <tr><td valign="top"><a href="#record_index_expr_type-1">record_index_expr_type/1</a></td><td>Returns the type subtree of a <code>record_index_expr</code>
    339. 

  339.   node.</td></tr>
    340. 

  340. <tr><td valign="top"><a href="#remove_comments-1">remove_comments/1</a></td><td>Clears the associated comments of <code>Node</code>.</td></tr>
    341. 

  341. <tr><td valign="top"><a href="#revert-1">revert/1</a></td><td>Returns an <code>erl_parse</code>-compatible representation of a
    342. 

  342.   syntax tree, if possible.</td></tr>
    343. 

  343. <tr><td valign="top"><a href="#revert_forms-1">revert_forms/1</a></td><td>Reverts a sequence of Erlang source code forms.</td></tr>
    344. 

  344. <tr><td valign="top"><a href="#rule-2">rule/2</a></td><td>Creates an abstract Mnemosyne rule.</td></tr>
    345. 

  345. <tr><td valign="top"><a href="#rule_arity-1">rule_arity/1</a></td><td>Returns the arity of a <code>rule</code> node.</td></tr>
    346. 

  346. <tr><td valign="top"><a href="#rule_clauses-1">rule_clauses/1</a></td><td>Returns the list of clause subtrees of a <code>rule</code> node.</td></tr>
    347. 

  347. <tr><td valign="top"><a href="#rule_name-1">rule_name/1</a></td><td>Returns the name subtree of a <code>rule</code> node.</td></tr>
    348. 

  348. <tr><td valign="top"><a href="#set_ann-2">set_ann/2</a></td><td>Sets the list of user annotations of <code>Node</code> to
    349. 

  349.   <code>Annotations</code>.</td></tr>
    350. 

  350. <tr><td valign="top"><a href="#set_attrs-2">set_attrs/2</a></td><td>Sets the attributes of <code>Node</code> to
    351. 

  351.   <code>Attributes</code>.</td></tr>
    352. 

  352. <tr><td valign="top"><a href="#set_pos-2">set_pos/2</a></td><td>Sets the position information of <code>Node</code> to
    353. 

  353.   <code>Pos</code>.</td></tr>
    354. 

  354. <tr><td valign="top"><a href="#set_postcomments-2">set_postcomments/2</a></td><td>Sets the post-comments of <code>Node</code> to
    355. 

  355.   <code>Comments</code>.</td></tr>
    356. 

  356. <tr><td valign="top"><a href="#set_precomments-2">set_precomments/2</a></td><td>Sets the pre-comments of <code>Node</code> to
    357. 

  357.   <code>Comments</code>.</td></tr>
    358. 

  358. <tr><td valign="top"><a href="#size_qualifier-2">size_qualifier/2</a></td><td>Creates an abstract size qualifier.</td></tr>
    359. 

  359. <tr><td valign="top"><a href="#size_qualifier_argument-1">size_qualifier_argument/1</a></td><td>Returns the argument subtree (the size) of a
    360. 

  360.   <code>size_qualifier</code> node.</td></tr>
    361. 

  361. <tr><td valign="top"><a href="#size_qualifier_body-1">size_qualifier_body/1</a></td><td>Returns the body subtree of a <code>size_qualifier</code>
    362. 

  362.   node.</td></tr>
    363. 

  363. <tr><td valign="top"><a href="#string-1">string/1</a></td><td>Creates an abstract string literal.</td></tr>
    364. 

  364. <tr><td valign="top"><a href="#string_literal-1">string_literal/1</a></td><td>Returns the literal string represented by a <code>string</code>
    365. 

  365.   node.</td></tr>
    366. 

  366. <tr><td valign="top"><a href="#string_value-1">string_value/1</a></td><td>Returns the value represented by a <code>string</code> node.</td></tr>
    367. 

  367. <tr><td valign="top"><a href="#subtrees-1">subtrees/1</a></td><td>Returns the grouped list of all subtrees of a syntax tree.</td></tr>
    368. 

  368. <tr><td valign="top"><a href="#text-1">text/1</a></td><td>Creates an abstract piece of source code text.</td></tr>
    369. 

  369. <tr><td valign="top"><a href="#text_string-1">text_string/1</a></td><td>Returns the character sequence represented by a
    370. 

  370.   <code>text</code> node.</td></tr>
    371. 

  371. <tr><td valign="top"><a href="#tree-1">tree/1</a></td><td><p>Equivalent to <a href="#tree-2"><tt>tree(Type, [])</tt></a>.</p>
    372. 

  372. </td></tr>
    373. 

  373. <tr><td valign="top"><a href="#tree-2">tree/2</a></td><td><em>For special purposes only</em>.</td></tr>
    374. 

  374. <tr><td valign="top"><a href="#try_after_expr-2">try_after_expr/2</a></td><td><p>Equivalent to <a href="#try_expr-4"><tt>try_expr(Body, [], [], After)</tt></a>.</p>
    375. 

  375. </td></tr>
    376. 

  376. <tr><td valign="top"><a href="#try_expr-2">try_expr/2</a></td><td><p>Equivalent to <a href="#try_expr-3"><tt>try_expr(Body, [], Handlers)</tt></a>.</p>
    377. 

  377. </td></tr>
    378. 

  378. <tr><td valign="top"><a href="#try_expr-3">try_expr/3</a></td><td><p>Equivalent to <a href="#try_expr-4"><tt>try_expr(Body, Clauses, Handlers, [])</tt></a>.</p>
    379. 

  379. </td></tr>
    380. 

  380. <tr><td valign="top"><a href="#try_expr-4">try_expr/4</a></td><td>Creates an abstract try-expression.</td></tr>
    381. 

  381. <tr><td valign="top"><a href="#try_expr_after-1">try_expr_after/1</a></td><td>Returns the list of "after" subtrees of a <code>try_expr</code>
    382. 

  382.   node.</td></tr>
    383. 

  383. <tr><td valign="top"><a href="#try_expr_body-1">try_expr_body/1</a></td><td>Returns the list of body subtrees of a <code>try_expr</code>
    384. 

  384.   node.</td></tr>
    385. 

  385. <tr><td valign="top"><a href="#try_expr_clauses-1">try_expr_clauses/1</a></td><td>Returns the list of case-clause subtrees of a
    386. 

  386.   <code>try_expr</code> node.</td></tr>
    387. 

  387. <tr><td valign="top"><a href="#try_expr_handlers-1">try_expr_handlers/1</a></td><td>Returns the list of handler-clause subtrees of a
    388. 

  388.   <code>try_expr</code> node.</td></tr>
    389. 

  389. <tr><td valign="top"><a href="#tuple-1">tuple/1</a></td><td>Creates an abstract tuple.</td></tr>
    390. 

  390. <tr><td valign="top"><a href="#tuple_elements-1">tuple_elements/1</a></td><td>Returns the list of element subtrees of a <code>tuple</code>
    391. 

  391.   node.</td></tr>
    392. 

  392. <tr><td valign="top"><a href="#tuple_size-1">tuple_size/1</a></td><td>Returns the number of elements of a <code>tuple</code> node.</td></tr>
    393. 

  393. <tr><td valign="top"><a href="#type-1">type/1</a></td><td>Returns the type tag of <code>Node</code>.</td></tr>
    394. 

  394. <tr><td valign="top"><a href="#underscore-0">underscore/0</a></td><td>Creates an abstract universal pattern ("<code>_</code>").</td></tr>
    395. 

  395. <tr><td valign="top"><a href="#update_tree-2">update_tree/2</a></td><td>Creates a syntax tree with the same type and attributes as the
    396. 

  396.   given tree.</td></tr>
    397. 

  397. <tr><td valign="top"><a href="#variable-1">variable/1</a></td><td>Creates an abstract variable with the given name.</td></tr>
    398. 

  398. <tr><td valign="top"><a href="#variable_literal-1">variable_literal/1</a></td><td>Returns the name of a <code>variable</code> node as a string.</td></tr>
    399. 

  399. <tr><td valign="top"><a href="#variable_name-1">variable_name/1</a></td><td>Returns the name of a <code>variable</code> node as an atom.</td></tr>
    400. 

  400. <tr><td valign="top"><a href="#warning_marker-1">warning_marker/1</a></td><td>Creates an abstract warning marker.</td></tr>
    401. 

  401. <tr><td valign="top"><a href="#warning_marker_info-1">warning_marker_info/1</a></td><td>Returns the ErrorInfo structure of a <code>warning_marker</code>
    402. 

  402.   node.</td></tr>
    403. 

  403. </table>
    404. 

  404. 

  405. <h2><a name="functions">Function Details</a></h2>
    406. 

  406. 

  407. <h3><a name="abstract-1">abstract/1</a></h3>
    408. 

  408. <p><tt>abstract(Term::term()) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    409. 

  409. <p>Returns the syntax tree corresponding to an Erlang term.
    410. 

  410.   <code>Term</code> must be a literal term, i.e., one that can be
    411. 

  411.   represented as a source code literal. Thus, it may not contain a
    412. 

  412.   process identifier, port, reference, binary or function value as a
    413. 

  413.   subterm. The function recognises printable strings, in order to get a
    414. 

  414.   compact and readable representation. Evaluation fails with reason
    415. 

  415.   <code>badarg</code> if <code>Term</code> is not a literal term.
    416. 

  416.  </p>
    417. 

  417. <p><b>See also:</b> <a href="#concrete-1">concrete/1</a>, <a href="#is_literal-1">is_literal/1</a>.</p>
    418. 

  418. 

  419. <h3><a name="add_ann-2">add_ann/2</a></h3>
    420. 

  420. <p><tt>add_ann(Annotation::term(), Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    421. 

  421. <p>Appends the term <code>Annotation</code> to the list of user
    422. 

  422.   annotations of <code>Node</code>.
    423. 

  423.  
    424. 

  424.   <p>Note: this is equivalent to <code>set_ann(Node, [Annotation |
    425. 

  425.   get_ann(Node)])</code>, but potentially more efficient.</p>
    426. 

  426.  </p>
    427. 

  427. <p><b>See also:</b> <a href="#get_ann-1">get_ann/1</a>, <a href="#set_ann-2">set_ann/2</a>.</p>
    428. 

  428. 

  429. <h3><a name="add_postcomments-2">add_postcomments/2</a></h3>
    430. 

  430. <p><tt>add_postcomments(Comments::[<a href="#type-syntaxTree">syntaxTree()</a>], Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    431. 

  431. <p>Appends <code>Comments</code> to the post-comments of
    432. 

  432.   <code>Node</code>.
    433. 

  433.  
    434. 

  434.   <p>Note: This is equivalent to <code>set_postcomments(Node,
    435. 

  435.   get_postcomments(Node) ++ Comments)</code>, but potentially more
    436. 

  436.   efficient.</p>
    437. 

  437.  </p>
    438. 

  438. <p><b>See also:</b> <a href="#add_precomments-2">add_precomments/2</a>, <a href="#comment-2">comment/2</a>, <a href="#get_postcomments-1">get_postcomments/1</a>, <a href="#join_comments-2">join_comments/2</a>, <a href="#set_postcomments-2">set_postcomments/2</a>.</p>
    439. 

  439. 

  440. <h3><a name="add_precomments-2">add_precomments/2</a></h3>
    441. 

  441. <p><tt>add_precomments(Comments::[<a href="#type-syntaxTree">syntaxTree()</a>], Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    442. 

  442. <p>Appends <code>Comments</code> to the pre-comments of
    443. 

  443.   <code>Node</code>.
    444. 

  444.  
    445. 

  445.   <p>Note: This is equivalent to <code>set_precomments(Node,
    446. 

  446.   get_precomments(Node) ++ Comments)</code>, but potentially more
    447. 

  447.   efficient.</p>
    448. 

  448.  </p>
    449. 

  449. <p><b>See also:</b> <a href="#add_postcomments-2">add_postcomments/2</a>, <a href="#comment-2">comment/2</a>, <a href="#get_precomments-1">get_precomments/1</a>, <a href="#join_comments-2">join_comments/2</a>, <a href="#set_precomments-2">set_precomments/2</a>.</p>
    450. 

  450. 

  451. <h3><a name="application-2">application/2</a></h3>
    452. 

  452. <p><tt>application(Operator::<a href="#type-syntaxTree">syntaxTree()</a>, Arguments::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    453. 

  453. <p>Creates an abstract function application expression. If
    454. 

  454.   <code>Arguments</code> is <code>[A1, ..., An]</code>, the result
    455. 

  455.   represents "<code><em>Operator</em>(<em>A1</em>, ...,
    456. 

  456.   <em>An</em>)</code>".
    457. 

  457.  </p>
    458. 

  458. <p><b>See also:</b> <a href="#application-3">application/3</a>, <a href="#application_arguments-1">application_arguments/1</a>, <a href="#application_operator-1">application_operator/1</a>.</p>
    459. 

  459. 

  460. <h3><a name="application-3">application/3</a></h3>
    461. 

  461. <p><tt>application(Module, Function::<a href="#type-syntaxTree">syntaxTree()</a>, Arguments::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    462. 

  462. <ul><li><tt>Module = none | <a href="#type-syntaxTree">syntaxTree()</a></tt></li></ul></p>
    463. 

  463. <p>Creates an abstract function application expression. (Utility
    464. 

  464.   function.) If <code>Module</code> is <code>none</code>, this is
    465. 

  465.   call is equivalent to <code>application(Function,
    466. 

  466.   Arguments)</code>, otherwise it is equivalent to
    467. 

  467.   <code>application(module_qualifier(Module, Function),
    468. 

  468.   Arguments)</code>.
    469. 

  469.  </p>
    470. 

  470. <p><b>See also:</b> <a href="#application-2">application/2</a>, <a href="#module_qualifier-2">module_qualifier/2</a>.</p>
    471. 

  471. 

  472. <h3><a name="application_arguments-1">application_arguments/1</a></h3>
    473. 

  473. <p><tt>application_arguments(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    474. 

  474. <p>Returns the list of argument subtrees of an
    475. 

  475.   <code>application</code> node.
    476. 

  476.  </p>
    477. 

  477. <p><b>See also:</b> <a href="#application-2">application/2</a>.</p>
    478. 

  478. 

  479. <h3><a name="application_operator-1">application_operator/1</a></h3>
    480. 

  480. <p><tt>application_operator(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    481. 

  481. <p>Returns the operator subtree of an <code>application</code>
    482. 

  482.   node.
    483. 

  483.  
    484. 

  484.   <p>Note: if <code>Node</code> represents
    485. 

  485.   "<code><em>M</em>:<em>F</em>(...)</code>", then the result is the
    486. 

  486.   subtree representing "<code><em>M</em>:<em>F</em></code>".</p>
    487. 

  487.  </p>
    488. 

  488. <p><b>See also:</b> <a href="#application-2">application/2</a>, <a href="#module_qualifier-2">module_qualifier/2</a>.</p>
    489. 

  489. 

  490. <h3><a name="arity_qualifier-2">arity_qualifier/2</a></h3>
    491. 

  491. <p><tt>arity_qualifier(Body::<a href="#type-syntaxTree">syntaxTree()</a>, Arity::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    492. 

  492. <p>Creates an abstract arity qualifier. The result represents
    493. 

  493.   "<code><em>Body</em>/<em>Arity</em></code>".
    494. 

  494.  </p>
    495. 

  495. <p><b>See also:</b> <a href="#arity_qualifier_argument-1">arity_qualifier_argument/1</a>, <a href="#arity_qualifier_body-1">arity_qualifier_body/1</a>.</p>
    496. 

  496. 

  497. <h3><a name="arity_qualifier_argument-1">arity_qualifier_argument/1</a></h3>
    498. 

  498. <p><tt>arity_qualifier_argument(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    499. 

  499. <p>Returns the argument (the arity) subtree of an
    500. 

  500.   <code>arity_qualifier</code> node.
    501. 

  501.  </p>
    502. 

  502. <p><b>See also:</b> <a href="#arity_qualifier-1">arity_qualifier/1</a>.</p>
    503. 

  503. 

  504. <h3><a name="arity_qualifier_body-1">arity_qualifier_body/1</a></h3>
    505. 

  505. <p><tt>arity_qualifier_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    506. 

  506. <p>Returns the body subtree of an <code>arity_qualifier</code>
    507. 

  507.   node.
    508. 

  508.  </p>
    509. 

  509. <p><b>See also:</b> <a href="#arity_qualifier-1">arity_qualifier/1</a>.</p>
    510. 

  510. 

  511. <h3><a name="atom-1">atom/1</a></h3>
    512. 

  512. <p><tt>atom(Name) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    513. 

  513. <ul><li><tt>Name = atom() | string()</tt></li></ul></p>
    514. 

  514. <p>Creates an abstract atom literal. The print name of the atom is
    515. 

  515.   the character sequence represented by <code>Name</code>.
    516. 

  516.  </p>
    517. 

  517. <p><b>See also:</b> <a href="#atom_literal-1">atom_literal/1</a>, <a href="#atom_name-1">atom_name/1</a>, <a href="#atom_value-1">atom_value/1</a>, <a href="#is_atom-2">is_atom/2</a>.</p>
    518. 

  518. 

  519. <h3><a name="atom_literal-1">atom_literal/1</a></h3>
    520. 

  520. <p><tt>atom_literal(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; string()</tt></p>
    521. 

  521. <p>Returns the literal string represented by an <code>atom</code>
    522. 

  522.   node. This includes surrounding single-quote characters if necessary.
    523. 

  523.  
    524. 

  524.   <p>Note that e.g. the result of <code>atom("x\ny")</code> represents
    525. 

  525.   any and all of <code>'x\ny'</code>, <code>'x\12y'</code>,
    526. 

  526.   <code>'x\012y'</code> and <code>'x\^Jy\'</code>; cf.
    527. 

  527.   <code>string/1</code>.</p>
    528. 

  528.  </p>
    529. 

  529. <p><b>See also:</b> <a href="#atom-1">atom/1</a>, <a href="#string-1">string/1</a>.</p>
    530. 

  530. 

  531. <h3><a name="atom_name-1">atom_name/1</a></h3>
    532. 

  532. <p><tt>atom_name(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; string()</tt></p>
    533. 

  533. <p>Returns the printname of an <code>atom</code> node.
    534. 

  534.  </p>
    535. 

  535. <p><b>See also:</b> <a href="#atom-1">atom/1</a>.</p>
    536. 

  536. 

  537. <h3><a name="atom_value-1">atom_value/1</a></h3>
    538. 

  538. <p><tt>atom_value(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; atom()</tt></p>
    539. 

  539. <p>Returns the value represented by an <code>atom</code> node.
    540. 

  540.  </p>
    541. 

  541. <p><b>See also:</b> <a href="#atom-1">atom/1</a>.</p>
    542. 

  542. 

  543. <h3><a name="attribute-1">attribute/1</a></h3>
    544. 

  544. <p><tt>attribute(Name) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    545. 

  545. <p>Equivalent to <a href="#attribute-2"><tt>attribute(Name, none)</tt></a>.</p>
    546. 

  546. 

  547. 

  548. <h3><a name="attribute-2">attribute/2</a></h3>
    549. 

  549. <p><tt>attribute(Name::<a href="#type-syntaxTree">syntaxTree()</a>, Args::Arguments) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    550. 

  550. <ul><li><tt>Arguments = none | [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></li></ul></p>
    551. 

  551. <p>Creates an abstract program attribute. If
    552. 

  552.   <code>Arguments</code> is <code>[A1, ..., An]</code>, the result
    553. 

  553.   represents "<code>-<em>Name</em>(<em>A1</em>, ...,
    554. 

  554.   <em>An</em>).</code>". Otherwise, if <code>Arguments</code> is
    555. 

  555.   <code>none</code>, the result represents
    556. 

  556.   "<code>-<em>Name</em>.</code>". The latter form makes it possible
    557. 

  557.   to represent preprocessor directives such as
    558. 

  558.   "<code>-endif.</code>". Attributes are source code forms.
    559. 

  559.  
    560. 

  560.   <p>Note: The preprocessor macro definition directive
    561. 

  561.   "<code>-define(<em>Name</em>, <em>Body</em>).</code>" has relatively
    562. 

  562.   few requirements on the syntactical form of <code>Body</code> (viewed
    563. 

  563.   as a sequence of tokens). The <code>text</code> node type can be used
    564. 

  564.   for a <code>Body</code> that is not a normal Erlang construct.</p>
    565. 

  565.  </p>
    566. 

  566. <p><b>See also:</b> <a href="#attribute-1">attribute/1</a>, <a href="#attribute_arguments-1">attribute_arguments/1</a>, <a href="#attribute_name-1">attribute_name/1</a>, <a href="#is_form-1">is_form/1</a>, <a href="#text-1">text/1</a>.</p>
    567. 

  567. 

  568. <h3><a name="attribute_arguments-1">attribute_arguments/1</a></h3>
    569. 

  569. <p><tt>attribute_arguments(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; none | [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    570. 

  570. <p>Returns the list of argument subtrees of an
    571. 

  571.   <code>attribute</code> node, if any. If <code>Node</code>
    572. 

  572.   represents "<code>-<em>Name</em>.</code>", the result is
    573. 

  573.   <code>none</code>. Otherwise, if <code>Node</code> represents
    574. 

  574.   "<code>-<em>Name</em>(<em>E1</em>, ..., <em>En</em>).</code>",
    575. 

  575.   <code>[E1, ..., E1]</code> is returned.
    576. 

  576.  </p>
    577. 

  577. <p><b>See also:</b> <a href="#attribute-1">attribute/1</a>.</p>
    578. 

  578. 

  579. <h3><a name="attribute_name-1">attribute_name/1</a></h3>
    580. 

  580. <p><tt>attribute_name(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    581. 

  581. <p>Returns the name subtree of an <code>attribute</code> node.
    582. 

  582.  </p>
    583. 

  583. <p><b>See also:</b> <a href="#attribute-1">attribute/1</a>.</p>
    584. 

  584. 

  585. <h3><a name="binary-1">binary/1</a></h3>
    586. 

  586. <p><tt>binary(Fields::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    587. 

  587. <p>Creates an abstract binary-object template. If
    588. 

  588.   <code>Fields</code> is <code>[F1, ..., Fn]</code>, the result
    589. 

  589.   represents "<code>&lt;&lt;<em>F1</em>, ...,
    590. 

  590.   <em>Fn</em>&gt;&gt;</code>".
    591. 

  591.  </p>
    592. 

  592. <p><b>See also:</b> <a href="#binary_field-2">binary_field/2</a>, <a href="#binary_fields-1">binary_fields/1</a>.</p>
    593. 

  593. 

  594. <h3><a name="binary_field-1">binary_field/1</a></h3>
    595. 

  595. <p><tt>binary_field(Body) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    596. 

  596. <p>Equivalent to <a href="#binary_field-2"><tt>binary_field(Body, [])</tt></a>.</p>
    597. 

  597. 

  598. 

  599. <h3><a name="binary_field-2">binary_field/2</a></h3>
    600. 

  600. <p><tt>binary_field(Body::<a href="#type-syntaxTree">syntaxTree()</a>, Types::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    601. 

  601. <p>Creates an abstract binary template field. If
    602. 

  602.   <code>Types</code> is the empty list, the result simply represents
    603. 

  603.   "<code><em>Body</em></code>", otherwise, if <code>Types</code> is
    604. 

  604.   <code>[T1, ..., Tn]</code>, the result represents
    605. 

  605.   "<code><em>Body</em>/<em>T1</em>-...-<em>Tn</em></code>".
    606. 

  606.  </p>
    607. 

  607. <p><b>See also:</b> <a href="#binary-1">binary/1</a>, <a href="#binary_field-1">binary_field/1</a>, <a href="#binary_field-3">binary_field/3</a>, <a href="#binary_field_body-1">binary_field_body/1</a>, <a href="#binary_field_size-1">binary_field_size/1</a>, <a href="#binary_field_types-1">binary_field_types/1</a>.</p>
    608. 

  608. 

  609. <h3><a name="binary_field-3">binary_field/3</a></h3>
    610. 

  610. <p><tt>binary_field(Body::<a href="#type-syntaxTree">syntaxTree()</a>, Size, Types::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    611. 

  611. <ul><li><tt>Size = none | <a href="#type-syntaxTree">syntaxTree()</a></tt></li></ul></p>
    612. 

  612. <p>Creates an abstract binary template field. (Utility function.)
    613. 

  613.   If <code>Size</code> is <code>none</code>, this is equivalent to
    614. 

  614.   "<code>binary_field(Body, Types)</code>", otherwise it is
    615. 

  615.   equivalent to "<code>binary_field(size_qualifier(Body, Size),
    616. 

  616.   Types)</code>".
    617. 

  617.  </p>
    618. 

  618. <p><b>See also:</b> <a href="#binary-1">binary/1</a>, <a href="#binary_field-2">binary_field/2</a>, <a href="#size_qualifier-2">size_qualifier/2</a>.</p>
    619. 

  619. 

  620. <h3><a name="binary_field_body-1">binary_field_body/1</a></h3>
    621. 

  621. <p><tt>binary_field_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    622. 

  622. <p>Returns the body subtree of a <code>binary_field</code>.
    623. 

  623.  </p>
    624. 

  624. <p><b>See also:</b> <a href="#binary_field-2">binary_field/2</a>.</p>
    625. 

  625. 

  626. <h3><a name="binary_field_size-1">binary_field_size/1</a></h3>
    627. 

  627. <p><tt>binary_field_size(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; none | <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    628. 

  628. <p>Returns the size specifier subtree of a
    629. 

  629.   <code>binary_field</code> node, if any. (Utility function.) If
    630. 

  630.   <code>Node</code> represents
    631. 

  631.   "<code><em>Body</em>:<em>Size</em></code>" or
    632. 

  632.   "<code><em>Body</em>:<em>Size</em>/<em>T1</em>, ...,
    633. 

  633.   <em>Tn</em></code>", the result is <code>Size</code>, otherwise
    634. 

  634.   <code>none</code> is returned.
    635. 

  635.  </p>
    636. 

  636. <p><b>See also:</b> <a href="#binary_field-2">binary_field/2</a>, <a href="#binary_field-3">binary_field/3</a>.</p>
    637. 

  637. 

  638. <h3><a name="binary_field_types-1">binary_field_types/1</a></h3>
    639. 

  639. <p><tt>binary_field_types(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    640. 

  640. <p>Returns the list of type-specifier subtrees of a
    641. 

  641.   <code>binary_field</code> node. If <code>Node</code> represents
    642. 

  642.   "<code>.../<em>T1</em>, ..., <em>Tn</em></code>", the result is
    643. 

  643.   <code>[T1, ..., Tn]</code>, otherwise the result is the empty list.
    644. 

  644.  </p>
    645. 

  645. <p><b>See also:</b> <a href="#binary_field-2">binary_field/2</a>.</p>
    646. 

  646. 

  647. <h3><a name="binary_fields-1">binary_fields/1</a></h3>
    648. 

  648. <p><tt>binary_fields(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    649. 

  649. <p>Returns the list of field subtrees of a <code>binary</code>
    650. 

  650.   node.
    651. 

  651.  </p>
    652. 

  652. <p><b>See also:</b> <a href="#binary-1">binary/1</a>, <a href="#binary_field-2">binary_field/2</a>.</p>
    653. 

  653. 

  654. <h3><a name="block_expr-1">block_expr/1</a></h3>
    655. 

  655. <p><tt>block_expr(Body::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    656. 

  656. <p>Creates an abstract block expression. If <code>Body</code> is
    657. 

  657.   <code>[B1, ..., Bn]</code>, the result represents "<code>begin
    658. 

  658.   <em>B1</em>, ..., <em>Bn</em> end</code>".
    659. 

  659.  </p>
    660. 

  660. <p><b>See also:</b> <a href="#block_expr_body-1">block_expr_body/1</a>.</p>
    661. 

  661. 

  662. <h3><a name="block_expr_body-1">block_expr_body/1</a></h3>
    663. 

  663. <p><tt>block_expr_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    664. 

  664. <p>Returns the list of body subtrees of a <code>block_expr</code>
    665. 

  665.   node.
    666. 

  666.  </p>
    667. 

  667. <p><b>See also:</b> <a href="#block_expr-1">block_expr/1</a>.</p>
    668. 

  668. 

  669. <h3><a name="case_expr-2">case_expr/2</a></h3>
    670. 

  670. <p><tt>case_expr(Argument::<a href="#type-syntaxTree">syntaxTree()</a>, Clauses::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    671. 

  671. <p>Creates an abstract case-expression. If <code>Clauses</code> is
    672. 

  672.   <code>[C1, ..., Cn]</code>, the result represents "<code>case
    673. 

  673.   <em>Argument</em> of <em>C1</em>; ...; <em>Cn</em> end</code>". More
    674. 

  674.   exactly, if each <code>Ci</code> represents "<code>(<em>Pi</em>)
    675. 

  675.   <em>Gi</em> -&gt; <em>Bi</em></code>", then the result represents
    676. 

  676.   "<code>case <em>Argument</em> of <em>P1</em> <em>G1</em> -&gt;
    677. 

  677.   <em>B1</em>; ...; <em>Pn</em> <em>Gn</em> -&gt; <em>Bn</em> end</code>".
    678. 

  678.  </p>
    679. 

  679. <p><b>See also:</b> <a href="#case_expr_argument-1">case_expr_argument/1</a>, <a href="#case_expr_clauses-1">case_expr_clauses/1</a>, <a href="#clause-3">clause/3</a>, <a href="#cond_expr-1">cond_expr/1</a>, <a href="#if_expr-1">if_expr/1</a>.</p>
    680. 

  680. 

  681. <h3><a name="case_expr_argument-1">case_expr_argument/1</a></h3>
    682. 

  682. <p><tt>case_expr_argument(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    683. 

  683. <p>Returns the argument subtree of a <code>case_expr</code> node.
    684. 

  684.  </p>
    685. 

  685. <p><b>See also:</b> <a href="#case_expr-2">case_expr/2</a>.</p>
    686. 

  686. 

  687. <h3><a name="case_expr_clauses-1">case_expr_clauses/1</a></h3>
    688. 

  688. <p><tt>case_expr_clauses(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    689. 

  689. <p>Returns the list of clause subtrees of a <code>case_expr</code>
    690. 

  690.   node.
    691. 

  691.  </p>
    692. 

  692. <p><b>See also:</b> <a href="#case_expr-2">case_expr/2</a>.</p>
    693. 

  693. 

  694. <h3><a name="catch_expr-1">catch_expr/1</a></h3>
    695. 

  695. <p><tt>catch_expr(Expr::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    696. 

  696. <p>Creates an abstract catch-expression. The result represents
    697. 

  697.   "<code>catch <em>Expr</em></code>".
    698. 

  698.  </p>
    699. 

  699. <p><b>See also:</b> <a href="#catch_expr_body-1">catch_expr_body/1</a>.</p>
    700. 

  700. 

  701. <h3><a name="catch_expr_body-1">catch_expr_body/1</a></h3>
    702. 

  702. <p><tt>catch_expr_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    703. 

  703. <p>Returns the body subtree of a <code>catch_expr</code> node.
    704. 

  704.  </p>
    705. 

  705. <p><b>See also:</b> <a href="#catch_expr-1">catch_expr/1</a>.</p>
    706. 

  706. 

  707. <h3><a name="char-1">char/1</a></h3>
    708. 

  708. <p><tt>char(Value::char()) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    709. 

  709. <p>Creates an abstract character literal. The result represents
    710. 

  710.   "<code>$<em>Name</em></code>", where <code>Name</code> corresponds to
    711. 

  711.   <code>Value</code>.
    712. 

  712.  
    713. 

  713.   <p>Note: the literal corresponding to a particular character value is
    714. 

  714.   not uniquely defined. E.g., the character "<code>a</code>" can be
    715. 

  715.   written both as "<code>$a</code>" and "<code>$\141</code>", and a Tab
    716. 

  716.   character can be written as "<code>$\11</code>", "<code>$\011</code>"
    717. 

  717.   or "<code>$\t</code>".</p>
    718. 

  718.  </p>
    719. 

  719. <p><b>See also:</b> <a href="#char_literal-1">char_literal/1</a>, <a href="#char_value-1">char_value/1</a>, <a href="#is_char-2">is_char/2</a>.</p>
    720. 

  720. 

  721. <h3><a name="char_literal-1">char_literal/1</a></h3>
    722. 

  722. <p><tt>char_literal(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; string()</tt></p>
    723. 

  723. <p>Returns the literal string represented by a <code>char</code>
    724. 

  724.   node. This includes the leading "<code>$</code>" character.
    725. 

  725.  </p>
    726. 

  726. <p><b>See also:</b> <a href="#char-1">char/1</a>.</p>
    727. 

  727. 

  728. <h3><a name="char_value-1">char_value/1</a></h3>
    729. 

  729. <p><tt>char_value(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; char()</tt></p>
    730. 

  730. <p>Returns the value represented by a <code>char</code> node.
    731. 

  731.  </p>
    732. 

  732. <p><b>See also:</b> <a href="#char-1">char/1</a>.</p>
    733. 

  733. 

  734. <h3><a name="class_qualifier-2">class_qualifier/2</a></h3>
    735. 

  735. <p><tt>class_qualifier(Class::<a href="#type-syntaxTree">syntaxTree()</a>, Body::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    736. 

  736. <p>Creates an abstract class qualifier. The result represents
    737. 

  737.   "<code><em>Class</em>:<em>Body</em></code>".
    738. 

  738.  </p>
    739. 

  739. <p><b>See also:</b> <a href="#class_qualifier_argument-1">class_qualifier_argument/1</a>, <a href="#class_qualifier_body-1">class_qualifier_body/1</a>, <a href="#try_expr-4">try_expr/4</a>.</p>
    740. 

  740. 

  741. <h3><a name="class_qualifier_argument-1">class_qualifier_argument/1</a></h3>
    742. 

  742. <p><tt>class_qualifier_argument(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    743. 

  743. <p>Returns the argument (the class) subtree of a
    744. 

  744.   <code>class_qualifier</code> node.
    745. 

  745.  </p>
    746. 

  746. <p><b>See also:</b> <a href="#class_qualifier-1">class_qualifier/1</a>.</p>
    747. 

  747. 

  748. <h3><a name="class_qualifier_body-1">class_qualifier_body/1</a></h3>
    749. 

  749. <p><tt>class_qualifier_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    750. 

  750. <p>Returns the body subtree of a <code>class_qualifier</code> node.
    751. 

  751.  </p>
    752. 

  752. <p><b>See also:</b> <a href="#class_qualifier-1">class_qualifier/1</a>.</p>
    753. 

  753. 

  754. <h3><a name="clause-2">clause/2</a></h3>
    755. 

  755. <p><tt>clause(Guard, Body) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    756. 

  756. <p>Equivalent to <a href="#clause-3"><tt>clause([], Guard, Body)</tt></a>.</p>
    757. 

  757. 

  758. 

  759. <h3><a name="clause-3">clause/3</a></h3>
    760. 

  760. <p><tt>clause(Patterns::[<a href="#type-syntaxTree">syntaxTree()</a>], Guard, Body::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    761. 

  761. <ul><li><tt>Guard = none | <a href="#type-syntaxTree">syntaxTree()</a> | [<a href="#type-syntaxTree">syntaxTree()</a>] | [[<a href="#type-syntaxTree">syntaxTree()</a>]]</tt></li></ul></p>
    762. 

  762. <p>Creates an abstract clause. If <code>Patterns</code> is
    763. 

  763.   <code>[P1, ..., Pn]</code> and <code>Body</code> is <code>[B1, ...,
    764. 

  764.   Bm]</code>, then if <code>Guard</code> is <code>none</code>, the
    765. 

  765.   result represents "<code>(<em>P1</em>, ..., <em>Pn</em>) -&gt;
    766. 

  766.   <em>B1</em>, ..., <em>Bm</em></code>", otherwise, unless
    767. 

  767.   <code>Guard</code> is a list, the result represents
    768. 

  768.   "<code>(<em>P1</em>, ..., <em>Pn</em>) when <em>Guard</em> -&gt;
    769. 

  769.   <em>B1</em>, ..., <em>Bm</em></code>".
    770. 

  770.  
    771. 

  771.   <p>For simplicity, the <code>Guard</code> argument may also be any
    772. 

  772.   of the following:
    773. 

  773.   <ul>
    774. 

  774.     <li>An empty list <code>[]</code>. This is equivalent to passing
    775. 

  775.         <code>none</code>.</li>
    776. 

  776.     <li>A nonempty list <code>[E1, ..., Ej]</code> of syntax trees.
    777. 

  777.         This is equivalent to passing <code>conjunction([E1, ...,
    778. 

  778.         Ej])</code>.</li>
    779. 

  779.     <li>A nonempty list of lists of syntax trees <code>[[E1_1, ...,
    780. 

  780.         E1_k1], ..., [Ej_1, ..., Ej_kj]]</code>, which is equivalent
    781. 

  781.         to passing <code>disjunction([conjunction([E1_1, ...,
    782. 

  782.         E1_k1]), ..., conjunction([Ej_1, ..., Ej_kj])])</code>.</li>
    783. 

  783.   </ul>
    784. 

  784.   </p>
    785. 

  785.  </p>
    786. 

  786. <p><b>See also:</b> <a href="#clause-2">clause/2</a>, <a href="#clause_body-1">clause_body/1</a>, <a href="#clause_guard-1">clause_guard/1</a>, <a href="#clause_patterns-1">clause_patterns/1</a>.</p>
    787. 

  787. 

  788. <h3><a name="clause_body-1">clause_body/1</a></h3>
    789. 

  789. <p><tt>clause_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    790. 

  790. <p>Return the list of body subtrees of a <code>clause</code>
    791. 

  791.   node.
    792. 

  792.  </p>
    793. 

  793. <p><b>See also:</b> <a href="#clause-3">clause/3</a>.</p>
    794. 

  794. 

  795. <h3><a name="clause_guard-1">clause_guard/1</a></h3>
    796. 

  796. <p><tt>clause_guard(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; none | <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    797. 

  797. <p>Returns the guard subtree of a <code>clause</code> node, if
    798. 

  798.   any. If <code>Node</code> represents "<code>(<em>P1</em>, ...,
    799. 

  799.   <em>Pn</em>) when <em>Guard</em> -&gt; <em>B1</em>, ...,
    800. 

  800.   <em>Bm</em></code>", <code>Guard</code> is returned. Otherwise, the
    801. 

  801.   result is <code>none</code>.
    802. 

  802.  </p>
    803. 

  803. <p><b>See also:</b> <a href="#clause-3">clause/3</a>.</p>
    804. 

  804. 

  805. <h3><a name="clause_patterns-1">clause_patterns/1</a></h3>
    806. 

  806. <p><tt>clause_patterns(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    807. 

  807. <p>Returns the list of pattern subtrees of a <code>clause</code>
    808. 

  808.   node.
    809. 

  809.  </p>
    810. 

  810. <p><b>See also:</b> <a href="#clause-3">clause/3</a>.</p>
    811. 

  811. 

  812. <h3><a name="comment-1">comment/1</a></h3>
    813. 

  813. <p><tt>comment(Strings) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    814. 

  814. <p>Equivalent to <a href="#comment-2"><tt>comment(none, Strings)</tt></a>.</p>
    815. 

  815. 

  816. 

  817. <h3><a name="comment-2">comment/2</a></h3>
    818. 

  818. <p><tt>comment(Pad::Padding, Strings::[string()]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    819. 

  819. <ul><li><tt>Padding = none | integer()</tt></li></ul></p>
    820. 

  820. <p>Creates an abstract comment with the given padding and text. If
    821. 

  821.   <code>Strings</code> is a (possibly empty) list
    822. 

  822.   <code>["<em>Txt1</em>", ..., "<em>TxtN</em>"]</code>, the result
    823. 

  823.   represents the source code text
    824. 

  824.   <pre>
    825. 

  825.       %<em>Txt1</em>
    826. 

  826.       ...
    827. 

  827.       %<em>TxtN</em></pre>
    828. 

  828.   <code>Padding</code> states the number of empty character positions
    829. 

  829.   to the left of the comment separating it horizontally from
    830. 

  830.   source code on the same line (if any). If <code>Padding</code> is
    831. 

  831.   <code>none</code>, a default positive number is used. If
    832. 

  832.   <code>Padding</code> is an integer less than 1, there should be no
    833. 

  833.   separating space. Comments are in themselves regarded as source
    834. 

  834.   program forms.
    835. 

  835.  </p>
    836. 

  836. <p><b>See also:</b> <a href="#comment-1">comment/1</a>, <a href="#is_form-1">is_form/1</a>.</p>
    837. 

  837. 

  838. <h3><a name="comment_padding-1">comment_padding/1</a></h3>
    839. 

  839. <p><tt>comment_padding(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; none | integer()</tt></p>
    840. 

  840. <p>Returns the amount of padding before the comment, or
    841. 

  841.   <code>none</code>. The latter means that a default padding may be
    842. 

  842.   used.
    843. 

  843.  </p>
    844. 

  844. <p><b>See also:</b> <a href="#comment-2">comment/2</a>.</p>
    845. 

  845. 

  846. <h3><a name="comment_text-1">comment_text/1</a></h3>
    847. 

  847. <p><tt>comment_text(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [string()]</tt></p>
    848. 

  848. <p>Returns the lines of text of the abstract comment.
    849. 

  849.  </p>
    850. 

  850. <p><b>See also:</b> <a href="#comment-2">comment/2</a>.</p>
    851. 

  851. 

  852. <h3><a name="compact_list-1">compact_list/1</a></h3>
    853. 

  853. <p><tt>compact_list(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    854. 

  854. <p>Yields the most compact form for an abstract list skeleton. The
    855. 

  855.   result either represents "<code>[<em>E1</em>, ..., <em>En</em> |
    856. 

  856.   <em>Tail</em>]</code>", where <code>Tail</code> is not a list
    857. 

  857.   skeleton, or otherwise simply "<code>[<em>E1</em>, ...,
    858. 

  858.   <em>En</em>]</code>". Annotations on subtrees of <code>Node</code>
    859. 

  859.   that represent list skeletons may be lost, but comments will be
    860. 

  860.   propagated to the result. Returns <code>Node</code> itself if
    861. 

  861.   <code>Node</code> does not represent a list skeleton.
    862. 

  862.  </p>
    863. 

  863. <p><b>See also:</b> <a href="#list-2">list/2</a>, <a href="#normalize_list-1">normalize_list/1</a>.</p>
    864. 

  864. 

  865. <h3><a name="concrete-1">concrete/1</a></h3>
    866. 

  866. <p><tt>concrete(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; term()</tt></p>
    867. 

  867. <p>Returns the Erlang term represented by a syntax tree. Evaluation
    868. 

  868.   fails with reason <code>badarg</code> if <code>Node</code> does not
    869. 

  869.   represent a literal term.
    870. 

  870.  
    871. 

  871.   <p>Note: Currently, the set of syntax trees which have a concrete
    872. 

  872.   representation is larger than the set of trees which can be built
    873. 

  873.   using the function <code>abstract/1</code>. An abstract character
    874. 

  874.   will be concretised as an integer, while <code>abstract/1</code> does
    875. 

  875.   not at present yield an abstract character for any input. (Use the
    876. 

  876.   <code>char/1</code> function to explicitly create an abstract
    877. 

  877.   character.)</p>
    878. 

  878.  </p>
    879. 

  879. <p><b>See also:</b> <a href="#abstract-1">abstract/1</a>, <a href="#char-1">char/1</a>, <a href="#is_literal-1">is_literal/1</a>.</p>
    880. 

  880. 

  881. <h3><a name="cond_expr-1">cond_expr/1</a></h3>
    882. 

  882. <p><tt>cond_expr(Clauses::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    883. 

  883. <p>Creates an abstract cond-expression. If <code>Clauses</code> is
    884. 

  884.   <code>[C1, ..., Cn]</code>, the result represents "<code>cond
    885. 

  885.   <em>C1</em>; ...; <em>Cn</em> end</code>". More exactly, if each
    886. 

  886.   <code>Ci</code> represents "<code>() <em>Ei</em> -&gt;
    887. 

  887.   <em>Bi</em></code>", then the result represents "<code>cond
    888. 

  888.   <em>E1</em> -&gt; <em>B1</em>; ...; <em>En</em> -&gt; <em>Bn</em>
    889. 

  889.   end</code>".
    890. 

  890.  </p>
    891. 

  891. <p><b>See also:</b> <a href="#case_expr-2">case_expr/2</a>, <a href="#clause-3">clause/3</a>, <a href="#cond_expr_clauses-1">cond_expr_clauses/1</a>.</p>
    892. 

  892. 

  893. <h3><a name="cond_expr_clauses-1">cond_expr_clauses/1</a></h3>
    894. 

  894. <tt>cond_expr_clauses(Node) -&gt; term()
    895. 

  895. </tt><p>Returns the list of clause subtrees of a <code>cond_expr</code>
    896. 

  896.   node.
    897. 

  897.  </p>
    898. 

  898. <p><b>See also:</b> <a href="#cond_expr-1">cond_expr/1</a>.</p>
    899. 

  899. 

  900. <h3><a name="conjunction-1">conjunction/1</a></h3>
    901. 

  901. <p><tt>conjunction(List::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    902. 

  902. <p>Creates an abstract conjunction. If <code>List</code> is
    903. 

  903.   <code>[E1, ..., En]</code>, the result represents
    904. 

  904.   "<code><em>E1</em>, ..., <em>En</em></code>".
    905. 

  905.  </p>
    906. 

  906. <p><b>See also:</b> <a href="#conjunction_body-1">conjunction_body/1</a>, <a href="#disjunction-1">disjunction/1</a>.</p>
    907. 

  907. 

  908. <h3><a name="conjunction_body-1">conjunction_body/1</a></h3>
    909. 

  909. <p><tt>conjunction_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    910. 

  910. <p>Returns the list of body subtrees of a
    911. 

  911.   <code>conjunction</code> node.
    912. 

  912.  </p>
    913. 

  913. <p><b>See also:</b> <a href="#conjunction-1">conjunction/1</a>.</p>
    914. 

  914. 

  915. <h3><a name="cons-2">cons/2</a></h3>
    916. 

  916. <p><tt>cons(Head::<a href="#type-syntaxTree">syntaxTree()</a>, Tail::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    917. 

  917. <p>"Optimising" list skeleton cons operation. Creates an abstract
    918. 

  918.   list skeleton whose first element is <code>Head</code> and whose tail
    919. 

  919.   corresponds to <code>Tail</code>. This is similar to
    920. 

  920.   <code>list([Head], Tail)</code>, except that <code>Tail</code> may
    921. 

  921.   not be <code>none</code>, and that the result does not necessarily
    922. 

  922.   represent exactly "<code>[<em>Head</em> | <em>Tail</em>]</code>", but
    923. 

  923.   may depend on the <code>Tail</code> subtree. E.g., if
    924. 

  924.   <code>Tail</code> represents <code>[X, Y]</code>, the result may
    925. 

  925.   represent "<code>[<em>Head</em>, X, Y]</code>", rather than
    926. 

  926.   "<code>[<em>Head</em> | [X, Y]]</code>". Annotations on
    927. 

  927.   <code>Tail</code> itself may be lost if <code>Tail</code> represents
    928. 

  928.   a list skeleton, but comments on <code>Tail</code> are propagated to
    929. 

  929.   the result.
    930. 

  930.  </p>
    931. 

  931. <p><b>See also:</b> <a href="#list-2">list/2</a>, <a href="#list_head-1">list_head/1</a>, <a href="#list_tail-1">list_tail/1</a>.</p>
    932. 

  932. 

  933. <h3><a name="copy_ann-2">copy_ann/2</a></h3>
    934. 

  934. <p><tt>copy_ann(Source::<a href="#type-syntaxTree">syntaxTree()</a>, Target::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    935. 

  935. <p>Copies the list of user annotations from <code>Source</code> to
    936. 

  936.   <code>Target</code>.
    937. 

  937.  
    938. 

  938.   <p>Note: this is equivalent to <code>set_ann(Target,
    939. 

  939.   get_ann(Source))</code>, but potentially more efficient.</p>
    940. 

  940.  </p>
    941. 

  941. <p><b>See also:</b> <a href="#get_ann-1">get_ann/1</a>, <a href="#set_ann-2">set_ann/2</a>.</p>
    942. 

  942. 

  943. <h3><a name="copy_attrs-2">copy_attrs/2</a></h3>
    944. 

  944. <p><tt>copy_attrs(Source::<a href="#type-syntaxTree">syntaxTree()</a>, Target::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    945. 

  945. <p>Copies the attributes from <code>Source</code> to
    946. 

  946.   <code>Target</code>.
    947. 

  947.  
    948. 

  948.   <p>Note: this is equivalent to <code>set_attrs(Target,
    949. 

  949.   get_attrs(Source))</code>, but potentially more efficient.</p>
    950. 

  950.  </p>
    951. 

  951. <p><b>See also:</b> <a href="#get_attrs-1">get_attrs/1</a>, <a href="#set_attrs-2">set_attrs/2</a>.</p>
    952. 

  952. 

  953. <h3><a name="copy_comments-2">copy_comments/2</a></h3>
    954. 

  954. <p><tt>copy_comments(Source::<a href="#type-syntaxTree">syntaxTree()</a>, Target::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    955. 

  955. <p>Copies the pre- and postcomments from <code>Source</code> to
    956. 

  956.   <code>Target</code>.
    957. 

  957.  
    958. 

  958.   <p>Note: This is equivalent to
    959. 

  959.   <code>set_postcomments(set_precomments(Target,
    960. 

  960.   get_precomments(Source)), get_postcomments(Source))</code>, but
    961. 

  961.   potentially more efficient.</p>
    962. 

  962.  </p>
    963. 

  963. <p><b>See also:</b> <a href="#comment-2">comment/2</a>, <a href="#get_postcomments-1">get_postcomments/1</a>, <a href="#get_precomments-1">get_precomments/1</a>, <a href="#set_postcomments-2">set_postcomments/2</a>, <a href="#set_precomments-2">set_precomments/2</a>.</p>
    964. 

  964. 

  965. <h3><a name="copy_pos-2">copy_pos/2</a></h3>
    966. 

  966. <p><tt>copy_pos(Source::<a href="#type-syntaxTree">syntaxTree()</a>, Target::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    967. 

  967. <p>Copies the position information from <code>Source</code> to
    968. 

  968.   <code>Target</code>.
    969. 

  969.  
    970. 

  970.   <p>This is equivalent to <code>set_pos(Target,
    971. 

  971.   get_pos(Source))</code>, but potentially more efficient.</p>
    972. 

  972.  </p>
    973. 

  973. <p><b>See also:</b> <a href="#get_pos-1">get_pos/1</a>, <a href="#set_pos-2">set_pos/2</a>.</p>
    974. 

  974. 

  975. <h3><a name="data-1">data/1</a></h3>
    976. 

  976. <p><tt>data(Tree::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; term()</tt></p>
    977. 

  977. <p><em>For special purposes only</em>. Returns the associated data
    978. 

  978.   of a syntax tree node. Evaluation fails with reason
    979. 

  979.   <code>badarg</code> if <code>is_tree(Node)</code> does not yield
    980. 

  980.   <code>true</code>.
    981. 

  981.  </p>
    982. 

  982. <p><b>See also:</b> <a href="#tree-2">tree/2</a>.</p>
    983. 

  983. 

  984. <h3><a name="disjunction-1">disjunction/1</a></h3>
    985. 

  985. <p><tt>disjunction(List::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    986. 

  986. <p>Creates an abstract disjunction. If <code>List</code> is
    987. 

  987.   <code>[E1, ..., En]</code>, the result represents
    988. 

  988.   "<code><em>E1</em>; ...; <em>En</em></code>".
    989. 

  989.  </p>
    990. 

  990. <p><b>See also:</b> <a href="#conjunction-1">conjunction/1</a>, <a href="#disjunction_body-1">disjunction_body/1</a>.</p>
    991. 

  991. 

  992. <h3><a name="disjunction_body-1">disjunction_body/1</a></h3>
    993. 

  993. <p><tt>disjunction_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    994. 

  994. <p>Returns the list of body subtrees of a
    995. 

  995.   <code>disjunction</code> node.
    996. 

  996.  </p>
    997. 

  997. <p><b>See also:</b> <a href="#disjunction-1">disjunction/1</a>.</p>
    998. 

  998. 

  999. <h3><a name="eof_marker-0">eof_marker/0</a></h3>
    1000. 

  1000. <p><tt>eof_marker() -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1001. 

  1001. <p>Creates an abstract end-of-file marker. This represents the
    1002. 

  1002.   end of input when reading a sequence of source code forms. An
    1003. 

  1003.   end-of-file marker is itself regarded as a source code form
    1004. 

  1004.   (namely, the last in any sequence in which it occurs). It has no
    1005. 

  1005.   defined lexical form.
    1006. 

  1006.  
    1007. 

  1007.   <p>Note: this is retained only for backwards compatibility with
    1008. 

  1008.   existing parsers and tools.</p>
    1009. 

  1009.  </p>
    1010. 

  1010. <p><b>See also:</b> <a href="#error_marker-1">error_marker/1</a>, <a href="#is_form-1">is_form/1</a>, <a href="#warning_marker-1">warning_marker/1</a>.</p>
    1011. 

  1011. 

  1012. <h3><a name="error_marker-1">error_marker/1</a></h3>
    1013. 

  1013. <p><tt>error_marker(Error::term()) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1014. 

  1014. <p>Creates an abstract error marker. The result represents an
    1015. 

  1015.   occurrence of an error in the source code, with an associated Erlang
    1016. 

  1016.   I/O ErrorInfo structure given by <code>Error</code> (see module
    1017. 

  1017.   <code>io</code> for details). Error markers are regarded as source
    1018. 

  1018.   code forms, but have no defined lexical form.
    1019. 

  1019.  
    1020. 

  1020.   <p>Note: this is supported only for backwards compatibility with
    1021. 

  1021.   existing parsers and tools.</p>
    1022. 

  1022.  </p>
    1023. 

  1023. <p><b>See also:</b> <a href="/usr/local/home/richardc/hipe/otp/lib/stdlib/doc/io.html">io</a>, <a href="#eof_marker-0">eof_marker/0</a>, <a href="#error_marker_info-1">error_marker_info/1</a>, <a href="#is_form-1">is_form/1</a>, <a href="#warning_marker-1">warning_marker/1</a>.</p>
    1024. 

  1024. 

  1025. <h3><a name="error_marker_info-1">error_marker_info/1</a></h3>
    1026. 

  1026. <p><tt>error_marker_info(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; term()</tt></p>
    1027. 

  1027. <p>Returns the ErrorInfo structure of an <code>error_marker</code>
    1028. 

  1028.   node.
    1029. 

  1029.  </p>
    1030. 

  1030. <p><b>See also:</b> <a href="#error_marker-1">error_marker/1</a>.</p>
    1031. 

  1031. 

  1032. <h3><a name="flatten_form_list-1">flatten_form_list/1</a></h3>
    1033. 

  1033. <p><tt>flatten_form_list(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1034. 

  1034. <p>Flattens sublists of a <code>form_list</code> node. Returns
    1035. 

  1035.   <code>Node</code> with all subtrees of type <code>form_list</code>
    1036. 

  1036.   recursively expanded, yielding a single "flat" abstract form
    1037. 

  1037.   sequence.
    1038. 

  1038.  </p>
    1039. 

  1039. <p><b>See also:</b> <a href="#form_list-1">form_list/1</a>.</p>
    1040. 

  1040. 

  1041. <h3><a name="float-1">float/1</a></h3>
    1042. 

  1042. <p><tt>float(Value::float()) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1043. 

  1043. <p>Creates an abstract floating-point literal. The lexical
    1044. 

  1044.   representation is the decimal floating-point numeral of
    1045. 

  1045.   <code>Value</code>.
    1046. 

  1046.  </p>
    1047. 

  1047. <p><b>See also:</b> <a href="#float_literal-1">float_literal/1</a>, <a href="#float_value-1">float_value/1</a>.</p>
    1048. 

  1048. 

  1049. <h3><a name="float_literal-1">float_literal/1</a></h3>
    1050. 

  1050. <p><tt>float_literal(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; string()</tt></p>
    1051. 

  1051. <p>Returns the numeral string represented by a <code>float</code>
    1052. 

  1052.   node.
    1053. 

  1053.  </p>
    1054. 

  1054. <p><b>See also:</b> <a href="#float-1">float/1</a>.</p>
    1055. 

  1055. 

  1056. <h3><a name="float_value-1">float_value/1</a></h3>
    1057. 

  1057. <p><tt>float_value(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; float()</tt></p>
    1058. 

  1058. <p>Returns the value represented by a <code>float</code> node. Note
    1059. 

  1059.   that floating-point values should usually not be compared for
    1060. 

  1060.   equality.
    1061. 

  1061.  </p>
    1062. 

  1062. <p><b>See also:</b> <a href="#float-1">float/1</a>.</p>
    1063. 

  1063. 

  1064. <h3><a name="form_list-1">form_list/1</a></h3>
    1065. 

  1065. <p><tt>form_list(Forms::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1066. 

  1066. <p>Creates an abstract sequence of "source code forms". If
    1067. 

  1067.   <code>Forms</code> is <code>[F1, ..., Fn]</code>, where each
    1068. 

  1068.   <code>Fi</code> is a form (cf. <code>is_form/1</code>, the result
    1069. 

  1069.   represents
    1070. 

  1070.   <pre>
    1071. 

  1071.       <em>F1</em>
    1072. 

  1072.       ...
    1073. 

  1073.       <em>Fn</em></pre>
    1074. 

  1074.   where the <code>Fi</code> are separated by one or more line breaks. A
    1075. 

  1075.   node of type <code>form_list</code> is itself regarded as a source
    1076. 

  1076.   code form; cf. <code>flatten_form_list/1</code>.
    1077. 

  1077.  
    1078. 

  1078.   <p>Note: this is simply a way of grouping source code forms as a
    1079. 

  1079.   single syntax tree, usually in order to form an Erlang module
    1080. 

  1080.   definition.</p>
    1081. 

  1081.  </p>
    1082. 

  1082. <p><b>See also:</b> <a href="#flatten_form_list-1">flatten_form_list/1</a>, <a href="#form_list_elements-1">form_list_elements/1</a>, <a href="#is_form-1">is_form/1</a>.</p>
    1083. 

  1083. 

  1084. <h3><a name="form_list_elements-1">form_list_elements/1</a></h3>
    1085. 

  1085. <p><tt>form_list_elements(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    1086. 

  1086. <p>Returns the list of subnodes of a <code>form_list</code> node.
    1087. 

  1087.  </p>
    1088. 

  1088. <p><b>See also:</b> <a href="#form_list-1">form_list/1</a>.</p>
    1089. 

  1089. 

  1090. <h3><a name="fun_expr-1">fun_expr/1</a></h3>
    1091. 

  1091. <p><tt>fun_expr(Clauses::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1092. 

  1092. <p>Creates an abstract fun-expression. If <code>Clauses</code> is
    1093. 

  1093.   <code>[C1, ..., Cn]</code>, the result represents "<code>fun
    1094. 

  1094.   <em>C1</em>; ...; <em>Cn</em> end</code>". More exactly, if each
    1095. 

  1095.   <code>Ci</code> represents "<code>(<em>Pi1</em>, ..., <em>Pim</em>)
    1096. 

  1096.   <em>Gi</em> -&gt; <em>Bi</em></code>", then the result represents
    1097. 

  1097.   "<code>fun (<em>P11</em>, ..., <em>P1m</em>) <em>G1</em> -&gt;
    1098. 

  1098.   <em>B1</em>; ...; (<em>Pn1</em>, ..., <em>Pnm</em>) <em>Gn</em> -&gt;
    1099. 

  1099.   <em>Bn</em> end</code>".
    1100. 

  1100.  </p>
    1101. 

  1101. <p><b>See also:</b> <a href="#fun_expr_arity-1">fun_expr_arity/1</a>, <a href="#fun_expr_clauses-1">fun_expr_clauses/1</a>.</p>
    1102. 

  1102. 

  1103. <h3><a name="fun_expr_arity-1">fun_expr_arity/1</a></h3>
    1104. 

  1104. <p><tt>fun_expr_arity(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; integer()</tt></p>
    1105. 

  1105. <p>Returns the arity of a <code>fun_expr</code> node. The result is
    1106. 

  1106.   the number of parameter patterns in the first clause of the
    1107. 

  1107.   fun-expression; subsequent clauses are ignored.
    1108. 

  1108.  
    1109. 

  1109.   <p>An exception is thrown if <code>fun_expr_clauses(Node)</code>
    1110. 

  1110.   returns an empty list, or if the first element of that list is not a
    1111. 

  1111.   syntax tree <code>C</code> of type <code>clause</code> such that
    1112. 

  1112.   <code>clause_patterns(C)</code> is a nonempty list.</p>
    1113. 

  1113.  </p>
    1114. 

  1114. <p><b>See also:</b> <a href="#clause-3">clause/3</a>, <a href="#clause_patterns-1">clause_patterns/1</a>, <a href="#fun_expr-1">fun_expr/1</a>, <a href="#fun_expr_clauses-1">fun_expr_clauses/1</a>.</p>
    1115. 

  1115. 

  1116. <h3><a name="fun_expr_clauses-1">fun_expr_clauses/1</a></h3>
    1117. 

  1117. <p><tt>fun_expr_clauses(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    1118. 

  1118. <p>Returns the list of clause subtrees of a <code>fun_expr</code>
    1119. 

  1119.   node.
    1120. 

  1120.  </p>
    1121. 

  1121. <p><b>See also:</b> <a href="#fun_expr-1">fun_expr/1</a>.</p>
    1122. 

  1122. 

  1123. <h3><a name="function-2">function/2</a></h3>
    1124. 

  1124. <p><tt>function(Name::<a href="#type-syntaxTree">syntaxTree()</a>, Clauses::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1125. 

  1125. <p>Creates an abstract function definition. If <code>Clauses</code>
    1126. 

  1126.   is <code>[C1, ..., Cn]</code>, the result represents
    1127. 

  1127.   "<code><em>Name</em> <em>C1</em>; ...; <em>Name</em>
    1128. 

  1128.   <em>Cn</em>.</code>". More exactly, if each <code>Ci</code>
    1129. 

  1129.   represents "<code>(<em>Pi1</em>, ..., <em>Pim</em>) <em>Gi</em> -&gt;
    1130. 

  1130.   <em>Bi</em></code>", then the result represents
    1131. 

  1131.   "<code><em>Name</em>(<em>P11</em>, ..., <em>P1m</em>) <em>G1</em> -&gt;
    1132. 

  1132.   <em>B1</em>; ...; <em>Name</em>(<em>Pn1</em>, ..., <em>Pnm</em>)
    1133. 

  1133.   <em>Gn</em> -&gt; <em>Bn</em>.</code>". Function definitions are source
    1134. 

  1134.   code forms.
    1135. 

  1135.  </p>
    1136. 

  1136. <p><b>See also:</b> <a href="#function_arity-1">function_arity/1</a>, <a href="#function_clauses-1">function_clauses/1</a>, <a href="#function_name-1">function_name/1</a>, <a href="#is_form-1">is_form/1</a>, <a href="#rule-2">rule/2</a>.</p>
    1137. 

  1137. 

  1138. <h3><a name="function_arity-1">function_arity/1</a></h3>
    1139. 

  1139. <p><tt>function_arity(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; integer()</tt></p>
    1140. 

  1140. <p>Returns the arity of a <code>function</code> node. The result
    1141. 

  1141.   is the number of parameter patterns in the first clause of the
    1142. 

  1142.   function; subsequent clauses are ignored.
    1143. 

  1143.  
    1144. 

  1144.   <p>An exception is thrown if <code>function_clauses(Node)</code>
    1145. 

  1145.   returns an empty list, or if the first element of that list is not
    1146. 

  1146.   a syntax tree <code>C</code> of type <code>clause</code> such that
    1147. 

  1147.   <code>clause_patterns(C)</code> is a nonempty list.</p>
    1148. 

  1148.  </p>
    1149. 

  1149. <p><b>See also:</b> <a href="#clause-3">clause/3</a>, <a href="#clause_patterns-1">clause_patterns/1</a>, <a href="#function-2">function/2</a>, <a href="#function_clauses-1">function_clauses/1</a>.</p>
    1150. 

  1150. 

  1151. <h3><a name="function_clauses-1">function_clauses/1</a></h3>
    1152. 

  1152. <tt>function_clauses(Node) -&gt; term()
    1153. 

  1153. </tt><p>Returns the list of clause subtrees of a <code>function</code>
    1154. 

  1154.   node.
    1155. 

  1155.  </p>
    1156. 

  1156. <p><b>See also:</b> <a href="#function-2">function/2</a>.</p>
    1157. 

  1157. 

  1158. <h3><a name="function_name-1">function_name/1</a></h3>
    1159. 

  1159. <tt>function_name(Node) -&gt; term()
    1160. 

  1160. </tt><p>Returns the name subtree of a <code>function</code> node.
    1161. 

  1161.  </p>
    1162. 

  1162. <p><b>See also:</b> <a href="#function-2">function/2</a>.</p>
    1163. 

  1163. 

  1164. <h3><a name="generator-2">generator/2</a></h3>
    1165. 

  1165. <p><tt>generator(Pattern::<a href="#type-syntaxTree">syntaxTree()</a>, Body::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1166. 

  1166. <p>Creates an abstract generator. The result represents
    1167. 

  1167.   "<code><em>Pattern</em> &lt;- <em>Body</em></code>".
    1168. 

  1168.  </p>
    1169. 

  1169. <p><b>See also:</b> <a href="#generator_body-1">generator_body/1</a>, <a href="#generator_pattern-1">generator_pattern/1</a>, <a href="#list_comp-2">list_comp/2</a>.</p>
    1170. 

  1170. 

  1171. <h3><a name="generator_body-1">generator_body/1</a></h3>
    1172. 

  1172. <p><tt>generator_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1173. 

  1173. <p>Returns the body subtree of a <code>generator</code> node.
    1174. 

  1174.  </p>
    1175. 

  1175. <p><b>See also:</b> <a href="#generator-2">generator/2</a>.</p>
    1176. 

  1176. 

  1177. <h3><a name="generator_pattern-1">generator_pattern/1</a></h3>
    1178. 

  1178. <p><tt>generator_pattern(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1179. 

  1179. <p>Returns the pattern subtree of a <code>generator</code> node.
    1180. 

  1180.  </p>
    1181. 

  1181. <p><b>See also:</b> <a href="#generator-2">generator/2</a>.</p>
    1182. 

  1182. 

  1183. <h3><a name="get_ann-1">get_ann/1</a></h3>
    1184. 

  1184. <p><tt>get_ann(X1::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [term()]</tt></p>
    1185. 

  1185. <p>Returns the list of user annotations associated with a syntax
    1186. 

  1186.   tree node. For a newly created node, this is the empty list. The
    1187. 

  1187.   annotations may be any terms.
    1188. 

  1188.  </p>
    1189. 

  1189. <p><b>See also:</b> <a href="#get_attrs-1">get_attrs/1</a>, <a href="#set_ann-2">set_ann/2</a>.</p>
    1190. 

  1190. 

  1191. <h3><a name="get_attrs-1">get_attrs/1</a></h3>
    1192. 

  1192. <p><tt>get_attrs(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTreeAttributes">syntaxTreeAttributes()</a></tt></p>
    1193. 

  1193. <p>Returns a representation of the attributes associated with a
    1194. 

  1194.   syntax tree node. The attributes are all the extra information that
    1195. 

  1195.   can be attached to a node. Currently, this includes position
    1196. 

  1196.   information, source code comments, and user annotations. The result
    1197. 

  1197.   of this function cannot be inspected directly; only attached to
    1198. 

  1198.   another node (cf. <code>set_attrs/2</code>).
    1199. 

  1199.  
    1200. 

  1200.   <p>For accessing individual attributes, see <code>get_pos/1</code>,
    1201. 

  1201.   <code>get_ann/1</code>, <code>get_precomments/1</code> and
    1202. 

  1202.   <code>get_postcomments/1</code>.</p>
    1203. 

  1203.  </p>
    1204. 

  1204. <p><b>See also:</b> <a href="#get_ann-1">get_ann/1</a>, <a href="#get_pos-1">get_pos/1</a>, <a href="#get_postcomments-1">get_postcomments/1</a>, <a href="#get_precomments-1">get_precomments/1</a>, <a href="#set_attrs-2">set_attrs/2</a>.</p>
    1205. 

  1205. 

  1206. <h3><a name="get_pos-1">get_pos/1</a></h3>
    1207. 

  1207. <p><tt>get_pos(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; term()</tt></p>
    1208. 

  1208. <p>Returns the position information associated with
    1209. 

  1209.   <code>Node</code>. This is usually a nonnegative integer (indicating
    1210. 

  1210.   the source code line number), but may be any term. By default, all
    1211. 

  1211.   new tree nodes have their associated position information set to the
    1212. 

  1212.   integer zero.
    1213. 

  1213.  </p>
    1214. 

  1214. <p><b>See also:</b> <a href="#get_attrs-1">get_attrs/1</a>, <a href="#set_pos-2">set_pos/2</a>.</p>
    1215. 

  1215. 

  1216. <h3><a name="get_postcomments-1">get_postcomments/1</a></h3>
    1217. 

  1217. <p><tt>get_postcomments(X1::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    1218. 

  1218. <p>Returns the associated post-comments of a node. This is a
    1219. 

  1219.   possibly empty list of abstract comments, in top-down textual order.
    1220. 

  1220.   When the code is formatted, post-comments are typically displayed to
    1221. 

  1221.   the right of and/or below the node. For example:
    1222. 

  1222.   <pre>
    1223. 

  1223.           {foo, X, Y}     % Post-comment of tuple</pre>
    1224. 

  1224.  
    1225. 

  1225.   <p>If possible, the comment should be moved past any following
    1226. 

  1226.   separator characters on the same line, rather than placing the
    1227. 

  1227.   separators on the following line. E.g.:
    1228. 

  1228.   <pre>
    1229. 

  1229.           foo([X | Xs], Y) -&gt;
    1230. 

  1230.               foo(Xs, bar(X));     % Post-comment of 'bar(X)' node
    1231. 

  1231.            ...</pre>
    1232. 

  1232.   (where the comment is moved past the rightmost "<code>)</code>" and
    1233. 

  1233.   the "<code>;</code>").</p>
    1234. 

  1234.  </p>
    1235. 

  1235. <p><b>See also:</b> <a href="#comment-2">comment/2</a>, <a href="#get_attrs-1">get_attrs/1</a>, <a href="#get_precomments-1">get_precomments/1</a>, <a href="#set_postcomments-2">set_postcomments/2</a>.</p>
    1236. 

  1236. 

  1237. <h3><a name="get_precomments-1">get_precomments/1</a></h3>
    1238. 

  1238. <p><tt>get_precomments(X1::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    1239. 

  1239. <p>Returns the associated pre-comments of a node. This is a
    1240. 

  1240.   possibly empty list of abstract comments, in top-down textual order.
    1241. 

  1241.   When the code is formatted, pre-comments are typically displayed
    1242. 

  1242.   directly above the node. For example:
    1243. 

  1243.   <pre>
    1244. 

  1244.           % Pre-comment of function
    1245. 

  1245.           foo(X) -&gt; {bar, X}.</pre>
    1246. 

  1246.  
    1247. 

  1247.   <p>If possible, the comment should be moved before any preceding
    1248. 

  1248.   separator characters on the same line. E.g.:
    1249. 

  1249.   <pre>
    1250. 

  1250.           foo([X | Xs]) -&gt;
    1251. 

  1251.               % Pre-comment of 'bar(X)' node
    1252. 

  1252.               [bar(X) | foo(Xs)];
    1253. 

  1253.           ...</pre>
    1254. 

  1254.   (where the comment is moved before the "<code>[</code>").</p>
    1255. 

  1255.  </p>
    1256. 

  1256. <p><b>See also:</b> <a href="#comment-2">comment/2</a>, <a href="#get_attrs-1">get_attrs/1</a>, <a href="#get_postcomments-1">get_postcomments/1</a>, <a href="#set_precomments-2">set_precomments/2</a>.</p>
    1257. 

  1257. 

  1258. <h3><a name="has_comments-1">has_comments/1</a></h3>
    1259. 

  1259. <p><tt>has_comments(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; bool()</tt></p>
    1260. 

  1260. <p>Yields <code>false</code> if the node has no associated
    1261. 

  1261.   comments, and <code>true</code> otherwise.
    1262. 

  1262.  
    1263. 

  1263.   <p>Note: This is equivalent to <code>(get_precomments(Node) == [])
    1264. 

  1264.   and (get_postcomments(Node) == [])</code>, but potentially more
    1265. 

  1265.   efficient.</p>
    1266. 

  1266.  </p>
    1267. 

  1267. <p><b>See also:</b> <a href="#get_postcomments-1">get_postcomments/1</a>, <a href="#get_precomments-1">get_precomments/1</a>, <a href="#remove_comments-1">remove_comments/1</a>.</p>
    1268. 

  1268. 

  1269. <h3><a name="if_expr-1">if_expr/1</a></h3>
    1270. 

  1270. <p><tt>if_expr(Clauses::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1271. 

  1271. <p>Creates an abstract if-expression. If <code>Clauses</code> is
    1272. 

  1272.   <code>[C1, ..., Cn]</code>, the result represents "<code>if
    1273. 

  1273.   <em>C1</em>; ...; <em>Cn</em> end</code>". More exactly, if each
    1274. 

  1274.   <code>Ci</code> represents "<code>() <em>Gi</em> -&gt;
    1275. 

  1275.   <em>Bi</em></code>", then the result represents "<code>if
    1276. 

  1276.   <em>G1</em> -&gt; <em>B1</em>; ...; <em>Gn</em> -&gt; <em>Bn</em>
    1277. 

  1277.   end</code>".
    1278. 

  1278.  </p>
    1279. 

  1279. <p><b>See also:</b> <a href="#case_expr-2">case_expr/2</a>, <a href="#clause-3">clause/3</a>, <a href="#if_expr_clauses-1">if_expr_clauses/1</a>.</p>
    1280. 

  1280. 

  1281. <h3><a name="if_expr_clauses-1">if_expr_clauses/1</a></h3>
    1282. 

  1282. <tt>if_expr_clauses(Node) -&gt; term()
    1283. 

  1283. </tt><p>Returns the list of clause subtrees of an <code>if_expr</code>
    1284. 

  1284.   node.
    1285. 

  1285.  </p>
    1286. 

  1286. <p><b>See also:</b> <a href="#if_expr-1">if_expr/1</a>.</p>
    1287. 

  1287. 

  1288. <h3><a name="implicit_fun-1">implicit_fun/1</a></h3>
    1289. 

  1289. <p><tt>implicit_fun(Name::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1290. 

  1290. <p>Creates an abstract "implicit fun" expression. The result
    1291. 

  1291.   represents "<code>fun <em>Name</em></code>".
    1292. 

  1292.  </p>
    1293. 

  1293. <p><b>See also:</b> <a href="#implicit_fun-2">implicit_fun/2</a>, <a href="#implicit_fun_name-1">implicit_fun_name/1</a>.</p>
    1294. 

  1294. 

  1295. <h3><a name="implicit_fun-2">implicit_fun/2</a></h3>
    1296. 

  1296. <p><tt>implicit_fun(Name::<a href="#type-syntaxTree">syntaxTree()</a>, Arity::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1297. 

  1297. <p>Creates an abstract "implicit fun" expression. (Utility
    1298. 

  1298.   function.) If <code>Arity</code> is <code>none</code>, this is
    1299. 

  1299.   equivalent to <code>implicit_fun(Name)</code>, otherwise it is
    1300. 

  1300.   equivalent to <code>implicit_fun(arity_qualifier(Name,
    1301. 

  1301.   Arity))</code>.
    1302. 

  1302.  </p>
    1303. 

  1303. <p><b>See also:</b> <a href="#implicit_fun-1">implicit_fun/1</a>.</p>
    1304. 

  1304. 

  1305. <h3><a name="implicit_fun_name-1">implicit_fun_name/1</a></h3>
    1306. 

  1306. <p><tt>implicit_fun_name(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1307. 

  1307. <p>Returns the name subtree of an <code>implicit_fun</code> node.
    1308. 

  1308.  
    1309. 

  1309.   <p>Note: if <code>Node</code> represents "<code>fun
    1310. 

  1310.   <em>N</em>/<em>A</em></code>", then the result is the subtree
    1311. 

  1311.   representing "<code><em>N</em>/<em>A</em></code>".</p>
    1312. 

  1312.  </p>
    1313. 

  1313. <p><b>See also:</b> <a href="#implicit_fun-1">implicit_fun/1</a>.</p>
    1314. 

  1314. 

  1315. <h3><a name="infix_expr-3">infix_expr/3</a></h3>
    1316. 

  1316. <p><tt>infix_expr(Left::<a href="#type-syntaxTree">syntaxTree()</a>, Operator::<a href="#type-syntaxTree">syntaxTree()</a>, Right::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1317. 

  1317. <p>Creates an abstract infix operator expression. The result
    1318. 

  1318.   represents "<code><em>Left</em> <em>Operator</em>
    1319. 

  1319.   <em>Right</em></code>".
    1320. 

  1320.  </p>
    1321. 

  1321. <p><b>See also:</b> <a href="#infix_expr_left-1">infix_expr_left/1</a>, <a href="#infix_expr_operator-1">infix_expr_operator/1</a>, <a href="#infix_expr_right-1">infix_expr_right/1</a>, <a href="#prefix_expr-2">prefix_expr/2</a>.</p>
    1322. 

  1322. 

  1323. <h3><a name="infix_expr_left-1">infix_expr_left/1</a></h3>
    1324. 

  1324. <p><tt>infix_expr_left(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1325. 

  1325. <p>Returns the left argument subtree of an
    1326. 

  1326.   <code>infix_expr</code> node.
    1327. 

  1327.  </p>
    1328. 

  1328. <p><b>See also:</b> <a href="#infix_expr-3">infix_expr/3</a>.</p>
    1329. 

  1329. 

  1330. <h3><a name="infix_expr_operator-1">infix_expr_operator/1</a></h3>
    1331. 

  1331. <p><tt>infix_expr_operator(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1332. 

  1332. <p>Returns the operator subtree of an <code>infix_expr</code>
    1333. 

  1333.   node.
    1334. 

  1334.  </p>
    1335. 

  1335. <p><b>See also:</b> <a href="#infix_expr-3">infix_expr/3</a>.</p>
    1336. 

  1336. 

  1337. <h3><a name="infix_expr_right-1">infix_expr_right/1</a></h3>
    1338. 

  1338. <p><tt>infix_expr_right(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1339. 

  1339. <p>Returns the right argument subtree of an
    1340. 

  1340.   <code>infix_expr</code> node.
    1341. 

  1341.  </p>
    1342. 

  1342. <p><b>See also:</b> <a href="#infix_expr-3">infix_expr/3</a>.</p>
    1343. 

  1343. 

  1344. <h3><a name="integer-1">integer/1</a></h3>
    1345. 

  1345. <p><tt>integer(Value::integer()) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1346. 

  1346. <p>Creates an abstract integer literal. The lexical representation
    1347. 

  1347.   is the canonical decimal numeral of <code>Value</code>.
    1348. 

  1348.  </p>
    1349. 

  1349. <p><b>See also:</b> <a href="#integer_literal-1">integer_literal/1</a>, <a href="#integer_value-1">integer_value/1</a>, <a href="#is_integer-2">is_integer/2</a>.</p>
    1350. 

  1350. 

  1351. <h3><a name="integer_literal-1">integer_literal/1</a></h3>
    1352. 

  1352. <p><tt>integer_literal(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; string()</tt></p>
    1353. 

  1353. <p>Returns the numeral string represented by an
    1354. 

  1354.   <code>integer</code> node.
    1355. 

  1355.  </p>
    1356. 

  1356. <p><b>See also:</b> <a href="#integer-1">integer/1</a>.</p>
    1357. 

  1357. 

  1358. <h3><a name="integer_value-1">integer_value/1</a></h3>
    1359. 

  1359. <p><tt>integer_value(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; integer()</tt></p>
    1360. 

  1360. <p>Returns the value represented by an <code>integer</code> node.
    1361. 

  1361.  </p>
    1362. 

  1362. <p><b>See also:</b> <a href="#integer-1">integer/1</a>.</p>
    1363. 

  1363. 

  1364. <h3><a name="is_atom-2">is_atom/2</a></h3>
    1365. 

  1365. <p><tt>is_atom(Node::<a href="#type-syntaxTree">syntaxTree()</a>, Value::atom()) -&gt; bool()</tt></p>
    1366. 

  1366. <p>Returns <code>true</code> if <code>Node</code> has type
    1367. 

  1367.   <code>atom</code> and represents <code>Value</code>, otherwise
    1368. 

  1368.   <code>false</code>.
    1369. 

  1369.  </p>
    1370. 

  1370. <p><b>See also:</b> <a href="#atom-1">atom/1</a>.</p>
    1371. 

  1371. 

  1372. <h3><a name="is_char-2">is_char/2</a></h3>
    1373. 

  1373. <p><tt>is_char(Node::<a href="#type-syntaxTree">syntaxTree()</a>, Value::char()) -&gt; bool()</tt></p>
    1374. 

  1374. <p>Returns <code>true</code> if <code>Node</code> has type
    1375. 

  1375.   <code>char</code> and represents <code>Value</code>, otherwise
    1376. 

  1376.   <code>false</code>.
    1377. 

  1377.  </p>
    1378. 

  1378. <p><b>See also:</b> <a href="#char-1">char/1</a>.</p>
    1379. 

  1379. 

  1380. <h3><a name="is_form-1">is_form/1</a></h3>
    1381. 

  1381. <p><tt>is_form(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; bool()</tt></p>
    1382. 

  1382. <p>Returns <code>true</code> if <code>Node</code> is a syntax tree
    1383. 

  1383.   representing a so-called "source code form", otherwise
    1384. 

  1384.   <code>false</code>. Forms are the Erlang source code units which,
    1385. 

  1385.   placed in sequence, constitute an Erlang program. Current form types
    1386. 

  1386.   are:
    1387. 

  1387.   <p><center><table border="1">
    1388. 

  1388.    <tr>
    1389. 

  1389.     <td><code>attribute</code></td>
    1390. 

  1390.     <td><code>comment</code></td>
    1391. 

  1391.     <td><code>error_marker</code></td>
    1392. 

  1392.     <td><code>eof_marker</code></td>
    1393. 

  1393.    </tr><tr>
    1394. 

  1394.     <td><code>form_list</code></td>
    1395. 

  1395.     <td><code>function</code></td>
    1396. 

  1396.     <td><code>rule</code></td>
    1397. 

  1397.     <td><code>warning_marker</code></td>
    1398. 

  1398.    </tr>
    1399. 

  1399.   </table></center></p></p>
    1400. 

  1400. <p><b>See also:</b> <a href="#attribute-2">attribute/2</a>, <a href="#comment-2">comment/2</a>, <a href="#eof_marker-1">eof_marker/1</a>, <a href="#error_marker-1">error_marker/1</a>, <a href="#form_list-1">form_list/1</a>, <a href="#function-2">function/2</a>, <a href="#rule-2">rule/2</a>, <a href="#type-1">type/1</a>, <a href="#warning_marker-1">warning_marker/1</a>.</p>
    1401. 

  1401. 

  1402. <h3><a name="is_integer-2">is_integer/2</a></h3>
    1403. 

  1403. <p><tt>is_integer(Node::<a href="#type-syntaxTree">syntaxTree()</a>, Value::integer()) -&gt; bool()</tt></p>
    1404. 

  1404. <p>Returns <code>true</code> if <code>Node</code> has type
    1405. 

  1405.   <code>integer</code> and represents <code>Value</code>, otherwise
    1406. 

  1406.   <code>false</code>.
    1407. 

  1407.  </p>
    1408. 

  1408. <p><b>See also:</b> <a href="#integer-1">integer/1</a>.</p>
    1409. 

  1409. 

  1410. <h3><a name="is_leaf-1">is_leaf/1</a></h3>
    1411. 

  1411. <p><tt>is_leaf(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; bool()</tt></p>
    1412. 

  1412. <p>Returns <code>true</code> if <code>Node</code> is a leaf node,
    1413. 

  1413.   otherwise <code>false</code>. The currently recognised leaf node
    1414. 

  1414.   types are:
    1415. 

  1415.   <p><center><table border="1">
    1416. 

  1416.    <tr>
    1417. 

  1417.     <td><code>atom</code></td>
    1418. 

  1418.     <td><code>char</code></td>
    1419. 

  1419.     <td><code>comment</code></td>
    1420. 

  1420.     <td><code>eof_marker</code></td>
    1421. 

  1421.     <td><code>error_marker</code></td>
    1422. 

  1422.    </tr><tr>
    1423. 

  1423.     <td><code>float</code></td>
    1424. 

  1424.     <td><code>integer</code></td>
    1425. 

  1425.     <td><code>nil</code></td>
    1426. 

  1426.     <td><code>operator</code></td>
    1427. 

  1427.     <td><code>string</code></td>
    1428. 

  1428.    </tr><tr>
    1429. 

  1429.     <td><code>text</code></td>
    1430. 

  1430.     <td><code>underscore</code></td>
    1431. 

  1431.     <td><code>variable</code></td>
    1432. 

  1432.     <td><code>warning_marker</code></td>
    1433. 

  1433.    </tr>
    1434. 

  1434.   </table></center></p>
    1435. 

  1435.   <p>A node of type <code>tuple</code> is a leaf node if and only if
    1436. 

  1436.   its arity is zero.</p>
    1437. 

  1437.  
    1438. 

  1438.   <p>Note: not all literals are leaf nodes, and vice versa. E.g.,
    1439. 

  1439.   tuples with nonzero arity and nonempty lists may be literals, but are
    1440. 

  1440.   not leaf nodes. Variables, on the other hand, are leaf nodes but not
    1441. 

  1441.   literals.</p>
    1442. 

  1442.  </p>
    1443. 

  1443. <p><b>See also:</b> <a href="#is_literal-1">is_literal/1</a>, <a href="#type-1">type/1</a>.</p>
    1444. 

  1444. 

  1445. <h3><a name="is_list_skeleton-1">is_list_skeleton/1</a></h3>
    1446. 

  1446. <p><tt>is_list_skeleton(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; bool()</tt></p>
    1447. 

  1447. <p>Returns <code>true</code> if <code>Node</code> has type
    1448. 

  1448.   <code>list</code> or <code>nil</code>, otherwise <code>false</code>.
    1449. 

  1449.  </p>
    1450. 

  1450. <p><b>See also:</b> <a href="#list-2">list/2</a>, <a href="#nil-0">nil/0</a>.</p>
    1451. 

  1451. 

  1452. <h3><a name="is_literal-1">is_literal/1</a></h3>
    1453. 

  1453. <p><tt>is_literal(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; bool()</tt></p>
    1454. 

  1454. <p>Returns <code>true</code> if <code>Node</code> represents a
    1455. 

  1455.   literal term, otherwise <code>false</code>. This function returns
    1456. 

  1456.   <code>true</code> if and only if the value of
    1457. 

  1457.   <code>concrete(Node)</code> is defined.
    1458. 

  1458.  </p>
    1459. 

  1459. <p><b>See also:</b> <a href="#abstract-1">abstract/1</a>, <a href="#concrete-1">concrete/1</a>.</p>
    1460. 

  1460. 

  1461. <h3><a name="is_proper_list-1">is_proper_list/1</a></h3>
    1462. 

  1462. <p><tt>is_proper_list(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; bool()</tt></p>
    1463. 

  1463. <p>Returns <code>true</code> if <code>Node</code> represents a
    1464. 

  1464.   proper list, and <code>false</code> otherwise. A proper list is a
    1465. 

  1465.   list skeleton either on the form "<code>[]</code>" or
    1466. 

  1466.   "<code>[<em>E1</em>, ..., <em>En</em>]</code>", or "<code>[... |
    1467. 

  1467.   <em>Tail</em>]</code>" where recursively <code>Tail</code> also
    1468. 

  1468.   represents a proper list.
    1469. 

  1469.  
    1470. 

  1470.   <p>Note: Since <code>Node</code> is a syntax tree, the actual
    1471. 

  1471.   run-time values corresponding to its subtrees may often be partially
    1472. 

  1472.   or completely unknown. Thus, if <code>Node</code> represents e.g.
    1473. 

  1473.   "<code>[... | Ns]</code>" (where <code>Ns</code> is a variable), then
    1474. 

  1474.   the function will return <code>false</code>, because it is not known
    1475. 

  1475.   whether <code>Ns</code> will be bound to a list at run-time. If
    1476. 

  1476.   <code>Node</code> instead represents e.g. "<code>[1, 2, 3]</code>" or
    1477. 

  1477.   "<code>[A | []]</code>", then the function will return
    1478. 

  1478.   <code>true</code>.</p>
    1479. 

  1479.  </p>
    1480. 

  1480. <p><b>See also:</b> <a href="#list-2">list/2</a>.</p>
    1481. 

  1481. 

  1482. <h3><a name="is_string-2">is_string/2</a></h3>
    1483. 

  1483. <p><tt>is_string(Node::<a href="#type-syntaxTree">syntaxTree()</a>, Value::string()) -&gt; bool()</tt></p>
    1484. 

  1484. <p>Returns <code>true</code> if <code>Node</code> has type
    1485. 

  1485.   <code>string</code> and represents <code>Value</code>, otherwise
    1486. 

  1486.   <code>false</code>.
    1487. 

  1487.  </p>
    1488. 

  1488. <p><b>See also:</b> <a href="#string-1">string/1</a>.</p>
    1489. 

  1489. 

  1490. <h3><a name="is_tree-1">is_tree/1</a></h3>
    1491. 

  1491. <p><tt>is_tree(Tree::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; bool()</tt></p>
    1492. 

  1492. <p><em>For special purposes only</em>. Returns <code>true</code> if
    1493. 

  1493.   <code>Tree</code> is an abstract syntax tree and <code>false</code>
    1494. 

  1494.   otherwise.
    1495. 

  1495.  
    1496. 

  1496.   <p><em>Note</em>: this function yields <code>false</code> for all
    1497. 

  1497.   "old-style" <code>erl_parse</code>-compatible "parse trees".</p>
    1498. 

  1498.  </p>
    1499. 

  1499. <p><b>See also:</b> <a href="#tree-2">tree/2</a>.</p>
    1500. 

  1500. 

  1501. <h3><a name="join_comments-2">join_comments/2</a></h3>
    1502. 

  1502. <p><tt>join_comments(Source::<a href="#type-syntaxTree">syntaxTree()</a>, Target::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1503. 

  1503. <p>Appends the comments of <code>Source</code> to the current
    1504. 

  1504.   comments of <code>Target</code>.
    1505. 

  1505.  
    1506. 

  1506.   <p>Note: This is equivalent to
    1507. 

  1507.   <code>add_postcomments(get_postcomments(Source),
    1508. 

  1508.   add_precomments(get_precomments(Source), Target))</code>, but
    1509. 

  1509.   potentially more efficient.</p>
    1510. 

  1510.  </p>
    1511. 

  1511. <p><b>See also:</b> <a href="#add_postcomments-2">add_postcomments/2</a>, <a href="#add_precomments-2">add_precomments/2</a>, <a href="#comment-2">comment/2</a>, <a href="#get_postcomments-1">get_postcomments/1</a>, <a href="#get_precomments-1">get_precomments/1</a>.</p>
    1512. 

  1512. 

  1513. <h3><a name="list-1">list/1</a></h3>
    1514. 

  1514. <p><tt>list(List) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1515. 

  1515. <p>Equivalent to <a href="#list-2"><tt>list(List, none)</tt></a>.</p>
    1516. 

  1516. 

  1517. 

  1518. <h3><a name="list-2">list/2</a></h3>
    1519. 

  1519. <p><tt>list(Elements::List, Tail) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    1520. 

  1520. <ul><li><tt>List = [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></li><li><tt>Tail = none | <a href="#type-syntaxTree">syntaxTree()</a></tt></li></ul></p>
    1521. 

  1521. <p>Constructs an abstract list skeleton. The result has type
    1522. 

  1522.   <code>list</code> or <code>nil</code>. If <code>List</code> is a
    1523. 

  1523.   nonempty list <code>[E1, ..., En]</code>, the result has type
    1524. 

  1524.   <code>list</code> and represents either "<code>[<em>E1</em>, ...,
    1525. 

  1525.   <em>En</em>]</code>", if <code>Tail</code> is <code>none</code>, or
    1526. 

  1526.   otherwise "<code>[<em>E1</em>, ..., <em>En</em> |
    1527. 

  1527.   <em>Tail</em>]</code>". If <code>List</code> is the empty list,
    1528. 

  1528.   <code>Tail</code> <em>must</em> be <code>none</code>, and in that
    1529. 

  1529.   case the result has type <code>nil</code> and represents
    1530. 

  1530.   "<code>[]</code>" (cf. <code>nil/0</code>).
    1531. 

  1531.  
    1532. 

  1532.   <p>The difference between lists as semantic objects (built up of
    1533. 

  1533.   individual "cons" and "nil" terms) and the various syntactic forms
    1534. 

  1534.   for denoting lists may be bewildering at first. This module provides
    1535. 

  1535.   functions both for exact control of the syntactic representation as
    1536. 

  1536.   well as for the simple composition and deconstruction in terms of
    1537. 

  1537.   cons and head/tail operations.</p>
    1538. 

  1538.  
    1539. 

  1539.   <p>Note: in <code>list(Elements, none)</code>, the "nil" list
    1540. 

  1540.   terminator is implicit and has no associated information (cf.
    1541. 

  1541.   <code>get_attrs/1</code>), while in the seemingly equivalent
    1542. 

  1542.   <code>list(Elements, Tail)</code> when <code>Tail</code> has type
    1543. 

  1543.   <code>nil</code>, the list terminator subtree <code>Tail</code> may
    1544. 

  1544.   have attached attributes such as position, comments, and annotations,
    1545. 

  1545.   which will be preserved in the result.</p>
    1546. 

  1546.  </p>
    1547. 

  1547. <p><b>See also:</b> <a href="#compact_list-1">compact_list/1</a>, <a href="#cons-2">cons/2</a>, <a href="#get_attrs-1">get_attrs/1</a>, <a href="#is_list_skeleton-1">is_list_skeleton/1</a>, <a href="#is_proper_list-1">is_proper_list/1</a>, <a href="#list-1">list/1</a>, <a href="#list_elements-1">list_elements/1</a>, <a href="#list_head-1">list_head/1</a>, <a href="#list_length-1">list_length/1</a>, <a href="#list_prefix-1">list_prefix/1</a>, <a href="#list_suffix-1">list_suffix/1</a>, <a href="#list_tail-1">list_tail/1</a>, <a href="#nil-0">nil/0</a>, <a href="#normalize_list-1">normalize_list/1</a>.</p>
    1548. 

  1548. 

  1549. <h3><a name="list_comp-2">list_comp/2</a></h3>
    1550. 

  1550. <p><tt>list_comp(Template::<a href="#type-syntaxTree">syntaxTree()</a>, Body::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1551. 

  1551. <p>Creates an abstract list comprehension. If <code>Body</code> is
    1552. 

  1552.   <code>[E1, ..., En]</code>, the result represents
    1553. 

  1553.   "<code>[<em>Template</em> || <em>E1</em>, ..., <em>En</em>]</code>".
    1554. 

  1554.  </p>
    1555. 

  1555. <p><b>See also:</b> <a href="#generator-2">generator/2</a>, <a href="#list_comp_body-1">list_comp_body/1</a>, <a href="#list_comp_template-1">list_comp_template/1</a>.</p>
    1556. 

  1556. 

  1557. <h3><a name="list_comp_body-1">list_comp_body/1</a></h3>
    1558. 

  1558. <p><tt>list_comp_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    1559. 

  1559. <p>Returns the list of body subtrees of a <code>list_comp</code>
    1560. 

  1560.   node.
    1561. 

  1561.  </p>
    1562. 

  1562. <p><b>See also:</b> <a href="#list_comp-2">list_comp/2</a>.</p>
    1563. 

  1563. 

  1564. <h3><a name="list_comp_template-1">list_comp_template/1</a></h3>
    1565. 

  1565. <p><tt>list_comp_template(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1566. 

  1566. <p>Returns the template subtree of a <code>list_comp</code> node.
    1567. 

  1567.  </p>
    1568. 

  1568. <p><b>See also:</b> <a href="#list_comp-2">list_comp/2</a>.</p>
    1569. 

  1569. 

  1570. <h3><a name="list_elements-1">list_elements/1</a></h3>
    1571. 

  1571. <p><tt>list_elements(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    1572. 

  1572. <p>Returns the list of element subtrees of a list skeleton.
    1573. 

  1573.   <code>Node</code> must represent a proper list. E.g., if
    1574. 

  1574.   <code>Node</code> represents "<code>[<em>X1</em>, <em>X2</em> |
    1575. 

  1575.   [<em>X3</em>, <em>X4</em> | []]</code>", then
    1576. 

  1576.   <code>list_elements(Node)</code> yields the list <code>[X1, X2, X3,
    1577. 

  1577.   X4]</code>.
    1578. 

  1578.  </p>
    1579. 

  1579. <p><b>See also:</b> <a href="#is_proper_list-1">is_proper_list/1</a>, <a href="#list-2">list/2</a>.</p>
    1580. 

  1580. 

  1581. <h3><a name="list_head-1">list_head/1</a></h3>
    1582. 

  1582. <p><tt>list_head(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1583. 

  1583. <p>Returns the head element subtree of a <code>list</code> node. If
    1584. 

  1584.   <code>Node</code> represents "<code>[<em>Head</em> ...]</code>", the
    1585. 

  1585.   result will represent "<code><em>Head</em></code>".
    1586. 

  1586.  </p>
    1587. 

  1587. <p><b>See also:</b> <a href="#cons-2">cons/2</a>, <a href="#list-2">list/2</a>, <a href="#list_tail-1">list_tail/1</a>.</p>
    1588. 

  1588. 

  1589. <h3><a name="list_length-1">list_length/1</a></h3>
    1590. 

  1590. <tt>list_length(Node) -&gt; term()
    1591. 

  1591. </tt><p>Returns the number of element subtrees of a list skeleton.
    1592. 

  1592.   <code>Node</code> must represent a proper list. E.g., if
    1593. 

  1593.   <code>Node</code> represents "<code>[X1 | [X2, X3 | [X4, X5,
    1594. 

  1594.   X6]]]</code>", then <code>list_length(Node)</code> returns the
    1595. 

  1595.   integer 6.
    1596. 

  1596.  
    1597. 

  1597.   <p>Note: this is equivalent to
    1598. 

  1598.   <code>length(list_elements(Node))</code>, but potentially more
    1599. 

  1599.   efficient.</p>
    1600. 

  1600.  </p>
    1601. 

  1601. <p><b>See also:</b> <a href="#is_proper_list-1">is_proper_list/1</a>, <a href="#list-2">list/2</a>, <a href="#list_elements-1">list_elements/1</a>.</p>
    1602. 

  1602. 

  1603. <h3><a name="list_prefix-1">list_prefix/1</a></h3>
    1604. 

  1604. <p><tt>list_prefix(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    1605. 

  1605. <p>Returns the prefix element subtrees of a <code>list</code> node.
    1606. 

  1606.   If <code>Node</code> represents "<code>[<em>E1</em>, ...,
    1607. 

  1607.   <em>En</em>]</code>" or "<code>[<em>E1</em>, ..., <em>En</em> |
    1608. 

  1608.   <em>Tail</em>]</code>", the returned value is <code>[E1, ...,
    1609. 

  1609.   En]</code>.
    1610. 

  1610.  </p>
    1611. 

  1611. <p><b>See also:</b> <a href="#list-2">list/2</a>.</p>
    1612. 

  1612. 

  1613. <h3><a name="list_suffix-1">list_suffix/1</a></h3>
    1614. 

  1614. <p><tt>list_suffix(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; none | <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1615. 

  1615. <p>Returns the suffix subtree of a <code>list</code> node, if one
    1616. 

  1616.   exists. If <code>Node</code> represents "<code>[<em>E1</em>, ...,
    1617. 

  1617.   <em>En</em> | <em>Tail</em>]</code>", the returned value is
    1618. 

  1618.   <code>Tail</code>, otherwise, i.e., if <code>Node</code> represents
    1619. 

  1619.   "<code>[<em>E1</em>, ..., <em>En</em>]</code>", <code>none</code> is
    1620. 

  1620.   returned.
    1621. 

  1621.  
    1622. 

  1622.   <p>Note that even if this function returns some <code>Tail</code>
    1623. 

  1623.   that is not <code>none</code>, the type of <code>Tail</code> can be
    1624. 

  1624.   <code>nil</code>, if the tail has been given explicitly, and the list
    1625. 

  1625.   skeleton has not been compacted (cf.
    1626. 

  1626.   <code>compact_list/1</code>).</p>
    1627. 

  1627.  </p>
    1628. 

  1628. <p><b>See also:</b> <a href="#compact_list-1">compact_list/1</a>, <a href="#list-2">list/2</a>, <a href="#nil-0">nil/0</a>.</p>
    1629. 

  1629. 

  1630. <h3><a name="list_tail-1">list_tail/1</a></h3>
    1631. 

  1631. <tt>list_tail(Node) -&gt; term()
    1632. 

  1632. </tt><p>Returns the tail of a <code>list</code> node. If
    1633. 

  1633.   <code>Node</code> represents a single-element list
    1634. 

  1634.   "<code>[<em>E</em>]</code>", then the result has type
    1635. 

  1635.   <code>nil</code>, representing "<code>[]</code>". If
    1636. 

  1636.   <code>Node</code> represents "<code>[<em>E1</em>, <em>E2</em>
    1637. 

  1637.   ...]</code>", the result will represent "<code>[<em>E2</em>
    1638. 

  1638.   ...]</code>", and if <code>Node</code> represents
    1639. 

  1639.   "<code>[<em>Head</em> | <em>Tail</em>]</code>", the result will
    1640. 

  1640.   represent "<code><em>Tail</em></code>".
    1641. 

  1641.  </p>
    1642. 

  1642. <p><b>See also:</b> <a href="#cons-2">cons/2</a>, <a href="#list-2">list/2</a>, <a href="#list_head-1">list_head/1</a>.</p>
    1643. 

  1643. 

  1644. <h3><a name="macro-1">macro/1</a></h3>
    1645. 

  1645. <p><tt>macro(Name) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1646. 

  1646. <p>Equivalent to <a href="#macro-2"><tt>macro(Name, none)</tt></a>.</p>
    1647. 

  1647. 

  1648. 

  1649. <h3><a name="macro-2">macro/2</a></h3>
    1650. 

  1650. <p><tt>macro(Name::<a href="#type-syntaxTree">syntaxTree()</a>, Arguments) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    1651. 

  1651. <ul><li><tt>Arguments = none | [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></li></ul></p>
    1652. 

  1652. <p>Creates an abstract macro application. If <code>Arguments</code>
    1653. 

  1653.   is <code>none</code>, the result represents
    1654. 

  1654.   "<code>?<em>Name</em></code>", otherwise, if <code>Arguments</code>
    1655. 

  1655.   is <code>[A1, ..., An]</code>, the result represents
    1656. 

  1656.   "<code>?<em>Name</em>(<em>A1</em>, ..., <em>An</em>)</code>".
    1657. 

  1657.  
    1658. 

  1658.   <p>Notes: if <code>Arguments</code> is the empty list, the result
    1659. 

  1659.   will thus represent "<code>?<em>Name</em>()</code>", including a pair
    1660. 

  1660.   of matching parentheses.</p>
    1661. 

  1661.  
    1662. 

  1662.   <p>The only syntactical limitation imposed by the preprocessor on the
    1663. 

  1663.   arguments to a macro application (viewed as sequences of tokens) is
    1664. 

  1664.   that they must be balanced with respect to parentheses, brackets,
    1665. 

  1665.   <code>begin ... end</code>, <code>case ... end</code>, etc. The
    1666. 

  1666.   <code>text</code> node type can be used to represent arguments which
    1667. 

  1667.   are not regular Erlang constructs.</p>
    1668. 

  1668.  </p>
    1669. 

  1669. <p><b>See also:</b> <a href="#macro-1">macro/1</a>, <a href="#macro_arguments-1">macro_arguments/1</a>, <a href="#macro_name-1">macro_name/1</a>, <a href="#text-1">text/1</a>.</p>
    1670. 

  1670. 

  1671. <h3><a name="macro_arguments-1">macro_arguments/1</a></h3>
    1672. 

  1672. <p><tt>macro_arguments(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; none | [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    1673. 

  1673. <p>Returns the list of argument subtrees of a <code>macro</code>
    1674. 

  1674.   node, if any. If <code>Node</code> represents
    1675. 

  1675.   "<code>?<em>Name</em></code>", <code>none</code> is returned.
    1676. 

  1676.   Otherwise, if <code>Node</code> represents
    1677. 

  1677.   "<code>?<em>Name</em>(<em>A1</em>, ..., <em>An</em>)</code>",
    1678. 

  1678.   <code>[A1, ..., An]</code> is returned.
    1679. 

  1679.  </p>
    1680. 

  1680. <p><b>See also:</b> <a href="#macro-2">macro/2</a>.</p>
    1681. 

  1681. 

  1682. <h3><a name="macro_name-1">macro_name/1</a></h3>
    1683. 

  1683. <p><tt>macro_name(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1684. 

  1684. <p>Returns the name subtree of a <code>macro</code> node.
    1685. 

  1685.  </p>
    1686. 

  1686. <p><b>See also:</b> <a href="#macro-2">macro/2</a>.</p>
    1687. 

  1687. 

  1688. <h3><a name="make_tree-2">make_tree/2</a></h3>
    1689. 

  1689. <p><tt>make_tree(Type::atom(), Groups::[[<a href="#type-syntaxTree">syntaxTree()</a>]]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1690. 

  1690. <p>Creates a syntax tree with the given type and subtrees.
    1691. 

  1691.   <code>Type</code> must be a node type name (cf. <code>type/1</code>)
    1692. 

  1692.   that does not denote a leaf node type (cf. <code>is_leaf/1</code>).
    1693. 

  1693.   <code>Groups</code> must be a <em>nonempty</em> list of groups of
    1694. 

  1694.   syntax trees, representing the subtrees of a node of the given type,
    1695. 

  1695.   in left-to-right order as they would occur in the printed program
    1696. 

  1696.   text, grouped by category as done by <code>subtrees/1</code>.
    1697. 

  1697.  
    1698. 

  1698.   <p>The result of <code>copy_attrs(Node, make_tree(type(Node),
    1699. 

  1699.   subtrees(Node)))</code> (cf. <code>update_tree/2</code>) represents
    1700. 

  1700.   the same source code text as the original <code>Node</code>, assuming
    1701. 

  1701.   that <code>subtrees(Node)</code> yields a nonempty list. However, it
    1702. 

  1702.   does not necessarily have the same data representation as
    1703. 

  1703.   <code>Node</code>.</p>
    1704. 

  1704.  </p>
    1705. 

  1705. <p><b>See also:</b> <a href="#copy_attrs-2">copy_attrs/2</a>, <a href="#is_leaf-1">is_leaf/1</a>, <a href="#subtrees-1">subtrees/1</a>, <a href="#type-1">type/1</a>, <a href="#update_tree-1">update_tree/1</a>.</p>
    1706. 

  1706. 

  1707. <h3><a name="match_expr-2">match_expr/2</a></h3>
    1708. 

  1708. <p><tt>match_expr(Pattern::<a href="#type-syntaxTree">syntaxTree()</a>, Body::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1709. 

  1709. <p>Creates an abstract match-expression. The result represents
    1710. 

  1710.   "<code><em>Pattern</em> = <em>Body</em></code>".
    1711. 

  1711.  </p>
    1712. 

  1712. <p><b>See also:</b> <a href="#match_expr_body-1">match_expr_body/1</a>, <a href="#match_expr_pattern-1">match_expr_pattern/1</a>.</p>
    1713. 

  1713. 

  1714. <h3><a name="match_expr_body-1">match_expr_body/1</a></h3>
    1715. 

  1715. <p><tt>match_expr_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1716. 

  1716. <p>Returns the body subtree of a <code>match_expr</code> node.
    1717. 

  1717.  </p>
    1718. 

  1718. <p><b>See also:</b> <a href="#match_expr-2">match_expr/2</a>.</p>
    1719. 

  1719. 

  1720. <h3><a name="match_expr_pattern-1">match_expr_pattern/1</a></h3>
    1721. 

  1721. <p><tt>match_expr_pattern(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1722. 

  1722. <p>Returns the pattern subtree of a <code>match_expr</code> node.
    1723. 

  1723.  </p>
    1724. 

  1724. <p><b>See also:</b> <a href="#match_expr-2">match_expr/2</a>.</p>
    1725. 

  1725. 

  1726. <h3><a name="meta-1">meta/1</a></h3>
    1727. 

  1727. <p><tt>meta(Tree::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1728. 

  1728. <p>Creates a meta-representation of a syntax tree. The result
    1729. 

  1729.   represents an Erlang expression "<code><em>MetaTree</em></code>"
    1730. 

  1730.   which, if evaluated, will yield a new syntax tree representing the
    1731. 

  1731.   same source code text as <code>Tree</code> (although the actual data
    1732. 

  1732.   representation may be different). The expression represented by
    1733. 

  1733.   <code>MetaTree</code> is <em>implementation independent</em> with
    1734. 

  1734.   regard to the data structures used by the abstract syntax tree
    1735. 

  1735.   implementation. Comments attached to nodes of <code>Tree</code> will
    1736. 

  1736.   be preserved, but other attributes are lost.
    1737. 

  1737.  
    1738. 

  1738.   <p>Any node in <code>Tree</code> whose node type is
    1739. 

  1739.   <code>variable</code> (cf. <code>type/1</code>), and whose list of
    1740. 

  1740.   annotations (cf. <code>get_ann/1</code>) contains the atom
    1741. 

  1741.   <code>meta_var</code>, will remain unchanged in the resulting tree,
    1742. 

  1742.   except that exactly one occurrence of <code>meta_var</code> is
    1743. 

  1743.   removed from its annotation list.</p>
    1744. 

  1744.  
    1745. 

  1745.   <p>The main use of the function <code>meta/1</code> is to transform a
    1746. 

  1746.   data structure <code>Tree</code>, which represents a piece of program
    1747. 

  1747.   code, into a form that is <em>representation independent when
    1748. 

  1748.   printed</em>. E.g., suppose <code>Tree</code> represents a variable
    1749. 

  1749.   named "V". Then (assuming a function <code>print/1</code> for
    1750. 

  1750.   printing syntax trees), evaluating <code>print(abstract(Tree))</code>
    1751. 

  1751.   - simply using <code>abstract/1</code> to map the actual data
    1752. 

  1752.   structure onto a syntax tree representation - would output a string
    1753. 

  1753.   that might look something like "<code>{tree, variable, ..., "V",
    1754. 

  1754.   ...}</code>", which is obviously dependent on the implementation of
    1755. 

  1755.   the abstract syntax trees. This could e.g. be useful for caching a
    1756. 

  1756.   syntax tree in a file. However, in some situations like in a program
    1757. 

  1757.   generator generator (with two "generator"), it may be unacceptable.
    1758. 

  1758.   Using <code>print(meta(Tree))</code> instead would output a
    1759. 

  1759.   <em>representation independent</em> syntax tree generating
    1760. 

  1760.   expression; in the above case, something like
    1761. 

  1761.   "<code>erl_syntax:variable("V")</code>".</p>
    1762. 

  1762.  </p>
    1763. 

  1763. <p><b>See also:</b> <a href="#abstract-1">abstract/1</a>, <a href="#get_ann-1">get_ann/1</a>, <a href="#type-1">type/1</a>.</p>
    1764. 

  1764. 

  1765. <h3><a name="module_qualifier-2">module_qualifier/2</a></h3>
    1766. 

  1766. <p><tt>module_qualifier(Module::<a href="#type-syntaxTree">syntaxTree()</a>, Body::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1767. 

  1767. <p>Creates an abstract module qualifier. The result represents
    1768. 

  1768.   "<code><em>Module</em>:<em>Body</em></code>".
    1769. 

  1769.  </p>
    1770. 

  1770. <p><b>See also:</b> <a href="#module_qualifier_argument-1">module_qualifier_argument/1</a>, <a href="#module_qualifier_body-1">module_qualifier_body/1</a>.</p>
    1771. 

  1771. 

  1772. <h3><a name="module_qualifier_argument-1">module_qualifier_argument/1</a></h3>
    1773. 

  1773. <p><tt>module_qualifier_argument(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1774. 

  1774. <p>Returns the argument (the module) subtree of a
    1775. 

  1775.   <code>module_qualifier</code> node.
    1776. 

  1776.  </p>
    1777. 

  1777. <p><b>See also:</b> <a href="#module_qualifier-2">module_qualifier/2</a>.</p>
    1778. 

  1778. 

  1779. <h3><a name="module_qualifier_body-1">module_qualifier_body/1</a></h3>
    1780. 

  1780. <p><tt>module_qualifier_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1781. 

  1781. <p>Returns the body subtree of a <code>module_qualifier</code>
    1782. 

  1782.   node.
    1783. 

  1783.  </p>
    1784. 

  1784. <p><b>See also:</b> <a href="#module_qualifier-2">module_qualifier/2</a>.</p>
    1785. 

  1785. 

  1786. <h3><a name="nil-0">nil/0</a></h3>
    1787. 

  1787. <p><tt>nil() -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1788. 

  1788. <p>Creates an abstract empty list. The result represents
    1789. 

  1789.   "<code>[]</code>". The empty list is traditionally called "nil".
    1790. 

  1790.  </p>
    1791. 

  1791. <p><b>See also:</b> <a href="#is_list_skeleton-1">is_list_skeleton/1</a>, <a href="#list-2">list/2</a>.</p>
    1792. 

  1792. 

  1793. <h3><a name="normalize_list-1">normalize_list/1</a></h3>
    1794. 

  1794. <p><tt>normalize_list(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1795. 

  1795. <p>Expands an abstract list skeleton to its most explicit form. If
    1796. 

  1796.   <code>Node</code> represents "<code>[<em>E1</em>, ..., <em>En</em> |
    1797. 

  1797.   <em>Tail</em>]</code>", the result represents "<code>[<em>E1</em> |
    1798. 

  1798.   ... [<em>En</em> | <em>Tail1</em>] ... ]</code>", where
    1799. 

  1799.   <code>Tail1</code> is the result of
    1800. 

  1800.   <code>normalize_list(Tail)</code>. If <code>Node</code> represents
    1801. 

  1801.   "<code>[<em>E1</em>, ..., <em>En</em>]</code>", the result simply
    1802. 

  1802.   represents "<code>[<em>E1</em> | ... [<em>En</em> | []] ...
    1803. 

  1803.   ]</code>". If <code>Node</code> does not represent a list skeleton,
    1804. 

  1804.   <code>Node</code> itself is returned.
    1805. 

  1805.  </p>
    1806. 

  1806. <p><b>See also:</b> <a href="#compact_list-1">compact_list/1</a>, <a href="#list-2">list/2</a>.</p>
    1807. 

  1807. 

  1808. <h3><a name="operator-1">operator/1</a></h3>
    1809. 

  1809. <p><tt>operator(Name) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    1810. 

  1810. <ul><li><tt>Name = atom() | string()</tt></li></ul></p>
    1811. 

  1811. <p>Creates an abstract operator. The name of the operator is the
    1812. 

  1812.   character sequence represented by <code>Name</code>. This is
    1813. 

  1813.   analogous to the print name of an atom, but an operator is never
    1814. 

  1814.   written within single-quotes; e.g., the result of
    1815. 

  1815.   <code>operator('++')</code> represents "<code>++</code>" rather
    1816. 

  1816.   than "<code>'++'</code>".
    1817. 

  1817.  </p>
    1818. 

  1818. <p><b>See also:</b> <a href="#atom-1">atom/1</a>, <a href="#operator_literal-1">operator_literal/1</a>, <a href="#operator_name-1">operator_name/1</a>.</p>
    1819. 

  1819. 

  1820. <h3><a name="operator_literal-1">operator_literal/1</a></h3>
    1821. 

  1821. <p><tt>operator_literal(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; string()</tt></p>
    1822. 

  1822. <p>Returns the literal string represented by an
    1823. 

  1823.   <code>operator</code> node. This is simply the operator name as a
    1824. 

  1824.   string.
    1825. 

  1825.  </p>
    1826. 

  1826. <p><b>See also:</b> <a href="#operator-1">operator/1</a>.</p>
    1827. 

  1827. 

  1828. <h3><a name="operator_name-1">operator_name/1</a></h3>
    1829. 

  1829. <p><tt>operator_name(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; atom()</tt></p>
    1830. 

  1830. <p>Returns the name of an <code>operator</code> node. Note that
    1831. 

  1831.   the name is returned as an atom.
    1832. 

  1832.  </p>
    1833. 

  1833. <p><b>See also:</b> <a href="#operator-1">operator/1</a>.</p>
    1834. 

  1834. 

  1835. <h3><a name="parentheses-1">parentheses/1</a></h3>
    1836. 

  1836. <p><tt>parentheses(Body::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1837. 

  1837. <p>Creates an abstract parenthesised expression. The result
    1838. 

  1838.   represents "<code>(<em>Body</em>)</code>", independently of the
    1839. 

  1839.   context.
    1840. 

  1840.  </p>
    1841. 

  1841. <p><b>See also:</b> <a href="#parentheses_body-1">parentheses_body/1</a>.</p>
    1842. 

  1842. 

  1843. <h3><a name="parentheses_body-1">parentheses_body/1</a></h3>
    1844. 

  1844. <p><tt>parentheses_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1845. 

  1845. <p>Returns the body subtree of a <code>parentheses</code> node.
    1846. 

  1846.  </p>
    1847. 

  1847. <p><b>See also:</b> <a href="#parentheses-1">parentheses/1</a>.</p>
    1848. 

  1848. 

  1849. <h3><a name="prefix_expr-2">prefix_expr/2</a></h3>
    1850. 

  1850. <p><tt>prefix_expr(Operator::<a href="#type-syntaxTree">syntaxTree()</a>, Argument::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1851. 

  1851. <p>Creates an abstract prefix operator expression. The result
    1852. 

  1852.   represents "<code><em>Operator</em> <em>Argument</em></code>".
    1853. 

  1853.  </p>
    1854. 

  1854. <p><b>See also:</b> <a href="#infix_expr-3">infix_expr/3</a>, <a href="#prefix_expr_argument-1">prefix_expr_argument/1</a>, <a href="#prefix_expr_operator-1">prefix_expr_operator/1</a>.</p>
    1855. 

  1855. 

  1856. <h3><a name="prefix_expr_argument-1">prefix_expr_argument/1</a></h3>
    1857. 

  1857. <p><tt>prefix_expr_argument(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1858. 

  1858. <p>Returns the argument subtree of a <code>prefix_expr</code>
    1859. 

  1859.   node.
    1860. 

  1860.  </p>
    1861. 

  1861. <p><b>See also:</b> <a href="#prefix_expr-2">prefix_expr/2</a>.</p>
    1862. 

  1862. 

  1863. <h3><a name="prefix_expr_operator-1">prefix_expr_operator/1</a></h3>
    1864. 

  1864. <p><tt>prefix_expr_operator(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1865. 

  1865. <p>Returns the operator subtree of a <code>prefix_expr</code>
    1866. 

  1866.   node.
    1867. 

  1867.  </p>
    1868. 

  1868. <p><b>See also:</b> <a href="#prefix_expr-2">prefix_expr/2</a>.</p>
    1869. 

  1869. 

  1870. <h3><a name="qualified_name-1">qualified_name/1</a></h3>
    1871. 

  1871. <p><tt>qualified_name(Segments::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1872. 

  1872. <p>Creates an abstract qualified name. The result represents
    1873. 

  1873.   "<code><em>S1</em>.<em>S2</em>. ... .<em>Sn</em></code>", if
    1874. 

  1874.   <code>Segments</code> is <code>[S1, S2, ..., Sn]</code>.
    1875. 

  1875.  </p>
    1876. 

  1876. <p><b>See also:</b> <a href="#qualified_name_segments-1">qualified_name_segments/1</a>.</p>
    1877. 

  1877. 

  1878. <h3><a name="qualified_name_segments-1">qualified_name_segments/1</a></h3>
    1879. 

  1879. <p><tt>qualified_name_segments(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    1880. 

  1880. <p>Returns the list of name segments of a
    1881. 

  1881.   <code>qualified_name</code> node.
    1882. 

  1882.  </p>
    1883. 

  1883. <p><b>See also:</b> <a href="#qualified_name-1">qualified_name/1</a>.</p>
    1884. 

  1884. 

  1885. <h3><a name="query_expr-1">query_expr/1</a></h3>
    1886. 

  1886. <p><tt>query_expr(Body::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1887. 

  1887. <p>Creates an abstract Mnemosyne query expression. The result
    1888. 

  1888.   represents "<code>query <em>Body</em> end</code>".
    1889. 

  1889.  </p>
    1890. 

  1890. <p><b>See also:</b> <a href="#query_expr_body-1">query_expr_body/1</a>, <a href="#record_access-2">record_access/2</a>, <a href="#rule-2">rule/2</a>.</p>
    1891. 

  1891. 

  1892. <h3><a name="query_expr_body-1">query_expr_body/1</a></h3>
    1893. 

  1893. <p><tt>query_expr_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1894. 

  1894. <p>Returns the body subtree of a <code>query_expr</code> node.
    1895. 

  1895.  </p>
    1896. 

  1896. <p><b>See also:</b> <a href="#query_expr-1">query_expr/1</a>.</p>
    1897. 

  1897. 

  1898. <h3><a name="receive_expr-1">receive_expr/1</a></h3>
    1899. 

  1899. <p><tt>receive_expr(Clauses) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1900. 

  1900. <p>Equivalent to <a href="#receive_expr-3"><tt>receive_expr(Clauses, none, [])</tt></a>.</p>
    1901. 

  1901. 

  1902. 

  1903. <h3><a name="receive_expr-3">receive_expr/3</a></h3>
    1904. 

  1904. <p><tt>receive_expr(Clauses::[<a href="#type-syntaxTree">syntaxTree()</a>], Timeout, Action::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    1905. 

  1905. <ul><li><tt>Timeout = none | <a href="#type-syntaxTree">syntaxTree()</a></tt></li></ul></p>
    1906. 

  1906. <p>Creates an abstract receive-expression. If <code>Timeout</code>
    1907. 

  1907.   is <code>none</code>, the result represents "<code>receive
    1908. 

  1908.   <em>C1</em>; ...; <em>Cn</em> end</code>" (the <code>Action</code>
    1909. 

  1909.   argument is ignored). Otherwise, if <code>Clauses</code> is
    1910. 

  1910.   <code>[C1, ..., Cn]</code> and <code>Action</code> is <code>[A1, ...,
    1911. 

  1911.   Am]</code>, the result represents "<code>receive <em>C1</em>; ...;
    1912. 

  1912.   <em>Cn</em> after <em>Timeout</em> -&gt; <em>A1</em>, ..., <em>Am</em>
    1913. 

  1913.   end</code>". More exactly, if each <code>Ci</code> represents
    1914. 

  1914.   "<code>(<em>Pi</em>) <em>Gi</em> -&gt; <em>Bi</em></code>", then the
    1915. 

  1915.   result represents "<code>receive <em>P1</em> <em>G1</em> -&gt;
    1916. 

  1916.   <em>B1</em>; ...; <em>Pn</em> <em>Gn</em> -&gt; <em>Bn</em> ...
    1917. 

  1917.   end</code>".
    1918. 

  1918.  
    1919. 

  1919.   <p>Note that in Erlang, a receive-expression must have at least one
    1920. 

  1920.   clause if no timeout part is specified.</p>
    1921. 

  1921.  </p>
    1922. 

  1922. <p><b>See also:</b> <a href="#case_expr-2">case_expr/2</a>, <a href="#clause-3">clause/3</a>, <a href="#receive_expr-1">receive_expr/1</a>, <a href="#receive_expr_action-1">receive_expr_action/1</a>, <a href="#receive_expr_clauses-1">receive_expr_clauses/1</a>, <a href="#receive_expr_timeout-1">receive_expr_timeout/1</a>.</p>
    1923. 

  1923. 

  1924. <h3><a name="receive_expr_action-1">receive_expr_action/1</a></h3>
    1925. 

  1925. <p><tt>receive_expr_action(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    1926. 

  1926. <p>Returns the list of action body subtrees of a
    1927. 

  1927.   <code>receive_expr</code> node. If <code>Node</code> represents
    1928. 

  1928.   "<code>receive <em>C1</em>; ...; <em>Cn</em> end</code>", this is the
    1929. 

  1929.   empty list.
    1930. 

  1930.  </p>
    1931. 

  1931. <p><b>See also:</b> <a href="#receive_expr-3">receive_expr/3</a>.</p>
    1932. 

  1932. 

  1933. <h3><a name="receive_expr_clauses-1">receive_expr_clauses/1</a></h3>
    1934. 

  1934. <p><tt>receive_expr_clauses(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt>
    1935. 

  1935. <ul><li><tt><a name="type-type">type(Node)</a> = receive_expr</tt></li></ul></p>
    1936. 

  1936. <p>Returns the list of clause subtrees of a
    1937. 

  1937.   <code>receive_expr</code> node.
    1938. 

  1938.  </p>
    1939. 

  1939. <p><b>See also:</b> <a href="#receive_expr-3">receive_expr/3</a>.</p>
    1940. 

  1940. 

  1941. <h3><a name="receive_expr_timeout-1">receive_expr_timeout/1</a></h3>
    1942. 

  1942. <p><tt>receive_expr_timeout(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; Timeout</tt>
    1943. 

  1943. <ul><li><tt>Timeout = none | <a href="#type-syntaxTree">syntaxTree()</a></tt></li></ul></p>
    1944. 

  1944. <p>Returns the timeout subtree of a <code>receive_expr</code> node,
    1945. 

  1945.   if any. If <code>Node</code> represents "<code>receive <em>C1</em>;
    1946. 

  1946.   ...; <em>Cn</em> end</code>", <code>none</code> is returned.
    1947. 

  1947.   Otherwise, if <code>Node</code> represents "<code>receive
    1948. 

  1948.   <em>C1</em>; ...; <em>Cn</em> after <em>Timeout</em> -&gt; <em>A1</em>,
    1949. 

  1949.   ..., <em>Am</em> end</code>", <code>[A1, ..., Am]</code> is returned.
    1950. 

  1950.  </p>
    1951. 

  1951. <p><b>See also:</b> <a href="#receive_expr-3">receive_expr/3</a>.</p>
    1952. 

  1952. 

  1953. <h3><a name="record_access-2">record_access/2</a></h3>
    1954. 

  1954. <p><tt>record_access(Argument, Field) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1955. 

  1955. <p>Equivalent to <a href="#record_access-3"><tt>record_access(Argument, none, Field)</tt></a>.</p>
    1956. 

  1956. 

  1957. 

  1958. <h3><a name="record_access-3">record_access/3</a></h3>
    1959. 

  1959. <p><tt>record_access(Argument::<a href="#type-syntaxTree">syntaxTree()</a>, Type, Field::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    1960. 

  1960. <ul><li><tt>Type = none | <a href="#type-syntaxTree">syntaxTree()</a></tt></li></ul></p>
    1961. 

  1961. <p>Creates an abstract record field access expression. If
    1962. 

  1962.   <code>Type</code> is not <code>none</code>, the result represents
    1963. 

  1963.   "<code><em>Argument</em>#<em>Type</em>.<em>Field</em></code>".
    1964. 

  1964.  
    1965. 

  1965.   <p>If <code>Type</code> is <code>none</code>, the result represents
    1966. 

  1966.   "<code><em>Argument</em>.<em>Field</em></code>". This is a special
    1967. 

  1967.   form only allowed within Mnemosyne queries.</p>
    1968. 

  1968.  </p>
    1969. 

  1969. <p><b>See also:</b> <a href="#query_expr-1">query_expr/1</a>, <a href="#record_access-2">record_access/2</a>, <a href="#record_access_argument-1">record_access_argument/1</a>, <a href="#record_access_field-1">record_access_field/1</a>, <a href="#record_access_type-1">record_access_type/1</a>, <a href="#record_expr-3">record_expr/3</a>.</p>
    1970. 

  1970. 

  1971. <h3><a name="record_access_argument-1">record_access_argument/1</a></h3>
    1972. 

  1972. <p><tt>record_access_argument(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1973. 

  1973. <p>Returns the argument subtree of a <code>record_access</code>
    1974. 

  1974.   node.
    1975. 

  1975.  </p>
    1976. 

  1976. <p><b>See also:</b> <a href="#record_access-3">record_access/3</a>.</p>
    1977. 

  1977. 

  1978. <h3><a name="record_access_field-1">record_access_field/1</a></h3>
    1979. 

  1979. <p><tt>record_access_field(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1980. 

  1980. <p>Returns the field subtree of a <code>record_access</code>
    1981. 

  1981.   node.
    1982. 

  1982.  </p>
    1983. 

  1983. <p><b>See also:</b> <a href="#record_access-3">record_access/3</a>.</p>
    1984. 

  1984. 

  1985. <h3><a name="record_access_type-1">record_access_type/1</a></h3>
    1986. 

  1986. <p><tt>record_access_type(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; none | <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1987. 

  1987. <p>Returns the type subtree of a <code>record_access</code> node,
    1988. 

  1988.   if any. If <code>Node</code> represents
    1989. 

  1989.   "<code><em>Argument</em>.<em>Field</em></code>", <code>none</code>
    1990. 

  1990.   is returned, otherwise if <code>Node</code> represents
    1991. 

  1991.   "<code><em>Argument</em>#<em>Type</em>.<em>Field</em></code>",
    1992. 

  1992.   <code>Type</code> is returned.
    1993. 

  1993.  </p>
    1994. 

  1994. <p><b>See also:</b> <a href="#record_access-3">record_access/3</a>.</p>
    1995. 

  1995. 

  1996. <h3><a name="record_expr-2">record_expr/2</a></h3>
    1997. 

  1997. <p><tt>record_expr(Type, Fields) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    1998. 

  1998. <p>Equivalent to <a href="#record_expr-3"><tt>record_expr(none, Type, Fields)</tt></a>.</p>
    1999. 

  1999. 

  2000. 

  2001. <h3><a name="record_expr-3">record_expr/3</a></h3>
    2002. 

  2002. <p><tt>record_expr(Argument, Type::<a href="#type-syntaxTree">syntaxTree()</a>, Fields::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    2003. 

  2003. <ul><li><tt>Argument = none | <a href="#type-syntaxTree">syntaxTree()</a></tt></li></ul></p>
    2004. 

  2004. <p>Creates an abstract record expression. If <code>Fields</code> is
    2005. 

  2005.   <code>[F1, ..., Fn]</code>, then if <code>Argument</code> is
    2006. 

  2006.   <code>none</code>, the result represents
    2007. 

  2007.   "<code>#<em>Type</em>{<em>F1</em>, ..., <em>Fn</em>}</code>",
    2008. 

  2008.   otherwise it represents
    2009. 

  2009.   "<code><em>Argument</em>#<em>Type</em>{<em>F1</em>, ...,
    2010. 

  2010.   <em>Fn</em>}</code>".
    2011. 

  2011.  </p>
    2012. 

  2012. <p><b>See also:</b> <a href="#record_access-3">record_access/3</a>, <a href="#record_expr-2">record_expr/2</a>, <a href="#record_expr_argument-1">record_expr_argument/1</a>, <a href="#record_expr_fields-1">record_expr_fields/1</a>, <a href="#record_expr_type-1">record_expr_type/1</a>, <a href="#record_field-2">record_field/2</a>, <a href="#record_index_expr-2">record_index_expr/2</a>.</p>
    2013. 

  2013. 

  2014. <h3><a name="record_expr_argument-1">record_expr_argument/1</a></h3>
    2015. 

  2015. <p><tt>record_expr_argument(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; none | <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2016. 

  2016. <p>Returns the argument subtree of a <code>record_expr</code> node,
    2017. 

  2017.   if any. If <code>Node</code> represents
    2018. 

  2018.   "<code>#<em>Type</em>{...}</code>", <code>none</code> is returned.
    2019. 

  2019.   Otherwise, if <code>Node</code> represents
    2020. 

  2020.   "<code><em>Argument</em>#<em>Type</em>{...}</code>",
    2021. 

  2021.   <code>Argument</code> is returned.
    2022. 

  2022.  </p>
    2023. 

  2023. <p><b>See also:</b> <a href="#record_expr-3">record_expr/3</a>.</p>
    2024. 

  2024. 

  2025. <h3><a name="record_expr_fields-1">record_expr_fields/1</a></h3>
    2026. 

  2026. <tt>record_expr_fields(Node) -&gt; term()
    2027. 

  2027. </tt><p>Returns the list of field subtrees of a
    2028. 

  2028.   <code>record_expr</code> node.
    2029. 

  2029.  </p>
    2030. 

  2030. <p><b>See also:</b> <a href="#record_expr-3">record_expr/3</a>.</p>
    2031. 

  2031. 

  2032. <h3><a name="record_expr_type-1">record_expr_type/1</a></h3>
    2033. 

  2033. <tt>record_expr_type(Node) -&gt; term()
    2034. 

  2034. </tt><p>Returns the type subtree of a <code>record_expr</code> node.
    2035. 

  2035.  </p>
    2036. 

  2036. <p><b>See also:</b> <a href="#record_expr-3">record_expr/3</a>.</p>
    2037. 

  2037. 

  2038. <h3><a name="record_field-1">record_field/1</a></h3>
    2039. 

  2039. <p><tt>record_field(Name) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2040. 

  2040. <p>Equivalent to <a href="#record_field-2"><tt>record_field(Name, none)</tt></a>.</p>
    2041. 

  2041. 

  2042. 

  2043. <h3><a name="record_field-2">record_field/2</a></h3>
    2044. 

  2044. <p><tt>record_field(Name::<a href="#type-syntaxTree">syntaxTree()</a>, Value) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    2045. 

  2045. <ul><li><tt>Value = none | <a href="#type-syntaxTree">syntaxTree()</a></tt></li></ul></p>
    2046. 

  2046. <p>Creates an abstract record field specification. If
    2047. 

  2047.   <code>Value</code> is <code>none</code>, the result represents
    2048. 

  2048.   simply "<code><em>Name</em></code>", otherwise it represents
    2049. 

  2049.   "<code><em>Name</em> = <em>Value</em></code>".
    2050. 

  2050.  </p>
    2051. 

  2051. <p><b>See also:</b> <a href="#record_expr-3">record_expr/3</a>, <a href="#record_field_name-1">record_field_name/1</a>, <a href="#record_field_value-1">record_field_value/1</a>.</p>
    2052. 

  2052. 

  2053. <h3><a name="record_field_name-1">record_field_name/1</a></h3>
    2054. 

  2054. <p><tt>record_field_name(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2055. 

  2055. <p>Returns the name subtree of a <code>record_field</code> node.
    2056. 

  2056.  </p>
    2057. 

  2057. <p><b>See also:</b> <a href="#record_field-2">record_field/2</a>.</p>
    2058. 

  2058. 

  2059. <h3><a name="record_field_value-1">record_field_value/1</a></h3>
    2060. 

  2060. <p><tt>record_field_value(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; none | <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2061. 

  2061. <p>Returns the value subtree of a <code>record_field</code> node,
    2062. 

  2062.   if any. If <code>Node</code> represents
    2063. 

  2063.   "<code><em>Name</em></code>", <code>none</code> is
    2064. 

  2064.   returned. Otherwise, if <code>Node</code> represents
    2065. 

  2065.   "<code><em>Name</em> = <em>Value</em></code>", <code>Value</code>
    2066. 

  2066.   is returned.
    2067. 

  2067.  </p>
    2068. 

  2068. <p><b>See also:</b> <a href="#record_field-2">record_field/2</a>.</p>
    2069. 

  2069. 

  2070. <h3><a name="record_index_expr-2">record_index_expr/2</a></h3>
    2071. 

  2071. <p><tt>record_index_expr(Type::<a href="#type-syntaxTree">syntaxTree()</a>, Field::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2072. 

  2072. <p>Creates an abstract record field index expression. The result
    2073. 

  2073.   represents "<code>#<em>Type</em>.<em>Field</em></code>".
    2074. 

  2074.  
    2075. 

  2075.   <p>(Note: the function name <code>record_index/2</code> is reserved
    2076. 

  2076.   by the Erlang compiler, which is why that name could not be used
    2077. 

  2077.   for this constructor.)</p>
    2078. 

  2078.  </p>
    2079. 

  2079. <p><b>See also:</b> <a href="#record_expr-3">record_expr/3</a>, <a href="#record_index_expr_field-1">record_index_expr_field/1</a>, <a href="#record_index_expr_type-1">record_index_expr_type/1</a>.</p>
    2080. 

  2080. 

  2081. <h3><a name="record_index_expr_field-1">record_index_expr_field/1</a></h3>
    2082. 

  2082. <p><tt>record_index_expr_field(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2083. 

  2083. <p>Returns the field subtree of a <code>record_index_expr</code>
    2084. 

  2084.   node.
    2085. 

  2085.  </p>
    2086. 

  2086. <p><b>See also:</b> <a href="#record_index_expr-2">record_index_expr/2</a>.</p>
    2087. 

  2087. 

  2088. <h3><a name="record_index_expr_type-1">record_index_expr_type/1</a></h3>
    2089. 

  2089. <p><tt>record_index_expr_type(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2090. 

  2090. <p>Returns the type subtree of a <code>record_index_expr</code>
    2091. 

  2091.   node.
    2092. 

  2092.  </p>
    2093. 

  2093. <p><b>See also:</b> <a href="#record_index_expr-2">record_index_expr/2</a>.</p>
    2094. 

  2094. 

  2095. <h3><a name="remove_comments-1">remove_comments/1</a></h3>
    2096. 

  2096. <p><tt>remove_comments(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2097. 

  2097. <p>Clears the associated comments of <code>Node</code>.
    2098. 

  2098.  
    2099. 

  2099.   <p>Note: This is equivalent to
    2100. 

  2100.   <code>set_precomments(set_postcomments(Node, []), [])</code>, but
    2101. 

  2101.   potentially more efficient.</p>
    2102. 

  2102.  </p>
    2103. 

  2103. <p><b>See also:</b> <a href="#set_postcomments-2">set_postcomments/2</a>, <a href="#set_precomments-2">set_precomments/2</a>.</p>
    2104. 

  2104. 

  2105. <h3><a name="revert-1">revert/1</a></h3>
    2106. 

  2106. <p><tt>revert(Tree::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2107. 

  2107. <p>Returns an <code>erl_parse</code>-compatible representation of a
    2108. 

  2108.   syntax tree, if possible. If <code>Tree</code> represents a
    2109. 

  2109.   well-formed Erlang program or expression, the conversion should work
    2110. 

  2110.   without problems. Typically, <code>is_tree/1</code> yields
    2111. 

  2111.   <code>true</code> if conversion failed (i.e., the result is still an
    2112. 

  2112.   abstract syntax tree), and <code>false</code> otherwise.
    2113. 

  2113.  
    2114. 

  2114.   <p>The <code>is_tree/1</code> test is not completely foolproof. For a
    2115. 

  2115.   few special node types (e.g. <code>arity_qualifier</code>), if such a
    2116. 

  2116.   node occurs in a context where it is not expected, it will be left
    2117. 

  2117.   unchanged as a non-reverted subtree of the result. This can only
    2118. 

  2118.   happen if <code>Tree</code> does not actually represent legal Erlang
    2119. 

  2119.   code.</p>
    2120. 

  2120.  </p>
    2121. 

  2121. <p><b>See also:</b> <a href="/usr/local/home/richardc/hipe/otp/lib/stdlib/doc/erl_parse.html">erl_parse</a>, <a href="#revert_forms-1">revert_forms/1</a>.</p>
    2122. 

  2122. 

  2123. <h3><a name="revert_forms-1">revert_forms/1</a></h3>
    2124. 

  2124. <p><tt>revert_forms(L::Forms) -&gt; [<a href="#type-erl_parse">erl_parse()</a>]</tt>
    2125. 

  2125. <ul><li><tt>Forms = <a href="#type-syntaxTree">syntaxTree()</a> | [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></li></ul></p>
    2126. 

  2126. <p>Reverts a sequence of Erlang source code forms. The sequence can
    2127. 

  2127.   be given either as a <code>form_list</code> syntax tree (possibly
    2128. 

  2128.   nested), or as a list of "program form" syntax trees. If successful,
    2129. 

  2129.   the corresponding flat list of <code>erl_parse</code>-compatible
    2130. 

  2130.   syntax trees is returned (cf. <code>revert/1</code>). If some program
    2131. 

  2131.   form could not be reverted, <code>{error, Form}</code> is thrown.
    2132. 

  2132.   Standalone comments in the form sequence are discarded.
    2133. 

  2133.  </p>
    2134. 

  2134. <p><b>See also:</b> <a href="#form_list-1">form_list/1</a>, <a href="#is_form-1">is_form/1</a>, <a href="#revert-1">revert/1</a>.</p>
    2135. 

  2135. 

  2136. <h3><a name="rule-2">rule/2</a></h3>
    2137. 

  2137. <p><tt>rule(Name::<a href="#type-syntaxTree">syntaxTree()</a>, Clauses::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2138. 

  2138. <p>Creates an abstract Mnemosyne rule. If <code>Clauses</code> is
    2139. 

  2139.   <code>[C1, ..., Cn]</code>, the results represents
    2140. 

  2140.   "<code><em>Name</em> <em>C1</em>; ...; <em>Name</em>
    2141. 

  2141.   <em>Cn</em>.</code>". More exactly, if each <code>Ci</code>
    2142. 

  2142.   represents "<code>(<em>Pi1</em>, ..., <em>Pim</em>) <em>Gi</em> -&gt;
    2143. 

  2143.   <em>Bi</em></code>", then the result represents
    2144. 

  2144.   "<code><em>Name</em>(<em>P11</em>, ..., <em>P1m</em>) <em>G1</em> :-
    2145. 

  2145.   <em>B1</em>; ...; <em>Name</em>(<em>Pn1</em>, ..., <em>Pnm</em>)
    2146. 

  2146.   <em>Gn</em> :- <em>Bn</em>.</code>". Rules are source code forms.
    2147. 

  2147.  </p>
    2148. 

  2148. <p><b>See also:</b> <a href="#function-2">function/2</a>, <a href="#is_form-1">is_form/1</a>, <a href="#rule_arity-1">rule_arity/1</a>, <a href="#rule_clauses-1">rule_clauses/1</a>, <a href="#rule_name-1">rule_name/1</a>.</p>
    2149. 

  2149. 

  2150. <h3><a name="rule_arity-1">rule_arity/1</a></h3>
    2151. 

  2151. <p><tt>rule_arity(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; integer()</tt></p>
    2152. 

  2152. <p>Returns the arity of a <code>rule</code> node. The result is the
    2153. 

  2153.   number of parameter patterns in the first clause of the rule;
    2154. 

  2154.   subsequent clauses are ignored.
    2155. 

  2155.  
    2156. 

  2156.   <p>An exception is thrown if <code>rule_clauses(Node)</code> returns
    2157. 

  2157.   an empty list, or if the first element of that list is not a syntax
    2158. 

  2158.   tree <code>C</code> of type <code>clause</code> such that
    2159. 

  2159.   <code>clause_patterns(C)</code> is a nonempty list.</p>
    2160. 

  2160.  </p>
    2161. 

  2161. <p><b>See also:</b> <a href="#clause-3">clause/3</a>, <a href="#clause_patterns-1">clause_patterns/1</a>, <a href="#rule-2">rule/2</a>, <a href="#rule_clauses-1">rule_clauses/1</a>.</p>
    2162. 

  2162. 

  2163. <h3><a name="rule_clauses-1">rule_clauses/1</a></h3>
    2164. 

  2164. <p><tt>rule_clauses(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    2165. 

  2165. <p>Returns the list of clause subtrees of a <code>rule</code> node.
    2166. 

  2166.  </p>
    2167. 

  2167. <p><b>See also:</b> <a href="#rule-2">rule/2</a>.</p>
    2168. 

  2168. 

  2169. <h3><a name="rule_name-1">rule_name/1</a></h3>
    2170. 

  2170. <p><tt>rule_name(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2171. 

  2171. <p>Returns the name subtree of a <code>rule</code> node.
    2172. 

  2172.  </p>
    2173. 

  2173. <p><b>See also:</b> <a href="#rule-2">rule/2</a>.</p>
    2174. 

  2174. 

  2175. <h3><a name="set_ann-2">set_ann/2</a></h3>
    2176. 

  2176. <p><tt>set_ann(Node::<a href="#type-syntaxTree">syntaxTree()</a>, Annotations::[term()]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2177. 

  2177. <p>Sets the list of user annotations of <code>Node</code> to
    2178. 

  2178.   <code>Annotations</code>.
    2179. 

  2179.  </p>
    2180. 

  2180. <p><b>See also:</b> <a href="#add_ann-2">add_ann/2</a>, <a href="#copy_ann-2">copy_ann/2</a>, <a href="#get_ann-1">get_ann/1</a>.</p>
    2181. 

  2181. 

  2182. <h3><a name="set_attrs-2">set_attrs/2</a></h3>
    2183. 

  2183. <p><tt>set_attrs(Node::<a href="#type-syntaxTree">syntaxTree()</a>, Attributes::<a href="#type-syntaxTreeAttributes">syntaxTreeAttributes()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2184. 

  2184. <p>Sets the attributes of <code>Node</code> to
    2185. 

  2185.   <code>Attributes</code>.
    2186. 

  2186.  </p>
    2187. 

  2187. <p><b>See also:</b> <a href="#copy_attrs-2">copy_attrs/2</a>, <a href="#get_attrs-1">get_attrs/1</a>.</p>
    2188. 

  2188. 

  2189. <h3><a name="set_pos-2">set_pos/2</a></h3>
    2190. 

  2190. <p><tt>set_pos(Node::<a href="#type-syntaxTree">syntaxTree()</a>, Pos::term()) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2191. 

  2191. <p>Sets the position information of <code>Node</code> to
    2192. 

  2192.   <code>Pos</code>.
    2193. 

  2193.  </p>
    2194. 

  2194. <p><b>See also:</b> <a href="#copy_pos-2">copy_pos/2</a>, <a href="#get_pos-1">get_pos/1</a>.</p>
    2195. 

  2195. 

  2196. <h3><a name="set_postcomments-2">set_postcomments/2</a></h3>
    2197. 

  2197. <p><tt>set_postcomments(Node::<a href="#type-syntaxTree">syntaxTree()</a>, Comments::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2198. 

  2198. <p>Sets the post-comments of <code>Node</code> to
    2199. 

  2199.   <code>Comments</code>. <code>Comments</code> should be a possibly
    2200. 

  2200.   empty list of abstract comments, in top-down textual order
    2201. 

  2201.  </p>
    2202. 

  2202. <p><b>See also:</b> <a href="#add_postcomments-2">add_postcomments/2</a>, <a href="#comment-2">comment/2</a>, <a href="#copy_comments-2">copy_comments/2</a>, <a href="#get_postcomments-1">get_postcomments/1</a>, <a href="#join_comments-2">join_comments/2</a>, <a href="#remove_comments-1">remove_comments/1</a>, <a href="#set_precomments-2">set_precomments/2</a>.</p>
    2203. 

  2203. 

  2204. <h3><a name="set_precomments-2">set_precomments/2</a></h3>
    2205. 

  2205. <p><tt>set_precomments(Node::<a href="#type-syntaxTree">syntaxTree()</a>, Comments::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2206. 

  2206. <p>Sets the pre-comments of <code>Node</code> to
    2207. 

  2207.   <code>Comments</code>. <code>Comments</code> should be a possibly
    2208. 

  2208.   empty list of abstract comments, in top-down textual order.
    2209. 

  2209.  </p>
    2210. 

  2210. <p><b>See also:</b> <a href="#add_precomments-2">add_precomments/2</a>, <a href="#comment-2">comment/2</a>, <a href="#copy_comments-2">copy_comments/2</a>, <a href="#get_precomments-1">get_precomments/1</a>, <a href="#join_comments-2">join_comments/2</a>, <a href="#remove_comments-1">remove_comments/1</a>, <a href="#set_postcomments-2">set_postcomments/2</a>.</p>
    2211. 

  2211. 

  2212. <h3><a name="size_qualifier-2">size_qualifier/2</a></h3>
    2213. 

  2213. <p><tt>size_qualifier(Body::<a href="#type-syntaxTree">syntaxTree()</a>, Size::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2214. 

  2214. <p>Creates an abstract size qualifier. The result represents
    2215. 

  2215.   "<code><em>Body</em>:<em>Size</em></code>".
    2216. 

  2216.  </p>
    2217. 

  2217. <p><b>See also:</b> <a href="#size_qualifier_argument-1">size_qualifier_argument/1</a>, <a href="#size_qualifier_body-1">size_qualifier_body/1</a>.</p>
    2218. 

  2218. 

  2219. <h3><a name="size_qualifier_argument-1">size_qualifier_argument/1</a></h3>
    2220. 

  2220. <p><tt>size_qualifier_argument(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2221. 

  2221. <p>Returns the argument subtree (the size) of a
    2222. 

  2222.   <code>size_qualifier</code> node.
    2223. 

  2223.  </p>
    2224. 

  2224. <p><b>See also:</b> <a href="#size_qualifier-2">size_qualifier/2</a>.</p>
    2225. 

  2225. 

  2226. <h3><a name="size_qualifier_body-1">size_qualifier_body/1</a></h3>
    2227. 

  2227. <p><tt>size_qualifier_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2228. 

  2228. <p>Returns the body subtree of a <code>size_qualifier</code>
    2229. 

  2229.   node.
    2230. 

  2230.  </p>
    2231. 

  2231. <p><b>See also:</b> <a href="#size_qualifier-2">size_qualifier/2</a>.</p>
    2232. 

  2232. 

  2233. <h3><a name="string-1">string/1</a></h3>
    2234. 

  2234. <p><tt>string(Value::string()) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2235. 

  2235. <p>Creates an abstract string literal. The result represents
    2236. 

  2236.   <code>"<em>Text</em>"</code> (including the surrounding
    2237. 

  2237.   double-quotes), where <code>Text</code> corresponds to the sequence
    2238. 

  2238.   of characters in <code>Value</code>, but not representing a
    2239. 

  2239.   <em>specific</em> string literal. E.g., the result of
    2240. 

  2240.   <code>string("x\ny")</code> represents any and all of
    2241. 

  2241.   <code>"x\ny"</code>, <code>"x\12y"</code>, <code>"x\012y"</code> and
    2242. 

  2242.   <code>"x\^Jy"</code>; cf. <code>char/1</code>.
    2243. 

  2243.  </p>
    2244. 

  2244. <p><b>See also:</b> <a href="#char-1">char/1</a>, <a href="#is_string-2">is_string/2</a>, <a href="#string_literal-1">string_literal/1</a>, <a href="#string_value-1">string_value/1</a>.</p>
    2245. 

  2245. 

  2246. <h3><a name="string_literal-1">string_literal/1</a></h3>
    2247. 

  2247. <p><tt>string_literal(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; string()</tt></p>
    2248. 

  2248. <p>Returns the literal string represented by a <code>string</code>
    2249. 

  2249.   node. This includes surrounding double-quote characters.
    2250. 

  2250.  </p>
    2251. 

  2251. <p><b>See also:</b> <a href="#string-1">string/1</a>.</p>
    2252. 

  2252. 

  2253. <h3><a name="string_value-1">string_value/1</a></h3>
    2254. 

  2254. <p><tt>string_value(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; string()</tt></p>
    2255. 

  2255. <p>Returns the value represented by a <code>string</code> node.
    2256. 

  2256.  </p>
    2257. 

  2257. <p><b>See also:</b> <a href="#string-1">string/1</a>.</p>
    2258. 

  2258. 

  2259. <h3><a name="subtrees-1">subtrees/1</a></h3>
    2260. 

  2260. <p><tt>subtrees(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [[<a href="#type-syntaxTree">syntaxTree()</a>]]</tt></p>
    2261. 

  2261. <p>Returns the grouped list of all subtrees of a syntax tree. If
    2262. 

  2262.   <code>Node</code> is a leaf node (cf. <code>is_leaf/1</code>), this
    2263. 

  2263.   is the empty list, otherwise the result is always a nonempty list,
    2264. 

  2264.   containing the lists of subtrees of <code>Node</code>, in
    2265. 

  2265.   left-to-right order as they occur in the printed program text, and
    2266. 

  2266.   grouped by category. Often, each group contains only a single
    2267. 

  2267.   subtree.
    2268. 

  2268.  
    2269. 

  2269.   <p>Depending on the type of <code>Node</code>, the size of some
    2270. 

  2270.   groups may be variable (e.g., the group consisting of all the
    2271. 

  2271.   elements of a tuple), while others always contain the same number of
    2272. 

  2272.   elements - usually exactly one (e.g., the group containing the
    2273. 

  2273.   argument expression of a case-expression). Note, however, that the
    2274. 

  2274.   exact structure of the returned list (for a given node type) should
    2275. 

  2275.   in general not be depended upon, since it might be subject to change
    2276. 

  2276.   without notice.</p>
    2277. 

  2277.  
    2278. 

  2278.   <p>The function <code>subtrees/1</code> and the constructor functions
    2279. 

  2279.   <code>make_tree/2</code> and <code>update_tree/2</code> can be a
    2280. 

  2280.   great help if one wants to traverse a syntax tree, visiting all its
    2281. 

  2281.   subtrees, but treat nodes of the tree in a uniform way in most or all
    2282. 

  2282.   cases. Using these functions makes this simple, and also assures that
    2283. 

  2283.   your code is not overly sensitive to extensions of the syntax tree
    2284. 

  2284.   data type, because any node types not explicitly handled by your code
    2285. 

  2285.   can be left to a default case.</p>
    2286. 

  2286.  
    2287. 

  2287.   <p>For example:
    2288. 

  2288.   <pre>
    2289. 

  2289.     postorder(F, Tree) -&gt;
    2290. 

  2290.         F(case subtrees(Tree) of
    2291. 

  2291.             [] -&gt; Tree;
    2292. 

  2292.             List -&gt; update_tree(Tree,
    2293. 

  2293.                                 [[postorder(F, Subtree)
    2294. 

  2294.                                   || Subtree &lt;- Group]
    2295. 

  2295.                                  || Group &lt;- List])
    2296. 

  2296.           end).
    2297. 

  2297.   </pre>
    2298. 

  2298.   maps the function <code>F</code> on <code>Tree</code> and all its
    2299. 

  2299.   subtrees, doing a post-order traversal of the syntax tree. (Note the
    2300. 

  2300.   use of <code>update_tree/2</code> to preserve node attributes.) For a
    2301. 

  2301.   simple function like:
    2302. 

  2302.   <pre>
    2303. 

  2303.     f(Node) -&gt;
    2304. 

  2304.         case type(Node) of
    2305. 

  2305.             atom -&gt; atom("a_" ++ atom_name(Node));
    2306. 

  2306.             _ -&gt; Node
    2307. 

  2307.         end.
    2308. 

  2308.   </pre>
    2309. 

  2309.   the call <code>postorder(fun f/1, Tree)</code> will yield a new
    2310. 

  2310.   representation of <code>Tree</code> in which all atom names have been
    2311. 

  2311.   extended with the prefix "a_", but nothing else (including comments,
    2312. 

  2312.   annotations and line numbers) has been changed.</p>
    2313. 

  2313.  </p>
    2314. 

  2314. <p><b>See also:</b> <a href="#copy_attrs-2">copy_attrs/2</a>, <a href="#is_leaf-1">is_leaf/1</a>, <a href="#make_tree-2">make_tree/2</a>, <a href="#type-1">type/1</a>.</p>
    2315. 

  2315. 

  2316. <h3><a name="text-1">text/1</a></h3>
    2317. 

  2317. <p><tt>text(String::string()) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2318. 

  2318. <p>Creates an abstract piece of source code text. The result
    2319. 

  2319.   represents exactly the sequence of characters in <code>String</code>.
    2320. 

  2320.   This is useful in cases when one wants full control of the resulting
    2321. 

  2321.   output, e.g., for the appearance of floating-point numbers or macro
    2322. 

  2322.   definitions.
    2323. 

  2323.  </p>
    2324. 

  2324. <p><b>See also:</b> <a href="#text_string-1">text_string/1</a>.</p>
    2325. 

  2325. 

  2326. <h3><a name="text_string-1">text_string/1</a></h3>
    2327. 

  2327. <p><tt>text_string(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; string()</tt></p>
    2328. 

  2328. <p>Returns the character sequence represented by a
    2329. 

  2329.   <code>text</code> node.
    2330. 

  2330.  </p>
    2331. 

  2331. <p><b>See also:</b> <a href="#text-1">text/1</a>.</p>
    2332. 

  2332. 

  2333. <h3><a name="tree-1">tree/1</a></h3>
    2334. 

  2334. <p><tt>tree(Type) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2335. 

  2335. <p>Equivalent to <a href="#tree-2"><tt>tree(Type, [])</tt></a>.</p>
    2336. 

  2336. 

  2337. 

  2338. <h3><a name="tree-2">tree/2</a></h3>
    2339. 

  2339. <p><tt>tree(Type::atom(), Data::term()) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2340. 

  2340. <p><em>For special purposes only</em>. Creates an abstract syntax
    2341. 

  2341.   tree node with type tag <code>Type</code> and associated data
    2342. 

  2342.   <code>Data</code>.
    2343. 

  2343.  
    2344. 

  2344.   <p>This function and the related <code>is_tree/1</code> and
    2345. 

  2345.   <code>data/1</code> provide a uniform way to extend the set of
    2346. 

  2346.   <code>erl_parse</code> node types. The associated data is any term,
    2347. 

  2347.   whose format may depend on the type tag.</p>
    2348. 

  2348.  
    2349. 

  2349.   <h4>Notes:</h4>
    2350. 

  2350.   <ul>
    2351. 

  2351.    <li>Any nodes created outside of this module must have type tags
    2352. 

  2352.        distinct from those currently defined by this module; see
    2353. 

  2353.        <code>type/1</code> for a complete list.</li>
    2354. 

  2354.    <li>The type tag of a syntax tree node may also be used
    2355. 

  2355.        as a primary tag by the <code>erl_parse</code> representation;
    2356. 

  2356.        in that case, the selector functions for that node type
    2357. 

  2357.        <em>must</em> handle both the abstract syntax tree and the
    2358. 

  2358.        <code>erl_parse</code> form. The function <code>type(T)</code>
    2359. 

  2359.        should return the correct type tag regardless of the
    2360. 

  2360.        representation of <code>T</code>, so that the user sees no
    2361. 

  2361.        difference between <code>erl_syntax</code> and
    2362. 

  2362.        <code>erl_parse</code> nodes.</li>
    2363. 

  2363.   </ul></p>
    2364. 

  2364. <p><b>See also:</b> <a href="#data-1">data/1</a>, <a href="#is_tree-1">is_tree/1</a>, <a href="#type-1">type/1</a>.</p>
    2365. 

  2365. 

  2366. <h3><a name="try_after_expr-2">try_after_expr/2</a></h3>
    2367. 

  2367. <p><tt>try_after_expr(Body::<a href="#type-syntaxTree">syntaxTree()</a>, After::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2368. 

  2368. <p>Equivalent to <a href="#try_expr-4"><tt>try_expr(Body, [], [], After)</tt></a>.</p>
    2369. 

  2369. 

  2370. 

  2371. <h3><a name="try_expr-2">try_expr/2</a></h3>
    2372. 

  2372. <p><tt>try_expr(Body::<a href="#type-syntaxTree">syntaxTree()</a>, Handlers::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2373. 

  2373. <p>Equivalent to <a href="#try_expr-3"><tt>try_expr(Body, [], Handlers)</tt></a>.</p>
    2374. 

  2374. 

  2375. 

  2376. <h3><a name="try_expr-3">try_expr/3</a></h3>
    2377. 

  2377. <p><tt>try_expr(Body::<a href="#type-syntaxTree">syntaxTree()</a>, Clauses::[<a href="#type-syntaxTree">syntaxTree()</a>], Handlers::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2378. 

  2378. <p>Equivalent to <a href="#try_expr-4"><tt>try_expr(Body, Clauses, Handlers, [])</tt></a>.</p>
    2379. 

  2379. 

  2380. 

  2381. <h3><a name="try_expr-4">try_expr/4</a></h3>
    2382. 

  2382. <p><tt>try_expr(Body::[<a href="#type-syntaxTree">syntaxTree()</a>], Clauses::[<a href="#type-syntaxTree">syntaxTree()</a>], Handlers::[<a href="#type-syntaxTree">syntaxTree()</a>], After::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2383. 

  2383. <p>Creates an abstract try-expression. If <code>Body</code> is
    2384. 

  2384.   <code>[B1, ..., Bn]</code>, <code>Clauses</code> is <code>[C1, ...,
    2385. 

  2385.   Cj]</code>, <code>Handlers</code> is <code>[H1, ..., Hk]</code>, and
    2386. 

  2386.   <code>After</code> is <code>[A1, ..., Am]</code>, the result
    2387. 

  2387.   represents "<code>try <em>B1</em>, ..., <em>Bn</em> of <em>C1</em>;
    2388. 

  2388.   ...; <em>Cj</em> catch <em>H1</em>; ...; <em>Hk</em> after
    2389. 

  2389.   <em>A1</em>, ..., <em>Am</em> end</code>". More exactly, if each
    2390. 

  2390.   <code>Ci</code> represents "<code>(<em>CPi</em>) <em>CGi</em> -&gt;
    2391. 

  2391.   <em>CBi</em></code>", and each <code>Hi</code> represents
    2392. 

  2392.   "<code>(<em>HPi</em>) <em>HGi</em> -&gt; <em>HBi</em></code>", then the
    2393. 

  2393.   result represents "<code>try <em>B1</em>, ..., <em>Bn</em> of
    2394. 

  2394.   <em>CP1</em> <em>CG1</em> -&gt; <em>CB1</em>; ...; <em>CPj</em>
    2395. 

  2395.   <em>CGj</em> -&gt; <em>CBj</em> catch <em>HP1</em> <em>HG1</em> -&gt;
    2396. 

  2396.   <em>HB1</em>; ...; <em>HPk</em> <em>HGk</em> -&gt; <em>HBk</em> after
    2397. 

  2397.   <em>A1</em>, ..., <em>Am</em> end</code>"; cf.
    2398. 

  2398.   <code>case_expr/2</code>. If <code>Clauses</code> is the empty list,
    2399. 

  2399.   the <code>of ...</code> section is left out. If <code>After</code> is
    2400. 

  2400.   the empty list, the <code>after ...</code> section is left out. If
    2401. 

  2401.   <code>Handlers</code> is the empty list, and <code>After</code> is
    2402. 

  2402.   nonempty, the <code>catch ...</code> section is left out.
    2403. 

  2403.  </p>
    2404. 

  2404. <p><b>See also:</b> <a href="#case_expr-2">case_expr/2</a>, <a href="#class_qualifier-2">class_qualifier/2</a>, <a href="#clause-3">clause/3</a>, <a href="#try_after_expr-2">try_after_expr/2</a>, <a href="#try_expr-2">try_expr/2</a>, <a href="#try_expr-3">try_expr/3</a>, <a href="#try_expr_after-1">try_expr_after/1</a>, <a href="#try_expr_body-1">try_expr_body/1</a>, <a href="#try_expr_clauses-1">try_expr_clauses/1</a>, <a href="#try_expr_handlers-1">try_expr_handlers/1</a>.</p>
    2405. 

  2405. 

  2406. <h3><a name="try_expr_after-1">try_expr_after/1</a></h3>
    2407. 

  2407. <p><tt>try_expr_after(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    2408. 

  2408. <p>Returns the list of "after" subtrees of a <code>try_expr</code>
    2409. 

  2409.   node.
    2410. 

  2410.  </p>
    2411. 

  2411. <p><b>See also:</b> <a href="#try_expr-4">try_expr/4</a>.</p>
    2412. 

  2412. 

  2413. <h3><a name="try_expr_body-1">try_expr_body/1</a></h3>
    2414. 

  2414. <p><tt>try_expr_body(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    2415. 

  2415. <p>Returns the list of body subtrees of a <code>try_expr</code>
    2416. 

  2416.   node.
    2417. 

  2417.  </p>
    2418. 

  2418. <p><b>See also:</b> <a href="#try_expr-4">try_expr/4</a>.</p>
    2419. 

  2419. 

  2420. <h3><a name="try_expr_clauses-1">try_expr_clauses/1</a></h3>
    2421. 

  2421. <p><tt>try_expr_clauses(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    2422. 

  2422. <p>Returns the list of case-clause subtrees of a
    2423. 

  2423.   <code>try_expr</code> node. If <code>Node</code> represents
    2424. 

  2424.   "<code>try <em>Body</em> catch <em>H1</em>; ...; <em>Hn</em>
    2425. 

  2425.   end</code>", the result is the empty list.
    2426. 

  2426.  </p>
    2427. 

  2427. <p><b>See also:</b> <a href="#try_expr-4">try_expr/4</a>.</p>
    2428. 

  2428. 

  2429. <h3><a name="try_expr_handlers-1">try_expr_handlers/1</a></h3>
    2430. 

  2430. <p><tt>try_expr_handlers(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    2431. 

  2431. <p>Returns the list of handler-clause subtrees of a
    2432. 

  2432.   <code>try_expr</code> node.
    2433. 

  2433.  </p>
    2434. 

  2434. <p><b>See also:</b> <a href="#try_expr-4">try_expr/4</a>.</p>
    2435. 

  2435. 

  2436. <h3><a name="tuple-1">tuple/1</a></h3>
    2437. 

  2437. <p><tt>tuple(Elements::[<a href="#type-syntaxTree">syntaxTree()</a>]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2438. 

  2438. <p>Creates an abstract tuple. If <code>Elements</code> is
    2439. 

  2439.   <code>[X1, ..., Xn]</code>, the result represents
    2440. 

  2440.   "<code>{<em>X1</em>, ..., <em>Xn</em>}</code>".
    2441. 

  2441.  
    2442. 

  2442.   <p>Note: The Erlang language has distinct 1-tuples, i.e.,
    2443. 

  2443.   <code>{X}</code> is always distinct from <code>X</code> itself.</p>
    2444. 

  2444.  </p>
    2445. 

  2445. <p><b>See also:</b> <a href="#tuple_elements-1">tuple_elements/1</a>, <a href="#tuple_size-1">tuple_size/1</a>.</p>
    2446. 

  2446. 

  2447. <h3><a name="tuple_elements-1">tuple_elements/1</a></h3>
    2448. 

  2448. <p><tt>tuple_elements(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; [<a href="#type-syntaxTree">syntaxTree()</a>]</tt></p>
    2449. 

  2449. <p>Returns the list of element subtrees of a <code>tuple</code>
    2450. 

  2450.   node.
    2451. 

  2451.  </p>
    2452. 

  2452. <p><b>See also:</b> <a href="#tuple-1">tuple/1</a>.</p>
    2453. 

  2453. 

  2454. <h3><a name="tuple_size-1">tuple_size/1</a></h3>
    2455. 

  2455. <p><tt>tuple_size(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; integer()</tt></p>
    2456. 

  2456. <p>Returns the number of elements of a <code>tuple</code> node.
    2457. 

  2457.  
    2458. 

  2458.   <p>Note: this is equivalent to
    2459. 

  2459.   <code>length(tuple_elements(Node))</code>, but potentially more
    2460. 

  2460.   efficient.</p>
    2461. 

  2461.  </p>
    2462. 

  2462. <p><b>See also:</b> <a href="#tuple-1">tuple/1</a>, <a href="#tuple_elements-1">tuple_elements/1</a>.</p>
    2463. 

  2463. 

  2464. <h3><a name="type-1">type/1</a></h3>
    2465. 

  2465. <p><tt>type(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; atom()</tt></p>
    2466. 

  2466. <p>Returns the type tag of <code>Node</code>. If <code>Node</code>
    2467. 

  2467.   does not represent a syntax tree, evaluation fails with reason
    2468. 

  2468.   <code>badarg</code>. Node types currently defined by this module are:
    2469. 

  2469.   <p><center><table border="1">
    2470. 

  2470.    <tr>
    2471. 

  2471.     <td>application</td>
    2472. 

  2472.     <td>arity_qualifier</td>
    2473. 

  2473.     <td>atom</td>
    2474. 

  2474.     <td>attribute</td>
    2475. 

  2475.    </tr><tr>
    2476. 

  2476.     <td>binary</td>
    2477. 

  2477.     <td>binary_field</td>
    2478. 

  2478.     <td>block_expr</td>
    2479. 

  2479.     <td>case_expr</td>
    2480. 

  2480.    </tr><tr>
    2481. 

  2481.     <td>catch_expr</td>
    2482. 

  2482.     <td>char</td>
    2483. 

  2483.     <td>class_qualifier</td>
    2484. 

  2484.     <td>clause</td>
    2485. 

  2485.    </tr><tr>
    2486. 

  2486.     <td>comment</td>
    2487. 

  2487.     <td>cond_expr</td>
    2488. 

  2488.     <td>conjunction</td>
    2489. 

  2489.     <td>disjunction</td>
    2490. 

  2490.    </tr><tr>
    2491. 

  2491.     <td>eof_marker</td>
    2492. 

  2492.     <td>error_marker</td>
    2493. 

  2493.     <td>float</td>
    2494. 

  2494.     <td>form_list</td>
    2495. 

  2495.    </tr><tr>
    2496. 

  2496.     <td>fun_expr</td>
    2497. 

  2497.     <td>function</td>
    2498. 

  2498.     <td>generator</td>
    2499. 

  2499.     <td>if_expr</td>
    2500. 

  2500.    </tr><tr>
    2501. 

  2501.     <td>implicit_fun</td>
    2502. 

  2502.     <td>infix_expr</td>
    2503. 

  2503.     <td>integer</td>
    2504. 

  2504.     <td>list</td>
    2505. 

  2505.    </tr><tr>
    2506. 

  2506.     <td>list_comp</td>
    2507. 

  2507.     <td>macro</td>
    2508. 

  2508.     <td>match_expr</td>
    2509. 

  2509.     <td>module_qualifier</td>
    2510. 

  2510.    </tr><tr>
    2511. 

  2511.     <td>nil</td>
    2512. 

  2512.     <td>operator</td>
    2513. 

  2513.     <td>parentheses</td>
    2514. 

  2514.     <td>prefix_expr</td>
    2515. 

  2515.    </tr><tr>
    2516. 

  2516.     <td>qualified_name</td>
    2517. 

  2517.     <td>query_expr</td>
    2518. 

  2518.     <td>receive_expr</td>
    2519. 

  2519.     <td>record_access</td>
    2520. 

  2520.    </tr><tr>
    2521. 

  2521.     <td>record_expr</td>
    2522. 

  2522.     <td>record_field</td>
    2523. 

  2523.     <td>record_index_expr</td>
    2524. 

  2524.     <td>rule</td>
    2525. 

  2525.    </tr><tr>
    2526. 

  2526.     <td>size_qualifier</td>
    2527. 

  2527.     <td>string</td>
    2528. 

  2528.     <td>text</td>
    2529. 

  2529.     <td>try_expr</td>
    2530. 

  2530.    </tr><tr>
    2531. 

  2531.     <td>tuple</td>
    2532. 

  2532.     <td>underscore</td>
    2533. 

  2533.     <td>variable</td>
    2534. 

  2534.     <td>warning_marker</td>
    2535. 

  2535.    </tr>
    2536. 

  2536.   </table></center></p>
    2537. 

  2537.   <p>The user may (for special purposes) create additional nodes
    2538. 

  2538.   with other type tags, using the <code>tree/2</code> function.</p>
    2539. 

  2539.  
    2540. 

  2540.   <p>Note: The primary constructor functions for a node type should
    2541. 

  2541.   always have the same name as the node type itself.</p>
    2542. 

  2542.  </p>
    2543. 

  2543. <p><b>See also:</b> <a href="#application-3">application/3</a>, <a href="#arity_qualifier-2">arity_qualifier/2</a>, <a href="#atom-1">atom/1</a>, <a href="#attribute-2">attribute/2</a>, <a href="#binary-1">binary/1</a>, <a href="#binary_field-2">binary_field/2</a>, <a href="#block_expr-1">block_expr/1</a>, <a href="#case_expr-2">case_expr/2</a>, <a href="#catch_expr-1">catch_expr/1</a>, <a href="#char-1">char/1</a>, <a href="#class_qualifier-2">class_qualifier/2</a>, <a href="#clause-3">clause/3</a>, <a href="#comment-2">comment/2</a>, <a href="#cond_expr-1">cond_expr/1</a>, <a href="#conjunction-1">conjunction/1</a>, <a href="#disjunction-1">disjunction/1</a>, <a href="#eof_marker-0">eof_marker/0</a>, <a href="#error_marker-1">error_marker/1</a>, <a href="#float-1">float/1</a>, <a href="#form_list-1">form_list/1</a>, <a href="#fun_expr-1">fun_expr/1</a>, <a href="#function-2">function/2</a>, <a href="#generator-2">generator/2</a>, <a href="#if_expr-1">if_expr/1</a>, <a href="#implicit_fun-2">implicit_fun/2</a>, <a href="#infix_expr-3">infix_expr/3</a>, <a href="#integer-1">integer/1</a>, <a href="#list-2">list/2</a>, <a href="#list_comp-2">list_comp/2</a>, <a href="#macro-2">macro/2</a>, <a href="#match_expr-2">match_expr/2</a>, <a href="#module_qualifier-2">module_qualifier/2</a>, <a href="#nil-0">nil/0</a>, <a href="#operator-1">operator/1</a>, <a href="#parentheses-1">parentheses/1</a>, <a href="#prefix_expr-2">prefix_expr/2</a>, <a href="#qualified_name-1">qualified_name/1</a>, <a href="#query_expr-1">query_expr/1</a>, <a href="#receive_expr-3">receive_expr/3</a>, <a href="#record_access-3">record_access/3</a>, <a href="#record_expr-2">record_expr/2</a>, <a href="#record_field-2">record_field/2</a>, <a href="#record_index_expr-2">record_index_expr/2</a>, <a href="#rule-2">rule/2</a>, <a href="#size_qualifier-2">size_qualifier/2</a>, <a href="#string-1">string/1</a>, <a href="#text-1">text/1</a>, <a href="#tree-2">tree/2</a>, <a href="#try_expr-3">try_expr/3</a>, <a href="#tuple-1">tuple/1</a>, <a href="#underscore-0">underscore/0</a>, <a href="#variable-1">variable/1</a>, <a href="#warning_marker-1">warning_marker/1</a>.</p>
    2544. 

  2544. 

  2545. <h3><a name="underscore-0">underscore/0</a></h3>
    2546. 

  2546. <p><tt>underscore() -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2547. 

  2547. <p>Creates an abstract universal pattern ("<code>_</code>"). The
    2548. 

  2548.   lexical representation is a single underscore character. Note that
    2549. 

  2549.   this is <em>not</em> a variable, lexically speaking.
    2550. 

  2550.  </p>
    2551. 

  2551. <p><b>See also:</b> <a href="#variable-1">variable/1</a>.</p>
    2552. 

  2552. 

  2553. <h3><a name="update_tree-2">update_tree/2</a></h3>
    2554. 

  2554. <p><tt>update_tree(Node::<a href="#type-syntaxTree">syntaxTree()</a>, Groups::[[<a href="#type-syntaxTree">syntaxTree()</a>]]) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2555. 

  2555. <p>Creates a syntax tree with the same type and attributes as the
    2556. 

  2556.   given tree. This is equivalent to <code>copy_attrs(Node,
    2557. 

  2557.   make_tree(type(Node), Groups))</code>.
    2558. 

  2558.  </p>
    2559. 

  2559. <p><b>See also:</b> <a href="#copy_attrs-2">copy_attrs/2</a>, <a href="#make_tree-2">make_tree/2</a>, <a href="#type-1">type/1</a>.</p>
    2560. 

  2560. 

  2561. <h3><a name="variable-1">variable/1</a></h3>
    2562. 

  2562. <p><tt>variable(Name) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt>
    2563. 

  2563. <ul><li><tt>Name = atom() | string()</tt></li></ul></p>
    2564. 

  2564. <p>Creates an abstract variable with the given name.
    2565. 

  2565.   <code>Name</code> may be any atom or string that represents a
    2566. 

  2566.   lexically valid variable name, but <em>not</em> a single underscore
    2567. 

  2567.   character; cf. <code>underscore/0</code>.
    2568. 

  2568.  
    2569. 

  2569.   <p>Note: no checking is done whether the character sequence
    2570. 

  2570.   represents a proper variable name, i.e., whether or not its first
    2571. 

  2571.   character is an uppercase Erlang character, or whether it does not
    2572. 

  2572.   contain control characters, whitespace, etc.</p>
    2573. 

  2573.  </p>
    2574. 

  2574. <p><b>See also:</b> <a href="#underscore-0">underscore/0</a>, <a href="#variable_literal-1">variable_literal/1</a>, <a href="#variable_name-1">variable_name/1</a>.</p>
    2575. 

  2575. 

  2576. <h3><a name="variable_literal-1">variable_literal/1</a></h3>
    2577. 

  2577. <p><tt>variable_literal(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; string()</tt></p>
    2578. 

  2578. <p>Returns the name of a <code>variable</code> node as a string.
    2579. 

  2579.  </p>
    2580. 

  2580. <p><b>See also:</b> <a href="#variable-1">variable/1</a>.</p>
    2581. 

  2581. 

  2582. <h3><a name="variable_name-1">variable_name/1</a></h3>
    2583. 

  2583. <p><tt>variable_name(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; atom()</tt></p>
    2584. 

  2584. <p>Returns the name of a <code>variable</code> node as an atom.
    2585. 

  2585.  </p>
    2586. 

  2586. <p><b>See also:</b> <a href="#variable-1">variable/1</a>.</p>
    2587. 

  2587. 

  2588. <h3><a name="warning_marker-1">warning_marker/1</a></h3>
    2589. 

  2589. <p><tt>warning_marker(Error::term()) -&gt; <a href="#type-syntaxTree">syntaxTree()</a></tt></p>
    2590. 

  2590. <p>Creates an abstract warning marker. The result represents an
    2591. 

  2591.   occurrence of a possible problem in the source code, with an
    2592. 

  2592.   associated Erlang I/O ErrorInfo structure given by <code>Error</code>
    2593. 

  2593.   (see module <code>io</code> for details). Warning markers are
    2594. 

  2594.   regarded as source code forms, but have no defined lexical form.
    2595. 

  2595.  
    2596. 

  2596.   <p>Note: this is supported only for backwards compatibility with
    2597. 

  2597.   existing parsers and tools.</p>
    2598. 

  2598.  </p>
    2599. 

  2599. <p><b>See also:</b> <a href="/usr/local/home/richardc/hipe/otp/lib/stdlib/doc/io.html">io</a>, <a href="#eof_marker-0">eof_marker/0</a>, <a href="#error_marker-1">error_marker/1</a>, <a href="#is_form-1">is_form/1</a>, <a href="#warning_marker_info-1">warning_marker_info/1</a>.</p>
    2600. 

  2600. 

  2601. <h3><a name="warning_marker_info-1">warning_marker_info/1</a></h3>
    2602. 

  2602. <p><tt>warning_marker_info(Node::<a href="#type-syntaxTree">syntaxTree()</a>) -&gt; term()</tt></p>
    2603. 

  2603. <p>Returns the ErrorInfo structure of a <code>warning_marker</code>
    2604. 

  2604.   node.
    2605. 

  2605.  </p>
    2606. 

  2606. <p><b>See also:</b> <a href="#warning_marker-1">warning_marker/1</a>.</p>
    2607. 

  2607. </body>
    2608. 

  2608. </html>
    2609.